Alc/midi/sf2load.c

   1
   2 #include "config.h"
   3
   4 #include <stdio.h>
   5 #include <stdlib.h>
   6
   7 #include "alMain.h"
   8 #include "alMidi.h"
   9 #include "alError.h"
  10 #include "alu.h"
  11
  12 #include "midi/base.h"
  13
  14
  15 static ALuint read_le32(Reader *stream)
  16 {
  17     ALubyte buf[4];
  18     if(Reader_read(stream, buf, 4) != 4)
  19         return 0;
  20     return (buf[3]<<24) | (buf[2]<<16) | (buf[1]<<8) | buf[0];
  21 }
  22 static ALushort read_le16(Reader *stream)
  23 {
  24     ALubyte buf[2];
  25     if(Reader_read(stream, buf, 2) != 2)
  26         return 0;
  27     return (buf[1]<<8) | buf[0];
  28 }
  29 static ALubyte read_8(Reader *stream)
  30 {
  31     ALubyte buf[1];
  32     if(Reader_read(stream, buf, 1) != 1)
  33         return 0;
  34     return buf[0];
  35 }
  36 static void skip(Reader *stream, ALuint amt)
  37 {
  38     while(amt > 0 && !READERR(stream))
  39     {
  40         char buf[4096];
  41         amt -= Reader_read(stream, buf, minu(sizeof(buf), amt));
  42     }
  43 }
  44
  45 typedef struct Generator {
  46     ALushort mGenerator;
  47     ALushort mAmount;
  48 } Generator;
  49 static void Generator_read(Generator *self, Reader *stream)
  50 {
  51     self->mGenerator = read_le16(stream);
  52     self->mAmount = read_le16(stream);
  53 }
  54
  55 static const ALint DefaultGenValue[60] = {
  56     0, /* 0 - startAddrOffset */
  57     0, /* 1 - endAddrOffset */
  58     0, /* 2 - startloopAddrOffset */
  59     0, /* 3 - endloopAddrOffset */
  60     0, /* 4 - startAddrCoarseOffset */
  61     0, /* 5 - modLfoToPitch */
  62     0, /* 6 - vibLfoToPitch */
  63     0, /* 7 - modEnvToPitch */
  64     13500, /* 8 - initialFilterFc */
  65     0, /* 9 - initialFilterQ */
  66     0, /* 10 - modLfoToFilterFc */
  67     0, /* 11 - modEnvToFilterFc */
  68     0, /* 12 - endAddrCoarseOffset */
  69     0, /* 13 - modLfoToVolume */
  70     0, /* 14 -  */
  71     0, /* 15 - chorusEffectsSend */
  72     0, /* 16 - reverbEffectsSend */
  73     0, /* 17 - pan */
  74     0, /* 18 -  */
  75     0, /* 19 -  */
  76     0, /* 20 -  */
  77     -12000, /* 21 - delayModLFO */
  78     0, /* 22 - freqModLFO */
  79     -12000, /* 23 - delayVibLFO */
  80     0, /* 24 - freqVibLFO */
  81     -12000, /* 25 - delayModEnv */
  82     -12000, /* 26 - attackModEnv */
  83     -12000, /* 27 - holdModEnv */
  84     -12000, /* 28 - decayModEnv */
  85     0, /* 29 - sustainModEnv */
  86     -12000, /* 30 - releaseModEnv */
  87     0, /* 31 - keynumToModEnvHold */
  88     0, /* 32 - keynumToModEnvDecay */
  89     -12000, /* 33 - delayVolEnv */
  90     -12000, /* 34 - attackVolEnv */
  91     -12000, /* 35 - holdVolEnv */
  92     -12000, /* 36 - decayVolEnv */
  93     0, /* 37 - sustainVolEnv */
  94     -12000, /* 38 - releaseVolEnv */
  95     0, /* 39 - keynumToVolEnvHold */
  96     0, /* 40 - keynumToVolEnvDecay */
  97     0, /* 41 -  */
  98     0, /* 42 -  */
  99     0, /* 43 - keyRange */
 100     0, /* 44 - velRange */
 101     0, /* 45 - startloopAddrCoarseOffset */
 102     0, /* 46 - keynum */
 103     0, /* 47 - velocity */
 104     0, /* 48 - initialAttenuation */
 105     0, /* 49 -  */
 106     0, /* 50 - endloopAddrCoarseOffset */
 107     0, /* 51 - corseTune */
 108     0, /* 52 - fineTune */
 109     0, /* 53 -  */
 110     0, /* 54 - sampleModes */
 111     0, /* 55 -  */
 112     100, /* 56 - scaleTuning */
 113     0, /* 57 - exclusiveClass */
 114     0, /* 58 - overridingRootKey */
 115     0, /* 59 -  */
 116 };
 117
 118 typedef struct Modulator {
 119     ALushort mSrcOp;
 120     ALushort mDstOp;
 121     ALshort mAmount;
 122     ALushort mAmtSrcOp;
 123     ALushort mTransOp;
 124 } Modulator;
 125 static void Modulator_read(Modulator *self, Reader *stream)
 126 {
 127     self->mSrcOp = read_le16(stream);
 128     self->mDstOp = read_le16(stream);
 129     self->mAmount = read_le16(stream);
 130     self->mAmtSrcOp = read_le16(stream);
 131     self->mTransOp = read_le16(stream);
 132 }
 133
 134 typedef struct Zone {
 135     ALushort mGenIdx;
 136     ALushort mModIdx;
 137 } Zone;
 138 static void Zone_read(Zone *self, Reader *stream)
 139 {
 140     self->mGenIdx = read_le16(stream);
 141     self->mModIdx = read_le16(stream);
 142 }
 143
 144 typedef struct PresetHeader {
 145     ALchar mName[20];
 146     ALushort mPreset; /* MIDI program number */
 147     ALushort mBank;
 148     ALushort mZoneIdx;
 149     ALuint mLibrary;
 150     ALuint mGenre;
 151     ALuint mMorphology;
 152 } PresetHeader;
 153 static void PresetHeader_read(PresetHeader *self, Reader *stream)
 154 {
 155     Reader_read(stream, self->mName, sizeof(self->mName));
 156     self->mPreset = read_le16(stream);
 157     self->mBank = read_le16(stream);
 158     self->mZoneIdx = read_le16(stream);
 159     self->mLibrary = read_le32(stream);
 160     self->mGenre = read_le32(stream);
 161     self->mMorphology = read_le32(stream);
 162 }
 163
 164 typedef struct InstrumentHeader {
 165     ALchar mName[20];
 166     ALushort mZoneIdx;
 167 } InstrumentHeader;
 168 static void InstrumentHeader_read(InstrumentHeader *self, Reader *stream)
 169 {
 170     Reader_read(stream, self->mName, sizeof(self->mName));
 171     self->mZoneIdx = read_le16(stream);
 172 }
 173
 174 typedef struct SampleHeader {
 175     ALchar mName[20];
 176     ALuint mStart;
 177     ALuint mEnd;
 178     ALuint mStartloop;
 179     ALuint mEndloop;
 180     ALuint mSampleRate;
 181     ALubyte mOriginalKey;
 182     ALbyte mCorrection;
 183     ALushort mSampleLink;
 184     ALushort mSampleType;
 185 } SampleHeader;
 186 static void SampleHeader_read(SampleHeader *self, Reader *stream)
 187 {
 188     Reader_read(stream, self->mName, sizeof(self->mName));
 189     self->mStart = read_le32(stream);
 190     self->mEnd = read_le32(stream);
 191     self->mStartloop = read_le32(stream);
 192     self->mEndloop = read_le32(stream);
 193     self->mSampleRate = read_le32(stream);
 194     self->mOriginalKey = read_8(stream);
 195     self->mCorrection = read_8(stream);
 196     self->mSampleLink = read_le16(stream);
 197     self->mSampleType = read_le16(stream);
 198 }
 199
 200
 201 typedef struct Soundfont {
 202     ALuint ifil;
 203     ALchar *irom;
 204
 205     PresetHeader *phdr;
 206     ALsizei phdr_size;
 207
 208     Zone *pbag;
 209     ALsizei pbag_size;
 210     Modulator *pmod;
 211     ALsizei pmod_size;
 212     Generator *pgen;
 213     ALsizei pgen_size;
 214
 215     InstrumentHeader *inst;
 216     ALsizei inst_size;
 217
 218     Zone *ibag;
 219     ALsizei ibag_size;
 220     Modulator *imod;
 221     ALsizei imod_size;
 222     Generator *igen;
 223     ALsizei igen_size;
 224
 225     SampleHeader *shdr;
 226     ALsizei shdr_size;
 227 } Soundfont;
 228
 229 static void Soundfont_Construct(Soundfont *self)
 230 {
 231     self->ifil = 0;
 232     self->irom = NULL;
 233
 234     self->phdr = NULL;
 235     self->phdr_size = 0;
 236
 237     self->pbag = NULL;
 238     self->pbag_size = 0;
 239     self->pmod = NULL;
 240     self->pmod_size = 0;
 241     self->pgen = NULL;
 242     self->pgen_size = 0;
 243
 244     self->inst = NULL;
 245     self->inst_size = 0;
 246
 247     self->ibag = NULL;
 248     self->ibag_size = 0;
 249     self->imod = NULL;
 250     self->imod_size = 0;
 251     self->igen = NULL;
 252     self->igen_size = 0;
 253
 254     self->shdr = NULL;
 255     self->shdr_size = 0;
 256 }
 257
 258 static void Soundfont_Destruct(Soundfont *self)
 259 {
 260     free(self->irom);
 261     self->irom = NULL;
 262
 263     free(self->phdr);
 264     self->phdr = NULL;
 265     self->phdr_size = 0;
 266
 267     free(self->pbag);
 268     self->pbag = NULL;
 269     self->pbag_size = 0;
 270     free(self->pmod);
 271     self->pmod = NULL;
 272     self->pmod_size = 0;
 273     free(self->pgen);
 274     self->pgen = NULL;
 275     self->pgen_size = 0;
 276
 277     free(self->inst);
 278     self->inst = NULL;
 279     self->inst_size = 0;
 280
 281     free(self->ibag);
 282     self->ibag = NULL;
 283     self->ibag_size = 0;
 284     free(self->imod);
 285     self->imod = NULL;
 286     self->imod_size = 0;
 287     free(self->igen);
 288     self->igen = NULL;
 289     self->igen_size = 0;
 290
 291     free(self->shdr);
 292     self->shdr = NULL;
 293     self->shdr_size = 0;
 294 }
 295
 296
 297 #define FOURCC(a,b,c,d) ((a) | ((b)<<8) | ((c)<<16) | ((d)<<24))
 298 #define FOURCCFMT     "%c%c%c%c"
 299 #define FOURCCARGS(x)  (char)((x)&0xff), (char)(((x)>>8)&0xff), (char)(((x)>>16)&0xff), (char)(((x)>>24)&0xff)
 300 typedef struct RiffHdr {
 301     ALuint mCode;
 302     ALuint mSize;
 303 } RiffHdr;
 304 static void RiffHdr_read(RiffHdr *self, Reader *stream)
 305 {
 306     self->mCode = read_le32(stream);
 307     self->mSize = read_le32(stream);
 308 }
 309
 310
 311 typedef struct GenModList {
 312     VECTOR(Generator) gens;
 313     VECTOR(Modulator) mods;
 314 } GenModList;
 315
 316 static void GenModList_Construct(GenModList *self)
 317 {
 318     VECTOR_INIT(self->gens);
 319     VECTOR_INIT(self->mods);
 320 }
 321
 322 static void GenModList_Destruct(GenModList *self)
 323 {
 324     VECTOR_DEINIT(self->mods);
 325     VECTOR_DEINIT(self->gens);
 326 }
 327
 328 static GenModList GenModList_clone(const GenModList *self)
 329 {
 330     GenModList ret;
 331
 332     GenModList_Construct(&ret);
 333
 334     VECTOR_INSERT(ret.gens, VECTOR_ITER_END(ret.gens),
 335         VECTOR_ITER_BEGIN(self->gens), VECTOR_ITER_END(self->gens)
 336     );
 337     VECTOR_INSERT(ret.mods, VECTOR_ITER_END(ret.mods),
 338         VECTOR_ITER_BEGIN(self->mods), VECTOR_ITER_END(self->mods)
 339     );
 340
 341     return ret;
 342 }
 343
 344 static void GenModList_insertGen(GenModList *self, const Generator *gen, ALboolean ispreset)
 345 {
 346     Generator *i = VECTOR_ITER_BEGIN(self->gens);
 347     Generator *end = VECTOR_ITER_END(self->gens);
 348     for(;i != end;i++)
 349     {
 350         if(i->mGenerator == gen->mGenerator)
 351         {
 352             i->mAmount = gen->mAmount;
 353             return;
 354         }
 355     }
 356
 357     if(ispreset &&
 358        (gen->mGenerator == 0 || gen->mGenerator == 1 || gen->mGenerator == 2 ||
 359         gen->mGenerator == 3 || gen->mGenerator == 4 || gen->mGenerator == 12 ||
 360         gen->mGenerator == 45 || gen->mGenerator == 46 || gen->mGenerator == 47 ||
 361         gen->mGenerator == 50 || gen->mGenerator == 54 || gen->mGenerator == 57 ||
 362         gen->mGenerator == 58))
 363         return;
 364
 365     if(VECTOR_PUSH_BACK(self->gens, *gen) == AL_FALSE)
 366     {
 367         ERR("Failed to insert generator (from %d elements)\n", VECTOR_SIZE(self->gens));
 368         return;
 369     }
 370 }
 371 static void GenModList_accumGen(GenModList *self, const Generator *gen)
 372 {
 373     Generator *i = VECTOR_ITER_BEGIN(self->gens);
 374     Generator *end = VECTOR_ITER_END(self->gens);
 375     for(;i != end;i++)
 376     {
 377         if(i->mGenerator == gen->mGenerator)
 378         {
 379             if(gen->mGenerator == 43 || gen->mGenerator == 44)
 380             {
 381                 /* Range generators accumulate by taking the intersection of
 382                  * the two ranges.
 383                  */
 384                 ALushort low = maxu(i->mAmount&0x00ff, gen->mAmount&0x00ff);
 385                 ALushort high = minu(i->mAmount&0xff00, gen->mAmount&0xff00);
 386                 i->mAmount = low | high;
 387             }
 388             else
 389                 i->mAmount += gen->mAmount;
 390             return;
 391         }
 392     }
 393
 394     if(VECTOR_PUSH_BACK(self->gens, *gen) == AL_FALSE)
 395     {
 396         ERR("Failed to insert generator (from %d elements)\n", VECTOR_SIZE(self->gens));
 397         return;
 398     }
 399     if(gen->mGenerator < 60)
 400         VECTOR_BACK(self->gens).mAmount += DefaultGenValue[gen->mGenerator];
 401 }
 402
 403 static void GenModList_insertMod(GenModList *self, const Modulator *mod)
 404 {
 405     Modulator *i = VECTOR_ITER_BEGIN(self->mods);
 406     Modulator *end = VECTOR_ITER_END(self->mods);
 407     for(;i != end;i++)
 408     {
 409         if(i->mDstOp == mod->mDstOp && i->mSrcOp == mod->mSrcOp &&
 410            i->mAmtSrcOp == mod->mAmtSrcOp && i->mTransOp == mod->mTransOp)
 411         {
 412             i->mAmount = mod->mAmount;
 413             return;
 414         }
 415     }
 416
 417     if(VECTOR_PUSH_BACK(self->mods, *mod) == AL_FALSE)
 418     {
 419         ERR("Failed to insert modulator (from %d elements)\n", VECTOR_SIZE(self->mods));
 420         return;
 421     }
 422 }
 423 static void GenModList_accumMod(GenModList *self, const Modulator *mod)
 424 {
 425     Modulator *i = VECTOR_ITER_BEGIN(self->mods);
 426     Modulator *end = VECTOR_ITER_END(self->mods);
 427     for(;i != end;i++)
 428     {
 429         if(i->mDstOp == mod->mDstOp && i->mSrcOp == mod->mSrcOp &&
 430            i->mAmtSrcOp == mod->mAmtSrcOp && i->mTransOp == mod->mTransOp)
 431         {
 432             i->mAmount += mod->mAmount;
 433             return;
 434         }
 435     }
 436
 437     if(VECTOR_PUSH_BACK(self->mods, *mod) == AL_FALSE)
 438     {
 439         ERR("Failed to insert modulator (from %d elements)\n", VECTOR_SIZE(self->mods));
 440         return;
 441     }
 442
 443     if(mod->mSrcOp == 0x0502 && mod->mDstOp == 48 && mod->mAmtSrcOp == 0 && mod->mTransOp == 0)
 444         VECTOR_BACK(self->mods).mAmount += 960;
 445     else if(mod->mSrcOp == 0x0102 && mod->mDstOp == 8 && mod->mAmtSrcOp == 0 && mod->mTransOp == 0)
 446         VECTOR_BACK(self->mods).mAmount += -2400;
 447     else if(mod->mSrcOp == 0x000D && mod->mDstOp == 6 && mod->mAmtSrcOp == 0 && mod->mTransOp == 0)
 448         VECTOR_BACK(self->mods).mAmount += 50;
 449     else if(mod->mSrcOp == 0x0081 && mod->mDstOp == 6 && mod->mAmtSrcOp == 0 && mod->mTransOp == 0)
 450         VECTOR_BACK(self->mods).mAmount += 50;
 451     else if(mod->mSrcOp == 0x0582 && mod->mDstOp == 48 && mod->mAmtSrcOp == 0 && mod->mTransOp == 0)
 452         VECTOR_BACK(self->mods).mAmount += 960;
 453     else if(mod->mSrcOp == 0x028A && mod->mDstOp == 17 && mod->mAmtSrcOp == 0 && mod->mTransOp == 0)
 454         VECTOR_BACK(self->mods).mAmount += 1000;
 455     else if(mod->mSrcOp == 0x058B && mod->mDstOp == 48 && mod->mAmtSrcOp == 0 && mod->mTransOp == 0)
 456         VECTOR_BACK(self->mods).mAmount += 960;
 457     else if(mod->mSrcOp == 0x00DB && mod->mDstOp == 16 && mod->mAmtSrcOp == 0 && mod->mTransOp == 0)
 458         VECTOR_BACK(self->mods).mAmount += 200;
 459     else if(mod->mSrcOp == 0x00DD && mod->mDstOp == 15 && mod->mAmtSrcOp == 0 && mod->mTransOp == 0)
 460         VECTOR_BACK(self->mods).mAmount += 200;
 461     /*else if(mod->mSrcOp == 0x020E && mod->mDstOp == ?initialpitch? && mod->mAmtSrcOp == 0x0010 && mod->mTransOp == 0)
 462         VECTOR_BACK(self->mods).mAmount += 12700;*/
 463 }
 464
 465
 466 #define ERROR_GOTO(lbl_, ...)  do {                                           \
 467     ERR(__VA_ARGS__);                                                         \
 468     goto lbl_;                                                                \
 469 } while(0)
 470
 471 static ALboolean ensureFontSanity(const Soundfont *sfont)
 472 {
 473     ALsizei i;
 474
 475     for(i = 0;i < sfont->phdr_size;i++)
 476     {
 477         if(sfont->phdr[i].mZoneIdx >= sfont->pbag_size)
 478         {
 479             WARN("Preset %d has invalid zone index %d (max: %d)\n", i,
 480                  sfont->phdr[i].mZoneIdx, sfont->pbag_size);
 481             return AL_FALSE;
 482         }
 483         if(i+1 < sfont->phdr_size && sfont->phdr[i+1].mZoneIdx < sfont->phdr[i].mZoneIdx)
 484         {
 485             WARN("Preset %d has invalid zone index (%d does not follow %d)\n", i+1,
 486                  sfont->phdr[i+1].mZoneIdx, sfont->phdr[i].mZoneIdx);
 487             return AL_FALSE;
 488         }
 489     }
 490
 491     for(i = 0;i < sfont->pbag_size;i++)
 492     {
 493         if(sfont->pbag[i].mGenIdx >= sfont->pgen_size)
 494         {
 495             WARN("Preset zone %d has invalid generator index %d (max: %d)\n", i,
 496                  sfont->pbag[i].mGenIdx, sfont->pgen_size);
 497             return AL_FALSE;
 498         }
 499         if(i+1 < sfont->pbag_size && sfont->pbag[i+1].mGenIdx < sfont->pbag[i].mGenIdx)
 500         {
 501             WARN("Preset zone %d has invalid generator index (%d does not follow %d)\n", i+1,
 502                  sfont->pbag[i+1].mGenIdx, sfont->pbag[i].mGenIdx);
 503             return AL_FALSE;
 504         }
 505         if(sfont->pbag[i].mModIdx >= sfont->pmod_size)
 506         {
 507             WARN("Preset zone %d has invalid modulator index %d (max: %d)\n", i,
 508                  sfont->pbag[i].mModIdx, sfont->pmod_size);
 509             return AL_FALSE;
 510         }
 511         if(i+1 < sfont->pbag_size && sfont->pbag[i+1].mModIdx < sfont->pbag[i].mModIdx)
 512         {
 513             WARN("Preset zone %d has invalid modulator index (%d does not follow %d)\n", i+1,
 514                  sfont->pbag[i+1].mModIdx, sfont->pbag[i].mModIdx);
 515             return AL_FALSE;
 516         }
 517     }
 518
 519
 520     for(i = 0;i < sfont->inst_size;i++)
 521     {
 522         if(sfont->inst[i].mZoneIdx >= sfont->ibag_size)
 523         {
 524             WARN("Instrument %d has invalid zone index %d (max: %d)\n", i,
 525                  sfont->inst[i].mZoneIdx, sfont->ibag_size);
 526             return AL_FALSE;
 527         }
 528         if(i+1 < sfont->inst_size && sfont->inst[i+1].mZoneIdx < sfont->inst[i].mZoneIdx)
 529         {
 530             WARN("Instrument %d has invalid zone index (%d does not follow %d)\n", i+1,
 531                  sfont->inst[i+1].mZoneIdx, sfont->inst[i].mZoneIdx);
 532             return AL_FALSE;
 533         }
 534     }
 535
 536     for(i = 0;i < sfont->ibag_size;i++)
 537     {
 538         if(sfont->ibag[i].mGenIdx >= sfont->igen_size)
 539         {
 540             WARN("Instrument zone %d has invalid generator index %d (max: %d)\n", i,
 541                  sfont->ibag[i].mGenIdx, sfont->igen_size);
 542             return AL_FALSE;
 543         }
 544         if(i+1 < sfont->ibag_size && sfont->ibag[i+1].mGenIdx < sfont->ibag[i].mGenIdx)
 545         {
 546             WARN("Instrument zone %d has invalid generator index (%d does not follow %d)\n", i+1,
 547                  sfont->ibag[i+1].mGenIdx, sfont->ibag[i].mGenIdx);
 548             return AL_FALSE;
 549         }
 550         if(sfont->ibag[i].mModIdx >= sfont->imod_size)
 551         {
 552             WARN("Instrument zone %d has invalid modulator index %d (max: %d)\n", i,
 553                  sfont->ibag[i].mModIdx, sfont->imod_size);
 554             return AL_FALSE;
 555         }
 556         if(i+1 < sfont->ibag_size && sfont->ibag[i+1].mModIdx < sfont->ibag[i].mModIdx)
 557         {
 558             WARN("Instrument zone %d has invalid modulator index (%d does not follow %d)\n", i+1,
 559                  sfont->ibag[i+1].mModIdx, sfont->ibag[i].mModIdx);
 560             return AL_FALSE;
 561         }
 562     }
 563
 564
 565     for(i = 0;i < sfont->shdr_size-1;i++)
 566     {
 567         if((sfont->shdr[i].mSampleType&0x8000) && sfont->irom == NULL)
 568         {
 569             WARN("Sample header %d has ROM sample type without an irom sub-chunk\n", i);
 570             return AL_FALSE;
 571         }
 572     }
 573
 574
 575     return AL_TRUE;
 576 }
 577
 578 static ALboolean checkZone(const GenModList *zone, const PresetHeader *preset, const InstrumentHeader *inst, const SampleHeader *samp)
 579 {
 580     Generator *gen = VECTOR_ITER_BEGIN(zone->gens);
 581     Generator *gen_end = VECTOR_ITER_END(zone->gens);
 582     for(;gen != gen_end;gen++)
 583     {
 584         if(gen->mGenerator == 43 || gen->mGenerator == 44)
 585         {
 586             int high = gen->mAmount>>8;
 587             int low = gen->mAmount&0xff;
 588
 589             if(!(low >= 0 && high <= 127 && high >= low))
 590             {
 591                 TRACE("Preset \"%s\", inst \"%s\", sample \"%s\": invalid %s range %d...%d\n",
 592                       preset->mName, inst->mName, samp->mName,
 593                       (gen->mGenerator == 43) ? "key" :
 594                       (gen->mGenerator == 44) ? "velocity" : "(unknown)",
 595                       low, high);
 596                 return AL_FALSE;
 597             }
 598         }
 599     }
 600
 601     return AL_TRUE;
 602 }
 603
 604 static ALenum getModSrcInput(int input)
 605 {
 606     if(input == 0) return AL_ONE_SOFT;
 607     if(input == 2) return AL_NOTEON_VELOCITY_SOFT;
 608     if(input == 3) return AL_NOTEON_KEY_SOFT;
 609     if(input == 10) return AL_KEYPRESSURE_SOFT;
 610     if(input == 13) return AL_CHANNELPRESSURE_SOFT;
 611     if(input == 14) return AL_PITCHBEND_SOFT;
 612     if(input == 16) return AL_PITCHBEND_SENSITIVITY_SOFT;
 613     if((input&0x80))
 614     {
 615         if(IsValidCtrlInput(input^0x80))
 616             return input^0x80;
 617     }
 618     ERR("Unhandled modulator source input: 0x%02x\n", input);
 619     return AL_INVALID;
 620 }
 621
 622 static ALenum getModSrcType(int type)
 623 {
 624     if(type == 0x0000) return AL_UNORM_SOFT;
 625     if(type == 0x0100) return AL_UNORM_REV_SOFT;
 626     if(type == 0x0200) return AL_SNORM_SOFT;
 627     if(type == 0x0300) return AL_SNORM_REV_SOFT;
 628     ERR("Unhandled modulator source type: 0x%04x\n", type);
 629     return AL_INVALID;
 630 }
 631
 632 static ALenum getModSrcForm(int form)
 633 {
 634     if(form == 0x0000) return AL_LINEAR_SOFT;
 635     if(form == 0x0400) return AL_CONCAVE_SOFT;
 636     if(form == 0x0800) return AL_CONVEX_SOFT;
 637     if(form == 0x0C00) return AL_SWITCH_SOFT;
 638     ERR("Unhandled modulator source form: 0x%04x\n", form);
 639     return AL_INVALID;
 640 }
 641
 642 static ALenum getModTransOp(int op)
 643 {
 644     if(op == 0) return AL_LINEAR_SOFT;
 645     if(op == 2) return AL_ABSOLUTE_SOFT;
 646     ERR("Unhandled modulator transform op: 0x%04x\n", op);
 647     return AL_INVALID;
 648 }
 649
 650 static ALenum getLoopMode(int mode)
 651 {
 652     if(mode == 0) return AL_NONE;
 653     if(mode == 1) return AL_LOOP_CONTINUOUS_SOFT;
 654     if(mode == 3) return AL_LOOP_UNTIL_RELEASE_SOFT;
 655     ERR("Unhandled loop mode: %d\n", mode);
 656     return AL_NONE;
 657 }
 658
 659 static ALenum getSampleType(int type)
 660 {
 661     if(type == 1) return AL_MONO_SOFT;
 662     if(type == 2) return AL_RIGHT_SOFT;
 663     if(type == 4) return AL_LEFT_SOFT;
 664     if(type == 8)
 665     {
 666         WARN("Sample type \"linked\" ignored; pretending mono\n");
 667         return AL_MONO_SOFT;
 668     }
 669     ERR("Unhandled sample type: 0x%04x\n", type);
 670     return AL_MONO_SOFT;
 671 }
 672
 673 static void fillZone(ALfontsound *sound, ALCcontext *context, const GenModList *zone)
 674 {
 675     static const ALenum Gen2Param[60] = {
 676         0, /* 0 - startAddrOffset */
 677         0, /* 1 - endAddrOffset */
 678         0, /* 2 - startloopAddrOffset */
 679         0, /* 3 - endloopAddrOffset */
 680         0, /* 4 - startAddrCoarseOffset */
 681         AL_MOD_LFO_TO_PITCH_SOFT, /* 5 - modLfoToPitch */
 682         AL_VIBRATO_LFO_TO_PITCH_SOFT, /* 6 - vibLfoToPitch */
 683         AL_MOD_ENV_TO_PITCH_SOFT, /* 7 - modEnvToPitch */
 684         AL_FILTER_CUTOFF_SOFT, /* 8 - initialFilterFc */
 685         AL_FILTER_RESONANCE_SOFT, /* 9 - initialFilterQ */
 686         AL_MOD_LFO_TO_FILTER_CUTOFF_SOFT, /* 10 - modLfoToFilterFc */
 687         AL_MOD_ENV_TO_FILTER_CUTOFF_SOFT, /* 11 - modEnvToFilterFc */
 688         0, /* 12 - endAddrCoarseOffset */
 689         AL_MOD_LFO_TO_VOLUME_SOFT, /* 13 - modLfoToVolume */
 690         0, /* 14 -  */
 691         AL_CHORUS_SEND_SOFT, /* 15 - chorusEffectsSend */
 692         AL_REVERB_SEND_SOFT, /* 16 - reverbEffectsSend */
 693         AL_PAN_SOFT, /* 17 - pan */
 694         0, /* 18 -  */
 695         0, /* 19 -  */
 696         0, /* 20 -  */
 697         AL_MOD_LFO_DELAY_SOFT, /* 21 - delayModLFO */
 698         AL_MOD_LFO_FREQUENCY_SOFT, /* 22 - freqModLFO */
 699         AL_VIBRATO_LFO_DELAY_SOFT, /* 23 - delayVibLFO */
 700         AL_VIBRATO_LFO_FREQUENCY_SOFT, /* 24 - freqVibLFO */
 701         AL_MOD_ENV_DELAYTIME_SOFT, /* 25 - delayModEnv */
 702         AL_MOD_ENV_ATTACKTIME_SOFT, /* 26 - attackModEnv */
 703         AL_MOD_ENV_HOLDTIME_SOFT, /* 27 - holdModEnv */
 704         AL_MOD_ENV_DECAYTIME_SOFT, /* 28 - decayModEnv */
 705         AL_MOD_ENV_SUSTAINVOLUME_SOFT, /* 29 - sustainModEnv */
 706         AL_MOD_ENV_RELEASETIME_SOFT, /* 30 - releaseModEnv */
 707         AL_MOD_ENV_KEY_TO_HOLDTIME_SOFT, /* 31 - keynumToModEnvHold */
 708         AL_MOD_ENV_KEY_TO_DECAYTIME_SOFT, /* 32 - keynumToModEnvDecay */
 709         AL_VOLUME_ENV_DELAYTIME_SOFT, /* 33 - delayVolEnv */
 710         AL_VOLUME_ENV_ATTACKTIME_SOFT, /* 34 - attackVolEnv */
 711         AL_VOLUME_ENV_HOLDTIME_SOFT, /* 35 - holdVolEnv */
 712         AL_VOLUME_ENV_DECAYTIME_SOFT, /* 36 - decayVolEnv */
 713         AL_VOLUME_ENV_SUSTAINVOLUME_SOFT, /* 37 - sustainVolEnv */
 714         AL_VOLUME_ENV_RELEASETIME_SOFT, /* 38 - releaseVolEnv */
 715         AL_VOLUME_ENV_KEY_TO_HOLDTIME_SOFT, /* 39 - keynumToVolEnvHold */
 716         AL_VOLUME_ENV_KEY_TO_DECAYTIME_SOFT, /* 40 - keynumToVolEnvDecay */
 717         0, /* 41 -  */
 718         0, /* 42 -  */
 719         AL_KEY_RANGE_SOFT, /* 43 - keyRange */
 720         AL_VELOCITY_RANGE_SOFT, /* 44 - velRange */
 721         0, /* 45 - startloopAddrCoarseOffset */
 722         0, /* 46 - keynum */
 723         0, /* 47 - velocity */
 724         AL_ATTENUATION_SOFT, /* 48 - initialAttenuation */
 725         0, /* 49 -  */
 726         0, /* 50 - endloopAddrCoarseOffset */
 727         AL_TUNING_COARSE_SOFT, /* 51 - corseTune */
 728         AL_TUNING_FINE_SOFT, /* 52 - fineTune */
 729         0, /* 53 -  */
 730         AL_LOOP_MODE_SOFT, /* 54 - sampleModes */
 731         0, /* 55 -  */
 732         AL_TUNING_SCALE_SOFT, /* 56 - scaleTuning */
 733         AL_EXCLUSIVE_CLASS_SOFT, /* 57 - exclusiveClass */
 734         AL_BASE_KEY_SOFT, /* 58 - overridingRootKey */
 735         0, /* 59 -  */
 736     };
 737     const Generator *gen, *gen_end;
 738     const Modulator *mod, *mod_end;
 739
 740     mod = VECTOR_ITER_BEGIN(zone->mods);
 741     mod_end = VECTOR_ITER_END(zone->mods);
 742     for(;mod != mod_end;mod++)
 743     {
 744         ALenum src0in = getModSrcInput(mod->mSrcOp&0xFF);
 745         ALenum src0type = getModSrcType(mod->mSrcOp&0x0300);
 746         ALenum src0form = getModSrcForm(mod->mSrcOp&0xFC00);
 747         ALenum src1in = getModSrcInput(mod->mAmtSrcOp&0xFF);
 748         ALenum src1type = getModSrcType(mod->mAmtSrcOp&0x0300);
 749         ALenum src1form = getModSrcForm(mod->mAmtSrcOp&0xFC00);
 750         ALenum trans = getModTransOp(mod->mTransOp);
 751         ALenum dst = (mod->mDstOp < 60) ? Gen2Param[mod->mDstOp] : 0;
 752         if(!dst || dst == AL_KEY_RANGE_SOFT || dst == AL_VELOCITY_RANGE_SOFT ||
 753            dst == AL_LOOP_MODE_SOFT || dst == AL_EXCLUSIVE_CLASS_SOFT ||
 754            dst == AL_BASE_KEY_SOFT)
 755             ERR("Unhandled modulator destination: %d\n", mod->mDstOp);
 756         else if(src0in != AL_INVALID && src0form != AL_INVALID && src0type != AL_INVALID &&
 757                 src1in != AL_INVALID && src1form != AL_INVALID && src0type != AL_INVALID &&
 758                 trans != AL_INVALID)
 759         {
 760             ALsizei idx = (ALsizei)(mod - VECTOR_ITER_BEGIN(zone->mods));
 761             ALfontsound_setModStagei(sound, context, idx, AL_SOURCE0_INPUT_SOFT, src0in);
 762             ALfontsound_setModStagei(sound, context, idx, AL_SOURCE0_TYPE_SOFT, src0type);
 763             ALfontsound_setModStagei(sound, context, idx, AL_SOURCE0_FORM_SOFT, src0form);
 764             ALfontsound_setModStagei(sound, context, idx, AL_SOURCE1_INPUT_SOFT, src1in);
 765             ALfontsound_setModStagei(sound, context, idx, AL_SOURCE1_TYPE_SOFT, src1type);
 766             ALfontsound_setModStagei(sound, context, idx, AL_SOURCE1_FORM_SOFT, src1form);
 767             ALfontsound_setModStagei(sound, context, idx, AL_AMOUNT_SOFT, mod->mAmount);
 768             ALfontsound_setModStagei(sound, context, idx, AL_TRANSFORM_OP_SOFT, trans);
 769             ALfontsound_setModStagei(sound, context, idx, AL_DESTINATION_SOFT, dst);
 770         }
 771     }
 772
 773     gen = VECTOR_ITER_BEGIN(zone->gens);
 774     gen_end = VECTOR_ITER_END(zone->gens);
 775     for(;gen != gen_end;gen++)
 776     {
 777         ALint value = (ALshort)gen->mAmount;
 778         if(gen->mGenerator == 0)
 779             sound->Start += value;
 780         else if(gen->mGenerator == 1)
 781             sound->End += value;
 782         else if(gen->mGenerator == 2)
 783             sound->LoopStart += value;
 784         else if(gen->mGenerator == 3)
 785             sound->LoopEnd += value;
 786         else if(gen->mGenerator == 4)
 787             sound->Start += value<<15;
 788         else if(gen->mGenerator == 12)
 789             sound->End += value<<15;
 790         else if(gen->mGenerator == 45)
 791             sound->LoopStart += value<<15;
 792         else if(gen->mGenerator == 50)
 793             sound->LoopEnd += value<<15;
 794         else if(gen->mGenerator == 43)
 795         {
 796             sound->MinKey = mini((value&0xff), 127);
 797             sound->MaxKey = mini(((value>>8)&0xff), 127);
 798         }
 799         else if(gen->mGenerator == 44)
 800         {
 801             sound->MinVelocity = mini((value&0xff), 127);
 802             sound->MaxVelocity = mini(((value>>8)&0xff), 127);
 803         }
 804         else
 805         {
 806             ALenum param = 0;
 807             if(gen->mGenerator < 60)
 808                 param = Gen2Param[gen->mGenerator];
 809             if(param)
 810             {
 811                 if(param == AL_BASE_KEY_SOFT)
 812                 {
 813                     if(!(value >= 0 && value <= 127))
 814                     {
 815                         if(value != -1)
 816                             WARN("Invalid overridingRootKey generator value %d\n", value);
 817                         continue;
 818                     }
 819                 }
 820                 if(param == AL_FILTER_RESONANCE_SOFT || param == AL_ATTENUATION_SOFT)
 821                     value = maxi(0, value);
 822                 else if(param == AL_CHORUS_SEND_SOFT || param == AL_REVERB_SEND_SOFT)
 823                     value = clampi(value, 0, 1000);
 824                 else if(param == AL_LOOP_MODE_SOFT)
 825                     value = getLoopMode(value);
 826                 ALfontsound_setPropi(sound, context, param, value);
 827             }
 828             else
 829             {
 830                 static ALuint warned[65536/32];
 831                 if(!(warned[gen->mGenerator/32]&(1<<(gen->mGenerator&31))))
 832                 {
 833                     warned[gen->mGenerator/32] |= 1<<(gen->mGenerator&31);
 834                     ERR("Unhandled generator %d\n", gen->mGenerator);
 835                 }
 836             }
 837         }
 838     }
 839 }
 840
 841 static void processInstrument(ALfontsound ***sounds, ALsizei *sounds_size, ALCcontext *context, ALbuffer *buffer, InstrumentHeader *inst, const PresetHeader *preset, const Soundfont *sfont, const GenModList *pzone)
 842 {
 843     const Generator *gen, *gen_end;
 844     const Modulator *mod, *mod_end;
 845     const Zone *zone, *zone_end;
 846     GenModList gzone;
 847     ALvoid *temp;
 848
 849     if((inst+1)->mZoneIdx == inst->mZoneIdx)
 850         ERR("Instrument with no zones!");
 851
 852     GenModList_Construct(&gzone);
 853     zone = sfont->ibag + inst->mZoneIdx;
 854     zone_end = sfont->ibag + (inst+1)->mZoneIdx;
 855     if(zone_end-zone > 1)
 856     {
 857         gen = sfont->igen + zone->mGenIdx;
 858         gen_end = sfont->igen + (zone+1)->mGenIdx;
 859
 860         // If no generators, or last generator is not a sample, this is a global zone
 861         for(;gen != gen_end;gen++)
 862         {
 863             if(gen->mGenerator == 53)
 864                 break;
 865         }
 866
 867         if(gen == gen_end)
 868         {
 869             gen = sfont->igen + zone->mGenIdx;
 870             gen_end = sfont->igen + (zone+1)->mGenIdx;
 871             for(;gen != gen_end;gen++)
 872                 GenModList_insertGen(&gzone, gen, AL_FALSE);
 873
 874             mod = sfont->imod + zone->mModIdx;
 875             mod_end = sfont->imod + (zone+1)->mModIdx;
 876             for(;mod != mod_end;mod++)
 877                 GenModList_insertMod(&gzone, mod);
 878
 879             zone++;
 880         }
 881     }
 882
 883     temp = realloc(*sounds, (zone_end-zone + *sounds_size)*sizeof((*sounds)[0]));
 884     if(!temp)
 885     {
 886         ERR("Failed reallocating fontsound storage to %d elements (from %d)\n",
 887             (ALsizei)(zone_end-zone) + *sounds_size, *sounds_size);
 888         return;
 889     }
 890     *sounds = temp;
 891     for(;zone != zone_end;zone++)
 892     {
 893         GenModList lzone = GenModList_clone(&gzone);
 894         mod = sfont->imod + zone->mModIdx;
 895         mod_end = sfont->imod + (zone+1)->mModIdx;
 896         for(;mod != mod_end;mod++)
 897             GenModList_insertMod(&lzone, mod);
 898
 899         gen = sfont->igen + zone->mGenIdx;
 900         gen_end = sfont->igen + (zone+1)->mGenIdx;
 901         for(;gen != gen_end;gen++)
 902         {
 903             if(gen->mGenerator == 53)
 904             {
 905                 const SampleHeader *samp;
 906                 ALfontsound *sound;
 907
 908                 if(gen->mAmount >= sfont->shdr_size-1)
 909                 {
 910                     ERR("Generator %ld has invalid sample ID (%d of %d)\n",
 911                         (long)(gen-sfont->igen), gen->mAmount, sfont->shdr_size-1);
 912                     break;
 913                 }
 914                 samp = &sfont->shdr[gen->mAmount];
 915
 916                 gen = VECTOR_ITER_BEGIN(pzone->gens);
 917                 gen_end = VECTOR_ITER_END(pzone->gens);
 918                 for(;gen != gen_end;gen++)
 919                     GenModList_accumGen(&lzone, gen);
 920
 921                 mod = VECTOR_ITER_BEGIN(pzone->mods);
 922                 mod_end = VECTOR_ITER_END(pzone->mods);
 923                 for(;mod != mod_end;mod++)
 924                     GenModList_accumMod(&lzone, mod);
 925
 926                 if(!checkZone(&lzone, preset, inst, samp))
 927                     break;
 928                 /* Ignore ROM samples for now. */
 929                 if((samp->mSampleType&0x8000))
 930                     break;
 931
 932                 sound = NewFontsound(context);
 933                 (*sounds)[(*sounds_size)++] = sound;
 934                 ALfontsound_setPropi(sound, context, AL_BUFFER, buffer->id);
 935                 ALfontsound_setPropi(sound, context, AL_SAMPLE_START_SOFT, samp->mStart);
 936                 ALfontsound_setPropi(sound, context, AL_SAMPLE_END_SOFT, samp->mEnd);
 937                 ALfontsound_setPropi(sound, context, AL_SAMPLE_LOOP_START_SOFT, samp->mStartloop);
 938                 ALfontsound_setPropi(sound, context, AL_SAMPLE_LOOP_END_SOFT, samp->mEndloop);
 939                 ALfontsound_setPropi(sound, context, AL_SAMPLE_RATE_SOFT, samp->mSampleRate);
 940                 ALfontsound_setPropi(sound, context, AL_BASE_KEY_SOFT, (samp->mOriginalKey <= 127) ? samp->mOriginalKey : 60);
 941                 ALfontsound_setPropi(sound, context, AL_KEY_CORRECTION_SOFT, samp->mCorrection);
 942                 ALfontsound_setPropi(sound, context, AL_SAMPLE_TYPE_SOFT, getSampleType(samp->mSampleType&0x7fff));
 943                 fillZone(sound, context, &lzone);
 944
 945                 break;
 946             }
 947             GenModList_insertGen(&lzone, gen, AL_FALSE);
 948         }
 949
 950         GenModList_Destruct(&lzone);
 951     }
 952
 953     GenModList_Destruct(&gzone);
 954 }
 955
 956 static size_t printStringChunk(Reader *stream, const RiffHdr *chnk, const char *title)
 957 {
 958     size_t len = 0;
 959     if(chnk->mSize == 0 || (chnk->mSize&1))
 960         ERR("Invalid "FOURCCFMT" size: %d\n", FOURCCARGS(chnk->mCode), chnk->mSize);
 961     else
 962     {
 963         char *str = calloc(1, chnk->mSize+1);
 964         len = Reader_read(stream, str, chnk->mSize);
 965
 966         TRACE("%s: %s\n", title, str);
 967         free(str);
 968     }
 969     return len;
 970 }
 971
 972 ALboolean loadSf2(Reader *stream, ALsoundfont *soundfont, ALCcontext *context)
 973 {
 974     ALsfpreset **presets = NULL;
 975     ALsizei presets_size = 0;
 976     ALbuffer *buffer = NULL;
 977     ALuint ltype;
 978     Soundfont sfont;
 979     RiffHdr riff;
 980     RiffHdr list;
 981     ALsizei i;
 982
 983     Soundfont_Construct(&sfont);
 984
 985     RiffHdr_read(&riff, stream);
 986     if(riff.mCode != FOURCC('R','I','F','F'))
 987         ERROR_GOTO(error, "Invalid Format, expected RIFF got '"FOURCCFMT"'\n", FOURCCARGS(riff.mCode));
 988     if((ltype=read_le32(stream)) != FOURCC('s','f','b','k'))
 989         ERROR_GOTO(error, "Invalid Format, expected sfbk got '"FOURCCFMT"'\n", FOURCCARGS(ltype));
 990
 991     if(READERR(stream) != 0)
 992         ERROR_GOTO(error, "Error reading file header\n");
 993
 994     RiffHdr_read(&list, stream);
 995     if(list.mCode != FOURCC('L','I','S','T'))
 996         ERROR_GOTO(error, "Invalid Format, expected LIST (INFO) got '"FOURCCFMT"'\n", FOURCCARGS(list.mCode));
 997     if((ltype=read_le32(stream)) != FOURCC('I','N','F','O'))
 998         ERROR_GOTO(error, "Invalid Format, expected INFO got '"FOURCCFMT"'\n", FOURCCARGS(ltype));
 999     list.mSize -= 4;
1000     while(list.mSize > 0 && !READERR(stream))
1001     {
1002         RiffHdr chnk;
1003
1004         if(list.mSize < 8)
1005         {
1006             WARN("Unexpected end of INFO list (%u extra bytes)\n", list.mSize);
1007             skip(stream, list.mSize);
1008             list.mSize = 0;
1009             break;
1010         }
1011
1012         RiffHdr_read(&chnk, stream);
1013         list.mSize -= 8;
1014         if(list.mSize < chnk.mSize)
1015         {
1016             WARN("INFO sub-chunk '"FOURCCFMT"' has %u bytes, but only %u bytes remain\n",
1017                  FOURCCARGS(chnk.mCode), chnk.mSize, list.mSize);
1018             skip(stream, list.mSize);
1019             list.mSize = 0;
1020             break;
1021         }
1022         list.mSize -= chnk.mSize;
1023
1024         if(chnk.mCode == FOURCC('i','f','i','l'))
1025         {
1026             if(chnk.mSize != 4)
1027                 ERR("Invalid ifil chunk size: %d\n", chnk.mSize);
1028             else
1029             {
1030                 ALushort major = read_le16(stream);
1031                 ALushort minor = read_le16(stream);
1032                 chnk.mSize -= 4;
1033
1034                 if(major != 2)
1035                     ERROR_GOTO(error, "Unsupported SF2 format version: %d.%02d\n", major, minor);
1036                 TRACE("SF2 format version: %d.%02d\n", major, minor);
1037
1038                 sfont.ifil = (major<<16) | minor;
1039             }
1040         }
1041         else if(chnk.mCode == FOURCC('i','r','o','m'))
1042         {
1043             if(chnk.mSize == 0 || (chnk.mSize&1))
1044                 ERR("Invalid irom size: %d\n", chnk.mSize);
1045             else
1046             {
1047                 free(sfont.irom);
1048                 sfont.irom = calloc(1, chnk.mSize+1);
1049                 chnk.mSize -= Reader_read(stream, sfont.irom, chnk.mSize);
1050
1051                 TRACE("SF2 ROM ID: %s\n", sfont.irom);
1052             }
1053         }
1054         else
1055         {
1056             static const struct {
1057                 ALuint code;
1058                 char title[16];
1059             } listinfos[] = {
1060                 { FOURCC('i','s','n','g'), "Engine ID" },
1061                 { FOURCC('I','N','A','M'), "Name" },
1062                 { FOURCC('I','C','R','D'), "Creation Date" },
1063                 { FOURCC('I','E','N','G'), "Creator" },
1064                 { FOURCC('I','P','R','D'), "Product ID" },
1065                 { FOURCC('I','C','O','P'), "Copyright" },
1066                 { FOURCC('I','C','M','T'), "Comment" },
1067                 { FOURCC('I','S','F','T'), "Created With" },
1068                 { 0, "" },
1069             };
1070
1071             for(i = 0;listinfos[i].code;i++)
1072             {
1073                 if(listinfos[i].code == chnk.mCode)
1074                 {
1075                     chnk.mSize -= printStringChunk(stream, &chnk, listinfos[i].title);
1076                     break;
1077                 }
1078             }
1079             if(!listinfos[i].code)
1080                 TRACE("Skipping INFO sub-chunk '"FOURCCFMT"' (%u bytes)\n", FOURCCARGS(chnk.mCode), chnk.mSize);
1081         }
1082         skip(stream, chnk.mSize);
1083     }
1084
1085     if(READERR(stream) != 0)
1086         ERROR_GOTO(error, "Error reading INFO chunk\n");
1087     if(sfont.ifil == 0)
1088         ERROR_GOTO(error, "Missing ifil sub-chunk\n");
1089
1090     RiffHdr_read(&list, stream);
1091     if(list.mCode != FOURCC('L','I','S','T'))
1092         ERROR_GOTO(error, "Invalid Format, expected LIST (sdta) got '"FOURCCFMT"'\n", FOURCCARGS(list.mCode));
1093     if((ltype=read_le32(stream)) != FOURCC('s','d','t','a'))
1094         ERROR_GOTO(error, "Invalid Format, expected sdta got '"FOURCCFMT"'\n", FOURCCARGS(ltype));
1095     list.mSize -= 4;
1096     {
1097         ALbyte *ptr;
1098         RiffHdr smpl;
1099         ALenum err;
1100
1101         RiffHdr_read(&smpl, stream);
1102         if(smpl.mCode != FOURCC('s','m','p','l'))
1103             ERROR_GOTO(error, "Invalid Format, expected smpl got '"FOURCCFMT"'\n", FOURCCARGS(smpl.mCode));
1104         list.mSize -= 8;
1105
1106         if(smpl.mSize > list.mSize)
1107             ERROR_GOTO(error, "Invalid Format, sample chunk size mismatch\n");
1108         list.mSize -= smpl.mSize;
1109
1110         buffer = NewBuffer(context);
1111         if(!buffer)
1112             SET_ERROR_AND_GOTO(context, AL_OUT_OF_MEMORY, error);
1113         /* Sample rate is unimportant, the individual fontsounds will specify it. */
1114         if((err=LoadData(buffer, 22050, AL_MONO16_SOFT, smpl.mSize/2, UserFmtMono, UserFmtShort, NULL, 1, AL_FALSE)) != AL_NO_ERROR)
1115             SET_ERROR_AND_GOTO(context, err, error);
1116
1117         ptr = buffer->data;
1118         if(IS_LITTLE_ENDIAN)
1119             smpl.mSize -= Reader_read(stream, ptr, smpl.mSize);
1120         else
1121         {
1122             ALuint total = 0;
1123             while(total < smpl.mSize && !READERR(stream))
1124             {
1125                 ALbyte buf[4096];
1126                 ALuint todo = minu(smpl.mSize-total, sizeof(buf));
1127                 ALuint i;
1128
1129                 smpl.mSize -= Reader_read(stream, buf, todo);
1130                 for(i = 0;i < todo;i++)
1131                     ptr[total+i] = buf[i^1];
1132
1133                 total += todo;
1134             }
1135         }
1136
1137         skip(stream, list.mSize);
1138     }
1139
1140     if(READERR(stream) != 0)
1141         ERROR_GOTO(error, "Error reading sdta chunk\n");
1142
1143     RiffHdr_read(&list, stream);
1144     if(list.mCode != FOURCC('L','I','S','T'))
1145         ERROR_GOTO(error, "Invalid Format, expected LIST (pdta) got '"FOURCCFMT"'\n", FOURCCARGS(list.mCode));
1146     if((ltype=read_le32(stream)) != FOURCC('p','d','t','a'))
1147         ERROR_GOTO(error, "Invalid Format, expected pdta got '"FOURCCFMT"'\n", FOURCCARGS(ltype));
1148
1149     //
1150     RiffHdr_read(&list, stream);
1151     if(list.mCode != FOURCC('p','h','d','r'))
1152         ERROR_GOTO(error, "Invalid Format, expected phdr got '"FOURCCFMT"'\n", FOURCCARGS(list.mCode));
1153     if((list.mSize%38) != 0 || list.mSize == 0)
1154         ERROR_GOTO(error, "Invalid Format, bad phdr size: %u\n", list.mSize);
1155     sfont.phdr_size = list.mSize/38;
1156     sfont.phdr = calloc(sfont.phdr_size, sizeof(sfont.phdr[0]));
1157     for(i = 0;i < sfont.phdr_size;i++)
1158         PresetHeader_read(&sfont.phdr[i], stream);
1159
1160     RiffHdr_read(&list, stream);
1161     if(list.mCode != FOURCC('p','b','a','g'))
1162         ERROR_GOTO(error, "Invalid Format, expected pbag got '"FOURCCFMT"'\n", FOURCCARGS(list.mCode));
1163     if((list.mSize%4) != 0 || list.mSize == 0)
1164         ERROR_GOTO(error, "Invalid Format, bad pbag size: %u\n", list.mSize);
1165     sfont.pbag_size = list.mSize/4;
1166     sfont.pbag = calloc(sfont.pbag_size, sizeof(sfont.pbag[0]));
1167     for(i = 0;i < sfont.pbag_size;i++)
1168         Zone_read(&sfont.pbag[i], stream);
1169
1170     RiffHdr_read(&list, stream);
1171     if(list.mCode != FOURCC('p','m','o','d'))
1172         ERROR_GOTO(error, "Invalid Format, expected pmod got '"FOURCCFMT"'\n", FOURCCARGS(list.mCode));
1173     if((list.mSize%10) != 0 || list.mSize == 0)
1174         ERROR_GOTO(error, "Invalid Format, bad pmod size: %u\n", list.mSize);
1175     sfont.pmod_size = list.mSize/10;
1176     sfont.pmod = calloc(sfont.pmod_size, sizeof(sfont.pmod[0]));
1177     for(i = 0;i < sfont.pmod_size;i++)
1178         Modulator_read(&sfont.pmod[i], stream);
1179
1180     RiffHdr_read(&list, stream);
1181     if(list.mCode != FOURCC('p','g','e','n'))
1182         ERROR_GOTO(error, "Invalid Format, expected pgen got '"FOURCCFMT"'\n", FOURCCARGS(list.mCode));
1183     if((list.mSize%4) != 0 || list.mSize == 0)
1184         ERROR_GOTO(error, "Invalid Format, bad pgen size: %u\n", list.mSize);
1185     sfont.pgen_size = list.mSize/4;
1186     sfont.pgen = calloc(sfont.pgen_size, sizeof(sfont.pgen[0]));
1187     for(i = 0;i < sfont.pgen_size;i++)
1188         Generator_read(&sfont.pgen[i], stream);
1189
1190     //
1191     RiffHdr_read(&list, stream);
1192     if(list.mCode != FOURCC('i','n','s','t'))
1193         ERROR_GOTO(error, "Invalid Format, expected inst got '"FOURCCFMT"'\n", FOURCCARGS(list.mCode));
1194     if((list.mSize%22) != 0 || list.mSize == 0)
1195         ERROR_GOTO(error, "Invalid Format, bad inst size: %u\n", list.mSize);
1196     sfont.inst_size = list.mSize/22;
1197     sfont.inst = calloc(sfont.inst_size, sizeof(sfont.inst[0]));
1198     for(i = 0;i < sfont.inst_size;i++)
1199         InstrumentHeader_read(&sfont.inst[i], stream);
1200
1201     RiffHdr_read(&list, stream);
1202     if(list.mCode != FOURCC('i','b','a','g'))
1203         ERROR_GOTO(error, "Invalid Format, expected ibag got '"FOURCCFMT"'\n", FOURCCARGS(list.mCode));
1204     if((list.mSize%4) != 0 || list.mSize == 0)
1205         ERROR_GOTO(error, "Invalid Format, bad ibag size: %u\n", list.mSize);
1206     sfont.ibag_size = list.mSize/4;
1207     sfont.ibag = calloc(sfont.ibag_size, sizeof(sfont.ibag[0]));
1208     for(i = 0;i < sfont.ibag_size;i++)
1209         Zone_read(&sfont.ibag[i], stream);
1210
1211     RiffHdr_read(&list, stream);
1212     if(list.mCode != FOURCC('i','m','o','d'))
1213         ERROR_GOTO(error, "Invalid Format, expected imod got '"FOURCCFMT"'\n", FOURCCARGS(list.mCode));
1214     if((list.mSize%10) != 0 || list.mSize == 0)
1215         ERROR_GOTO(error, "Invalid Format, bad imod size: %u\n", list.mSize);
1216     sfont.imod_size = list.mSize/10;
1217     sfont.imod = calloc(sfont.imod_size, sizeof(sfont.imod[0]));
1218     for(i = 0;i < sfont.imod_size;i++)
1219         Modulator_read(&sfont.imod[i], stream);
1220
1221     RiffHdr_read(&list, stream);
1222     if(list.mCode != FOURCC('i','g','e','n'))
1223         ERROR_GOTO(error, "Invalid Format, expected igen got '"FOURCCFMT"'\n", FOURCCARGS(list.mCode));
1224     if((list.mSize%4) != 0 || list.mSize == 0)
1225         ERROR_GOTO(error, "Invalid Format, bad igen size: %u\n", list.mSize);
1226     sfont.igen_size = list.mSize/4;
1227     sfont.igen = calloc(sfont.igen_size, sizeof(sfont.igen[0]));
1228     for(i = 0;i < sfont.igen_size;i++)
1229         Generator_read(&sfont.igen[i], stream);
1230
1231     //
1232     RiffHdr_read(&list, stream);
1233     if(list.mCode != FOURCC('s','h','d','r'))
1234         ERROR_GOTO(error, "Invalid Format, expected shdr got '"FOURCCFMT"'\n", FOURCCARGS(list.mCode));
1235     if((list.mSize%46) != 0 || list.mSize == 0)
1236         ERROR_GOTO(error, "Invalid Format, bad shdr size: %u\n", list.mSize);
1237     sfont.shdr_size = list.mSize/46;
1238     sfont.shdr = calloc(sfont.shdr_size, sizeof(sfont.shdr[0]));
1239     for(i = 0;i < sfont.shdr_size;i++)
1240         SampleHeader_read(&sfont.shdr[i], stream);
1241
1242     if(READERR(stream) != 0)
1243         ERROR_GOTO(error, "Error reading pdta chunk\n");
1244
1245     if(!ensureFontSanity(&sfont))
1246         goto error;
1247
1248     presets = calloc(1, (soundfont->NumPresets+sfont.phdr_size-1)*sizeof(presets[0]));
1249     if(!presets)
1250         ERROR_GOTO(error, "Error allocating presets\n");
1251     memcpy(presets, soundfont->Presets, soundfont->NumPresets*sizeof(presets[0]));
1252     presets_size = soundfont->NumPresets;
1253
1254     for(i = 0;i < sfont.phdr_size-1;i++)
1255     {
1256         const Generator *gen, *gen_end;
1257         const Modulator *mod, *mod_end;
1258         const Zone *zone, *zone_end;
1259         ALfontsound **sounds = NULL;
1260         ALsizei sounds_size = 0;
1261         GenModList gzone;
1262
1263         if(sfont.phdr[i+1].mZoneIdx == sfont.phdr[i].mZoneIdx)
1264             continue;
1265
1266         GenModList_Construct(&gzone);
1267         zone = sfont.pbag + sfont.phdr[i].mZoneIdx;
1268         zone_end = sfont.pbag + sfont.phdr[i+1].mZoneIdx;
1269         if(zone_end-zone > 1)
1270         {
1271             gen = sfont.pgen + zone->mGenIdx;
1272             gen_end = sfont.pgen + (zone+1)->mGenIdx;
1273
1274             // If no generators, or last generator is not an instrument, this is a global zone
1275             for(;gen != gen_end;gen++)
1276             {
1277                 if(gen->mGenerator == 41)
1278                     break;
1279             }
1280
1281             if(gen == gen_end)
1282             {
1283                 gen = sfont.pgen + zone->mGenIdx;
1284                 gen_end = sfont.pgen + (zone+1)->mGenIdx;
1285                 for(;gen != gen_end;gen++)
1286                     GenModList_insertGen(&gzone, gen, AL_TRUE);
1287
1288                 mod = sfont.pmod + zone->mModIdx;
1289                 mod_end = sfont.pmod + (zone+1)->mModIdx;
1290                 for(;mod != mod_end;mod++)
1291                     GenModList_insertMod(&gzone, mod);
1292
1293                 zone++;
1294             }
1295         }
1296
1297         for(;zone != zone_end;zone++)
1298         {
1299             GenModList lzone = GenModList_clone(&gzone);
1300
1301             mod = sfont.pmod + zone->mModIdx;
1302             mod_end = sfont.pmod + (zone+1)->mModIdx;
1303             for(;mod != mod_end;mod++)
1304                 GenModList_insertMod(&lzone, mod);
1305
1306             gen = sfont.pgen + zone->mGenIdx;
1307             gen_end = sfont.pgen + (zone+1)->mGenIdx;
1308             for(;gen != gen_end;gen++)
1309             {
1310                 if(gen->mGenerator == 41)
1311                 {
1312                     if(gen->mAmount >= sfont.inst_size-1)
1313                         ERR("Generator %ld has invalid instrument ID (%d of %d)\n",
1314                             (long)(gen-sfont.pgen), gen->mAmount, sfont.inst_size-1);
1315                     else
1316                         processInstrument(
1317                             &sounds, &sounds_size, context, buffer, &sfont.inst[gen->mAmount],
1318                             &sfont.phdr[i], &sfont, &lzone
1319                         );
1320                     break;
1321                 }
1322                 GenModList_insertGen(&lzone, gen, AL_TRUE);
1323             }
1324             GenModList_Destruct(&lzone);
1325         }
1326
1327         if(sounds_size > 0)
1328         {
1329             ALsizei j;
1330
1331             presets[presets_size] = NewPreset(context);
1332             presets[presets_size]->Preset = sfont.phdr[i].mPreset;
1333             presets[presets_size]->Bank = sfont.phdr[i].mBank;
1334
1335             for(j = 0;j < sounds_size;j++)
1336                 IncrementRef(&sounds[j]->ref);
1337             sounds = ExchangePtr((XchgPtr*)&presets[presets_size]->Sounds, sounds);
1338             ExchangeInt(&presets[presets_size]->NumSounds, sounds_size);
1339             presets_size++;
1340         }
1341         free(sounds);
1342
1343         GenModList_Destruct(&gzone);
1344     }
1345
1346     for(i = soundfont->NumPresets;i < presets_size;i++)
1347         IncrementRef(&presets[i]->ref);
1348     presets = ExchangePtr((XchgPtr*)&soundfont->Presets, presets);
1349     ExchangeInt(&soundfont->NumPresets, presets_size);
1350
1351     free(presets);
1352
1353     Soundfont_Destruct(&sfont);
1354     /* If the buffer ends up unused, delete it. */
1355     if(ReadRef(&buffer->ref) == 0)
1356     {
1357         TRACE("Deleting unused buffer...\n");
1358         DeleteBuffer(context->Device, buffer);
1359     }
1360
1361     return AL_TRUE;
1362
1363 error:
1364     if(presets)
1365     {
1366         ALCdevice *device = context->Device;
1367         for(i = soundfont->NumPresets;i < presets_size;i++)
1368             DeletePreset(device, presets[i]);
1369         free(presets);
1370     }
1371
1372     Soundfont_Destruct(&sfont);
1373     if(buffer)
1374         DeleteBuffer(context->Device, buffer);
1375
1376     return AL_FALSE;
1377 }