/* FluidSynth - A Software Synthesizer * * Copyright (C) 2003 Peter Hanappe and others. * * SoundFont file loading code borrowed from Smurf SoundFont Editor * Copyright (C) 1999-2001 Josh Green * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Library General Public License * as published by the Free Software Foundation; either version 2 of * the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, but * WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Library General Public License for more details. * * You should have received a copy of the GNU Library General Public * License along with this library; if not, write to the Free * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA * 02111-1307, USA */ #include "sfont.h" #include "fluid.h" #include "voice.h" // #define DEBUG_SFONT #include "libmscore/xml.h" static bool debugMode = false; namespace FluidS { //--------------------------------------------------------- // SFVersion //--------------------------------------------------------- SFVersion::SFVersion() { major = 0; minor = 0; } //--------------------------------------------------------- // SFont //--------------------------------------------------------- SFont::SFont(Fluid* f) { synth = f; samplepos = 0; samplesize = 0; } SFont::~SFont() { foreach(Sample* s, sample) delete s; foreach(Preset* p, presets) delete p; foreach(unsigned char* p, infos) delete[] p; foreach(Instrument* i, instruments) { // foreach(Zone* z, i->zones) // delete z; delete i; } } //--------------------------------------------------------- // read //--------------------------------------------------------- bool SFont::read(const QString& s) { f.setFileName(s); if (!load()) return false; foreach(Instrument* i, instruments) { if (!i->import_sfont()) return false; } foreach(Preset* p, presets) { if (!p->importSfont()) return false; } return true; } //--------------------------------------------------------- // get_preset //--------------------------------------------------------- Preset* SFont::get_preset(int bank, int num) { foreach(Preset* p, presets) { if ((p->get_banknum() == bank) && (p->get_num() == num)) return p; } return 0; } //--------------------------------------------------------- // Preset //--------------------------------------------------------- Preset::Preset(SFont* s) { sfont = s; bank = 0; num = 0; _global_zone = 0; } //--------------------------------------------------------- // Preset //--------------------------------------------------------- Preset::~Preset() { delete _global_zone; foreach(Zone* z, zones) delete z; } //--------------------------------------------------------- // loadSamples // this is called if the preset is associated with a // channel //--------------------------------------------------------- void Preset::loadSamples() { // sfont->synth->mutex.lock(); if (_global_zone && _global_zone->instrument) { Instrument* i = _global_zone->instrument; if (i->global_zone && i->global_zone->sample) i->global_zone->sample->load(); foreach(Zone* iz, i->zones) iz->sample->load(); } foreach(Zone* z, zones) { Instrument* i = z->instrument; if (i->global_zone && i->global_zone->sample) i->global_zone->sample->load(); foreach(Zone* iz, i->zones) iz->sample->load(); } // sfont->synth->mutex.unlock(); } //--------------------------------------------------------- // noteon //--------------------------------------------------------- bool Preset::noteon(Fluid* synth, unsigned id, int chan, int key, int vel, double nt) { Mod* mod; Mod* mod_list[FLUID_NUM_MOD]; /* list for 'sorting' preset modulators */ Zone* global_preset_zone = global_zone(); /* run thru all the zones of this preset */ foreach (Zone* preset_zone, zones) { /* check if the note falls into the key and velocity range of this preset */ if (preset_zone->inside_range(key, vel)) { Instrument* inst = preset_zone->get_inst(); Zone* global_inst_zone = inst->get_global_zone(); /* run thru all the zones of this instrument */ foreach(Zone* inst_zone, inst->get_zone()) { /* make sure this instrument zone has a valid sample */ Sample* sample = inst_zone->get_sample(); if (sample == 0 || sample->inRom()) continue; /* check if the note falls into the key and velocity range of this instrument */ if (inst_zone->inside_range(key, vel) && (sample != 0)) { /* this is a good zone. allocate a new synthesis process and initialize it */ Voice* voice = synth->alloc_voice(id, sample, chan, key, vel, nt); if (voice == 0) return false; /* Instrumentrument level, generators */ for (int i = 0; i < GEN_LAST; i++) { /* SF 2.01 section 9.4 'bullet' 4: * * A generator in a local instrument zone supersedes a * global instrument zone generator. Both cases supersede * the default generator -> voice_gen_set */ if (inst_zone->genlist[i].flags) voice->gen_set(i, inst_zone->genlist[i].val); else if ((global_inst_zone != 0) && (global_inst_zone->genlist[i].flags)) voice->gen_set(i, global_inst_zone->genlist[i].val); else { /* The generator has not been defined in this instrument. * Do nothing, leave it at the default. */ } } /* for all generators */ /* global instrument zone, modulators: Put them all into a * list. */ int mod_list_count = 0; if (global_inst_zone){ foreach(Mod* mod, global_inst_zone->modlist) mod_list[mod_list_count++] = mod; } /* local instrument zone, modulators. * Replace modulators with the same definition in the list: * SF 2.01 page 69, 'bullet' 8 */ foreach(Mod* mod, inst_zone->modlist) { /* 'Identical' modulators will be deleted by setting their * list entry to 0. The list length is known, 0 * entries will be ignored later. SF2.01 section 9.5.1 * page 69, 'bullet' 3 defines 'identical'. */ for (int i = 0; i < mod_list_count; i++){ if (mod_list[i] && test_identity(mod, mod_list[i])){ mod_list[i] = 0; } } /* Finally add the new modulator to to the list. */ mod_list[mod_list_count++] = mod; } /* Add instrument modulators (global / local) to the voice. */ for (int i = 0; i < mod_list_count; i++){ mod = mod_list[i]; if (mod) { // disabled modulators CANNOT be skipped. /* Instrumentrument modulators -supersede- existing (default) * modulators. SF 2.01 page 69, 'bullet' 6 */ voice->add_mod(mod, FLUID_VOICE_OVERWRITE); } } /* Preset level, generators */ for (int i = 0; i < GEN_LAST; i++) { /* SF 2.01 section 8.5 page 58: If some generators are * encountered at preset level, they should be ignored */ if ((i != GEN_STARTADDROFS) && (i != GEN_ENDADDROFS) && (i != GEN_STARTLOOPADDROFS) && (i != GEN_ENDLOOPADDROFS) && (i != GEN_STARTADDRCOARSEOFS) && (i != GEN_ENDADDRCOARSEOFS) && (i != GEN_STARTLOOPADDRCOARSEOFS) && (i != GEN_KEYNUM) && (i != GEN_VELOCITY) && (i != GEN_ENDLOOPADDRCOARSEOFS) && (i != GEN_SAMPLEMODE) && (i != GEN_EXCLUSIVECLASS) && (i != GEN_OVERRIDEROOTKEY)) { /* SF 2.01 section 9.4 'bullet' 9: A generator in a * local preset zone supersedes a global preset zone * generator. The effect is -added- to the destination * summing node -> voice_gen_incr */ if (preset_zone->genlist[i].flags) { voice->gen_incr(i, preset_zone->genlist[i].val); } else if ((global_preset_zone != 0) && global_preset_zone->genlist[i].flags) { voice->gen_incr(i, global_preset_zone->genlist[i].val); } else { /* The generator has not been defined in this preset * Do nothing, leave it unchanged. */ } } /* if available at preset level */ } /* for all generators */ /* Global preset zone, modulators: put them all into a * list. */ mod_list_count = 0; if (global_preset_zone){ foreach(Mod* mod, global_preset_zone->modlist) mod_list[mod_list_count++] = mod; } /* Process the modulators of the local preset zone. Kick * out all identical modulators from the global preset zone * (SF 2.01 page 69, second-last bullet) */ foreach(Mod* mod, preset_zone->modlist) { for (int i = 0; i < mod_list_count; i++) { if (mod_list[i] && test_identity(mod,mod_list[i])) mod_list[i] = 0; } /* Finally add the new modulator to the list. */ mod_list[mod_list_count++] = mod; } /* Add preset modulators (global / local) to the voice. */ for (int i = 0; i < mod_list_count; i++){ mod = mod_list[i]; if ((mod != 0) && (mod->amount != 0)) { /* disabled modulators can be skipped. */ /* Preset modulators -add- to existing instrument / * default modulators. SF2.01 page 70 first bullet on * page */ voice->add_mod(mod, FLUID_VOICE_ADD); } } /* add the synthesis process to the synthesis loop. */ synth->start_voice(voice); /* Store the ID of the first voice that was created by this noteon event. * Exclusive class may only terminate older voices. * That avoids killing voices, which have just been created. * (a noteon event can create several voice processes with the same exclusive * class - for example when using stereo samples) */ } } } } return true; } //--------------------------------------------------------- // importSfont //--------------------------------------------------------- bool Preset::importSfont() { if (name.isEmpty()) name = QString("Bank%1,Preset%2").arg(bank).arg(num); int idx = 0; foreach(Zone* zone, zones) { // zone->name = QString("%1/%2").arg(name).arg(idx); if (!zone->importZone()) return false; if ((idx == 0) && (zone->get_inst() == 0)) setGlobalZone(zones.takeAt(0)); ++idx; } return true; } //--------------------------------------------------------- // import_sfont //--------------------------------------------------------- bool Instrument::import_sfont() { int idx = 0; foreach(Zone* zone, zones) { if (!zone->importZone()) return false; if ((idx == 0) && (zone->get_sample() == 0)) global_zone = zones.takeAt(0); idx++; } return true; } //--------------------------------------------------------- // Zone //--------------------------------------------------------- Zone::Zone() { instrument = 0; sample = 0; sampIdx = 0; instIdx = 0; keylo = 0; keyhi = 128; vello = 0; velhi = 128; /* Flag all generators as unused (default, they will be set when they are found * in the sound font). * This also sets the generator values to default, but that is of no concern here.*/ fluid_gen_set_default_values(&genlist[0]); } Zone::~Zone() { foreach(Mod* m, modlist) delete m; foreach(SFGen* p, gen) delete p; foreach(SFMod* p, mod) delete p; } //--------------------------------------------------------- // inside_range //--------------------------------------------------------- bool Zone::inside_range(int key, int vel) const { return ((keylo <= key) && (keyhi >= key) && (vello <= vel) && (velhi >= vel)); } //--------------------------------------------------------- // Instrument //--------------------------------------------------------- Instrument::Instrument() { global_zone = 0; } Instrument::~Instrument() { delete global_zone; foreach(Zone* z, zones) delete z; } //--------------------------------------------------------- // importZone //--------------------------------------------------------- bool Zone::importZone() { foreach (SFGen* sfgen, gen) { switch (sfgen->id) { case GEN_KEYRANGE: keylo = sfgen->amount.range.lo; keyhi = sfgen->amount.range.hi; break; case GEN_VELRANGE: vello = sfgen->amount.range.lo; velhi = sfgen->amount.range.hi; break; default: /* FIXME: some generators have an unsigned word amount value but i don't know which ones */ genlist[sfgen->id].val = (float) sfgen->amount.sword; genlist[sfgen->id].flags = GEN_SET; break; } } // Import the modulators (only SF2.1 and higher) foreach(SFMod* mod_src, mod) { Mod* mod_dest = new Mod; int type; // mod_dest->next = 0; /* pointer to next modulator, this is the end of the list now.*/ /* *** Amount *** */ mod_dest->amount = mod_src->amount; /* *** Source *** */ mod_dest->src1 = mod_src->src & 127; /* index of source 1, seven-bit value, SF2.01 section 8.2, page 50 */ mod_dest->flags1 = 0; /* Bit 7: CC flag SF 2.01 section 8.2.1 page 50*/ if (mod_src->src & (1<<7)) mod_dest->flags1 |= FLUID_MOD_CC; else mod_dest->flags1 |= FLUID_MOD_GC; /* Bit 8: D flag SF 2.01 section 8.2.2 page 51*/ if (mod_src->src & (1<<8)) mod_dest->flags1 |= FLUID_MOD_NEGATIVE; else mod_dest->flags1 |= FLUID_MOD_POSITIVE; /* Bit 9: P flag SF 2.01 section 8.2.3 page 51*/ if (mod_src->src & (1<<9)) mod_dest->flags1 |= FLUID_MOD_BIPOLAR; else mod_dest->flags1 |= FLUID_MOD_UNIPOLAR; /* modulator source types: SF2.01 section 8.2.1 page 52 */ type = (mod_src->src) >> 10; type &= 63; /* type is a 6-bit value */ if (type == 0) mod_dest->flags1 |= FLUID_MOD_LINEAR; else if (type == 1) mod_dest->flags1 |= FLUID_MOD_CONCAVE; else if (type == 2) mod_dest->flags1 |= FLUID_MOD_CONVEX; else if (type == 3) mod_dest->flags1 |= FLUID_MOD_SWITCH; else { /* This shouldn't happen - unknown type! * Deactivate the modulator by setting the amount to 0. */ mod_dest->amount=0; } /* *** Dest *** */ mod_dest->dest = mod_src->dest; /* index of controlled generator */ /* *** Amount source *** */ mod_dest->src2 = mod_src->amtsrc & 127; /* index of source 2, seven-bit value, SF2.01 section 8.2, p.50 */ mod_dest->flags2 = 0; /* Bit 7: CC flag SF 2.01 section 8.2.1 page 50*/ if (mod_src->amtsrc & (1<<7)) mod_dest->flags2 |= FLUID_MOD_CC; else mod_dest->flags2 |= FLUID_MOD_GC; /* Bit 8: D flag SF 2.01 section 8.2.2 page 51*/ if (mod_src->amtsrc & (1<<8)) mod_dest->flags2 |= FLUID_MOD_NEGATIVE; else mod_dest->flags2 |= FLUID_MOD_POSITIVE; /* Bit 9: P flag SF 2.01 section 8.2.3 page 51*/ if (mod_src->amtsrc & (1<<9)) mod_dest->flags2 |= FLUID_MOD_BIPOLAR; else mod_dest->flags2 |= FLUID_MOD_UNIPOLAR; /* modulator source types: SF2.01 section 8.2.1 page 52 */ type = (mod_src->amtsrc) >> 10; type &= 63; /* type is a 6-bit value */ if (type == 0) mod_dest->flags2 |= FLUID_MOD_LINEAR; else if (type == 1) mod_dest->flags2 |= FLUID_MOD_CONCAVE; else if (type == 2) mod_dest->flags2 |= FLUID_MOD_CONVEX; else if (type == 3) mod_dest->flags2 |= FLUID_MOD_SWITCH; else { /* This shouldn't happen - unknown type! * Deactivate the modulator by setting the amount to 0. */ mod_dest->amount=0; } /* *** Transform *** */ /* SF2.01 only uses the 'linear' transform (0). * Deactivate the modulator by setting the amount to 0 in any other case. */ if (mod_src->trans !=0) mod_dest->amount = 0; /* Store the new modulator in the zone The order of modulators * will make a difference, at least in an instrument context: The * second modulator overwrites the first one, if they only differ * in amount. */ modlist.append(mod_dest); } return true; } //--------------------------------------------------------- // Sample //--------------------------------------------------------- Sample::Sample(SFont* s) { sf = s; _valid = false; start = 0; end = 0; loopstart = 0; loopend = 0; samplerate = 0; origpitch = 0; pitchadj = 0; sampletype = 0; data = 0; amplitude_that_reaches_noise_floor_is_valid = false; amplitude_that_reaches_noise_floor = 0.0; } //--------------------------------------------------------- // Sample //--------------------------------------------------------- Sample::~Sample() { delete[] data; } //--------------------------------------------------------- // load //--------------------------------------------------------- void Sample::load() { if (!_valid || data) return; QFile fd(sf->get_name()); if (!fd.open(QIODevice::ReadOnly)) return; if (sampletype & FLUID_SAMPLETYPE_OGG_VORBIS) { if (!fd.seek(sf->samplePos() + start)) return; } else { if (!fd.seek(sf->samplePos() + start * sizeof(short))) return; } unsigned int size = end - start; if (sampletype & FLUID_SAMPLETYPE_OGG_VORBIS) { #ifdef SOUNDFONT3 char* p = new char[size]; if (fd.read(p, size) != size) { printf(" read %d failed\n", size); return; } decompressOggVorbis(p, size); delete[] p; #endif } else { data = new short[size]; size *= sizeof(short); if (fd.read((char*)data, size) != size) return; if (QSysInfo::ByteOrder == QSysInfo::BigEndian) { unsigned char hi, lo; unsigned int i, j; short s; uchar* cbuf = (uchar*) data; for (i = 0, j = 0; j < size; i++) { lo = cbuf[j++]; hi = cbuf[j++]; s = (hi << 8) | lo; data[i] = s; } } end -= (start + 1); // marks last sample, contrary to SF spec. loopstart -= start; loopend -= start; start = 0; } optimize(); } //--------------------------------------------------------- // inRom //--------------------------------------------------------- bool Sample::inRom() const { return sampletype & FLUID_SAMPLETYPE_ROM; } static const char idlist[] = { "RIFFLISTsfbkINFOsdtapdtaifilisngINAMiromiverICRDIENGIPRD" "ICOPICMTISFTsnamsmplphdrpbagpmodpgeninstibagimodigenshdr" }; //--------------------------------------------------------- // chunkid //--------------------------------------------------------- static int chunkid (unsigned int id) { unsigned int* p = (unsigned int *) & idlist; for (unsigned i = 0; i < sizeof (idlist) / sizeof (int); i++, p++) { if (*p == id) return (i + 1); } return UNKN_ID; } //--------------------------------------------------------- // preset_compare //--------------------------------------------------------- static bool preset_compare (Preset* a, Preset* b) { int aval = (a->bank) << 16 | a->num; int bval = (b->bank) << 16 | b->num; return aval < bval; } //--------------------------------------------------------- // readchunk //--------------------------------------------------------- void SFont::readchunk(SFChunk* var) { safe_fread(var, 8); if (QSysInfo::ByteOrder == QSysInfo::BigEndian) var->size = GUINT32_FROM_BE(var->size); else var->size = GUINT32_FROM_LE(var->size); } //--------------------------------------------------------- // load // return true on success //--------------------------------------------------------- bool SFont::load() { if (!f.open(QIODevice::ReadOnly)) { qCritical("Unable to open file \"%s\"", qPrintable(f.fileName())); return false; } SFChunk chunk; try { readchunk(&chunk); if (chunkid(chunk.id) != RIFF_ID) throw(QString("Not a RIFF file")); safe_fread(&chunk.id, 4); if (chunkid (chunk.id) != SFBK_ID) /* error if not SFBK_ID */ throw(QString("Not a sound font file")); if (chunk.size != f.size() - 8) throw(QString("Sound font file size mismatch %1 %2").arg(chunk.size).arg(f.size() - 8)); /* Process INFO block */ read_listchunk(&chunk); if (chunkid(chunk.id) != INFO_ID) throw(QString("Invalid ID found when expecting INFO chunk")); process_info(chunk.size); /* Process sample chunk */ read_listchunk(&chunk); if (chunkid (chunk.id) != SDTA_ID) throw(QString("Invalid ID found when expecting SAMPLE chunk")); process_sdta(chunk.size); /* process HYDRA chunk */ read_listchunk(&chunk); if (chunkid (chunk.id) != PDTA_ID) throw(QString("Invalid ID found when expecting HYDRA chunk")); process_pdta (chunk.size); fixup_pgen(); fixup_igen(); } catch (QString s) { printf("fluid: error loading sound font: %s\n", qPrintable(s)); f.close(); return false; } f.close(); /* sort preset list by bank, preset # */ qSort(presets.begin(), presets.end(), preset_compare); return true; } //--------------------------------------------------------- // READW //--------------------------------------------------------- unsigned short SFont::READW() { unsigned short _temp; safe_fread(&_temp, 2); if (QSysInfo::ByteOrder == QSysInfo::BigEndian) return GINT16_FROM_BE(_temp); else return GINT16_FROM_LE(_temp); } //--------------------------------------------------------- // READD //--------------------------------------------------------- void SFont::READD(unsigned int& var) { unsigned int _temp; safe_fread(&_temp, 4); if (QSysInfo::ByteOrder == QSysInfo::BigEndian) var = GINT32_FROM_BE(_temp); else var = GINT32_FROM_LE(_temp); } //--------------------------------------------------------- // READB //--------------------------------------------------------- unsigned char SFont::READB() { unsigned char var; safe_fread(&var, 1); return var; } //--------------------------------------------------------- // READC //--------------------------------------------------------- char SFont::READC() { char var; safe_fread(&var, 1); return var; } //--------------------------------------------------------- // FSKIPW //--------------------------------------------------------- void SFont::FSKIPW() { safe_fseek(2); } void SFont::READSTR(char* name) { safe_fread(name, 20); name[20] = '\0'; } //--------------------------------------------------------- // read_listchunk //--------------------------------------------------------- void SFont::read_listchunk (SFChunk* chunk) { readchunk (chunk); if (chunkid (chunk->id) != LIST_ID) throw(QString("Invalid chunk id in level 0 parse")); safe_fread(&chunk->id, 4); chunk->size -= 4; } //--------------------------------------------------------- // process_info //--------------------------------------------------------- void SFont::process_info(int size) { while (size > 0) { SFChunk chunk; readchunk (&chunk); size -= 8; unsigned char id = chunkid (chunk.id); if (id == IFIL_ID) { // sound font version chunk? if (chunk.size != 4) throw(QString("Sound font version info chunk has invalid size")); _version.major = READW(); _version.minor = READW(); if (_version.major < 2 || _version.major > 3) throw(QString("Bad Sound font version %1.%2").arg(_version.major).arg(_version.minor)); } else if (id == IVER_ID) { /* ROM version chunk? */ if (chunk.size != 4) throw(QString("ROM version info chunk has invalid size")); romver.major = READW(); romver.minor = READW(); } else if (id != UNKN_ID) { if ((id != ICMT_ID && chunk.size > 256) || (chunk.size > 65536) || (chunk.size % 2)) throw(QString("INFO sub chunk has invalid chunk size")); /* alloc for chunk id and da chunk */ unsigned char* item = new unsigned char[chunk.size + 1]; *(unsigned char *) item = id; safe_fread (&item[1], chunk.size); /* force terminate info item (don't forget uint8 info ID) */ *(item + chunk.size) = '\0'; infos.append(item); } else throw(QString("Invalid chunk id in INFO chunk")); size -= chunk.size; } if (size < 0) throw(QString("INFO chunk size mismatch")); } //--------------------------------------------------------- // process_sdta // return true on success //--------------------------------------------------------- void SFont::process_sdta (int size) { if (size == 0) return; // no sample data? /* read sub chunk */ SFChunk chunk; readchunk (&chunk); size -= 8; if (chunkid (chunk.id) != SMPL_ID) throw(QString("Expected SMPL chunk found invalid id instead")); if ((size - chunk.size) != 0) throw(QString("SDTA chunk size mismatch %1 != %2").arg(size).arg(chunk.size)); /* sample data follows */ setSamplepos(f.pos()); setSamplesize(chunk.size); FSKIP(chunk.size); } //--------------------------------------------------------- // pdtahelper //--------------------------------------------------------- void SFont::pdtahelper (unsigned expid, unsigned reclen, SFChunk* chunk, int* size) { const char* expstr = CHNKIDSTR (expid); readchunk (chunk); *size -= 8; unsigned id = chunkid(chunk->id); if (id != expid) throw(QString("Expected PDTA sub-chunk %1 found invalid id instead").arg(expstr)); if (chunk->size % reclen) /* valid chunk size? */ throw(QString("chunk size is not a multiple of %1 bytes").arg(reclen)); if ((*size -= chunk->size) < 0) throw(QString("%1 chunk size exceeds remaining PDTA chunk size").arg(expstr)); } //--------------------------------------------------------- // process_pdta //--------------------------------------------------------- void SFont::process_pdta (int size) { static const unsigned id[] = { PHDR_ID, PBAG_ID, PMOD_ID, PGEN_ID, IHDR_ID, IBAG_ID, IMOD_ID, IGEN_ID, SHDR_ID }; static const unsigned len[] = { SFPHDRSIZE, SFBAGSIZE, SFMODSIZE, SFGENSIZE, SFIHDRSIZE, SFBAGSIZE, SFMODSIZE, SFGENSIZE, SFSHDRSIZE }; typedef void (SFont::*LoadFunc)(int); static const LoadFunc funcArray[] = { &SFont::load_phdr, &SFont::load_pbag, &SFont::load_pmod, &SFont::load_pgen, &SFont::load_ihdr, &SFont::load_ibag, &SFont::load_imod, &SFont::load_igen, &SFont::load_shdr }; SFChunk chunk; for (int i = 0; i < 9; ++i) { pdtahelper(id[i], len[i], &chunk, &size); (this->*funcArray[i])(chunk.size); } } /* preset header loader */ void SFont::load_phdr (int size) { Preset* pr = 0; /* ptr to current & previous preset */ unsigned short zndx, pzndx = 0; if (size % SFPHDRSIZE || size == 0) throw(QString("Preset header chunk size is invalid")); int i = size / SFPHDRSIZE - 1; if (i == 0) { /* at least one preset + term record */ qWarning("File contains no presets"); FSKIP (SFPHDRSIZE); return; } for (; i > 0; i--) { /* load all preset headers */ Preset* p = new Preset(this); presets.append(p); char str[21]; READSTR (str); p->name = QString::fromLatin1(str); p->num = READW(); p->bank = READW(); zndx = READW(); unsigned int tmp; READD (tmp); READD (tmp); READD (tmp); if (pr) { /* not first preset? */ if (zndx < pzndx) throw(QString("Preset header indices not monotonic")); int i2 = zndx - pzndx; while (i2--) pr->zones.prepend(0); } else if (zndx > 0) /* 1st preset, warn if ofs >0 */ qWarning("%d preset zones not referenced, discarding", zndx); pr = p; /* update preset ptr */ pzndx = zndx; } FSKIP (24); zndx = READW(); /* Read terminal generator index */ FSKIP (12); if (zndx < pzndx) throw(QString("Preset header indices not monotonic")); int i2 = zndx - pzndx; while (i2--) pr->zones.prepend(0); } /* preset bag loader */ void SFont::load_pbag (int size) { Zone *z, *pz = 0; unsigned short genndx, modndx; unsigned short pgenndx = 0, pmodndx = 0; if (size % SFBAGSIZE || size == 0) /* size is multiple of SFBAGSIZE? */ throw(QString("Preset bag chunk size is invalid")); foreach(Preset* p, presets) { for (int i = 0; i < p->zones.size(); ++i) { if ((size -= SFBAGSIZE) < 0) throw(QString("1:Preset bag chunk size mismatch")); z = new Zone; genndx = READW(); /* possible read failure ^ */ modndx = READW(); z->sample = 0; if (pz) { /* if not first zone */ if (genndx < pgenndx) throw(QString("Preset bag generator indices not monotonic")); if (modndx < pmodndx) throw(QString("Preset bag modulator indices not monotonic")); int ii = genndx - pgenndx; while (ii--) pz->gen.prepend(0); ii = modndx - pmodndx; while (ii--) pz->mod.prepend(0); } pz = z; /* update previous zone ptr */ pgenndx = genndx; /* update previous zone gen index */ pmodndx = modndx; /* update previous zone mod index */ p->zones[i] = z; } } size -= SFBAGSIZE; if (size != 0) throw(QString("2:Preset bag chunk size mismatch")); genndx = READW(); modndx = READW(); if (!pz) { if (genndx > 0) qWarning("No preset generators and terminal index not 0"); if (modndx > 0) qWarning("No preset modulators and terminal index not 0"); return; } if (genndx < pgenndx) throw(QString("Preset bag generator indices not monotonic")); if (modndx < pmodndx) throw(QString("Preset bag modulator indices not monotonic")); int i = genndx - pgenndx; while (i--) pz->gen.prepend(0); i = modndx - pmodndx; while (i--) pz->mod.prepend(0); } //--------------------------------------------------------- // load_pmod // preset modulator loader //--------------------------------------------------------- void SFont::load_pmod (int size) { foreach (Preset* p, presets) { foreach(Zone* p2, p->zones) { for (int i = 0; i < p2->mod.size(); ++i) { if ((size -= SFMODSIZE) < 0) throw(QString("Preset modulator chunk size mismatch")); SFMod* m = new SFMod; m->src = READW(); m->dest = READW(); m->amount = READW(); m->amtsrc = READW(); m->trans = READW(); p2->mod[i] = m; } } } /* If there isn't even a terminal record Hmmm, the specs say there should be one, but.. */ if (size == 0) return; size -= SFMODSIZE; if (size != 0) throw(QString("Preset modulator chunk size mismatch")); FSKIP (SFMODSIZE); /* terminal mod */ } static const unsigned short badgen[] = { Gen_Unused1, Gen_Unused2, Gen_Unused3, Gen_Unused4, Gen_Reserved1, Gen_Reserved2, Gen_Reserved3, 0 }; static const unsigned short badpgen[] = { Gen_StartAddrOfs, Gen_EndAddrOfs, Gen_StartLoopAddrOfs, Gen_EndLoopAddrOfs, Gen_StartAddrCoarseOfs, Gen_EndAddrCoarseOfs, Gen_StartLoopAddrCoarseOfs, Gen_Keynum, Gen_Velocity, Gen_EndLoopAddrCoarseOfs, Gen_SampleModes, Gen_ExclusiveClass, Gen_OverrideRootKey, 0 }; /* check validity of instrument generator */ static int gen_valid (int gen) { /* is generator id valid? */ int i = 0; if (gen > Gen_MaxValid) return false; while (badgen[i] && badgen[i] != gen) i++; return (badgen[i] == 0); } /* check validity of preset generator */ static int gen_validp (int gen) { /* is preset generator valid? */ int i = 0; if (!gen_valid (gen)) return false; while (badpgen[i] && badpgen[i] != (unsigned short) gen) i++; return (badpgen[i] == 0); } //--------------------------------------------------------- // gen_inlist // Find generator in gen list //--------------------------------------------------------- static SFGen* gen_inlist (int gen, const QList& genlist) { foreach(SFGen* p, genlist) { if (p == 0) break; if (gen == p->id) return p; } return 0; } /* delete zone from zone list */ static void sfont_zone_delete (QList* l, Zone * zone) { l->removeOne(zone); delete zone; } /* ------------------------------------------------------------------- * preset generator loader * generator (per preset) loading rules: * Zones with no generators or modulators shall be annihilated * Global zone must be 1st zone, discard additional ones (instrumentless zones) * * generator (per zone) loading rules (in order of decreasing precedence): * KeyRange is 1st in list (if exists), else discard * if a VelRange exists only preceded by a KeyRange, else discard * if a generator follows an instrument discard it * if a duplicate generator exists replace previous one * ------------------------------------------------------------------- */ void SFont::load_pgen (int size) { foreach(Preset* p, presets) { bool gzone = false; bool discarded = false; QList& zl = p->zones; for (int k = 0; k < zl.size(); ++k) { int level = 0; Zone* z = zl[k]; int i = 0; for (; i < z->gen.size();) { SFGen* dup = 0; bool skip = false; bool drop = false; if ((size -= SFGENSIZE) < 0) throw(QString("1:Preset generator chunk size mismatch")); unsigned short genid = READW(); SFGenAmount genval; if (genid == Gen_KeyRange) { /* nothing precedes */ if (level == 0) { level = 1; genval.range.lo = READB(); genval.range.hi = READB(); } else skip = true; } else if (genid == Gen_VelRange) { // only KeyRange precedes if (level <= 1) { level = 2; genval.range.lo = READB(); genval.range.hi = READB(); } else skip = true; } else if (genid == Gen_Instrument) { /* inst is last gen */ level = 3; genval.uword = READW(); z->instIdx = genval.uword + 1; break; /* break out of generator loop */ } else { level = 2; if (gen_validp (genid)) { /* generator valid? */ genval.sword = READW(); dup = gen_inlist (genid, z->gen); } else skip = true; } if (!skip) { SFGen *g; if (!dup) { /* if gen ! dup alloc new */ g = new SFGen; g->id = genid; z->gen[i] = g; } else { g = dup; // ptr to orig gen drop = true; } g->amount = genval; } else { /* Skip this generator */ discarded = true; drop = true; FSKIPW (); } if (!drop) ++i; else { z->gen.removeAt(i); // drop place holder } } if (level == 3) z->gen.removeAt(i); // drop place holder else { // congratulations its a global zone if (!gzone) { // Prior global zones? gzone = true; // if global zone is not 1st zone, relocate if (k != 0) { Zone* save = zl.takeAt(k); qDebug("Preset \"%s\": Global zone is not first zone", qPrintable(p->name)); zl.prepend(save); continue; } } else { // previous global zone exists, discard qDebug("Preset \"%s\": Discarding invalid global zone", qPrintable(p->name)); sfont_zone_delete(&zl, z); } } for (; i < z->gen.size();) { discarded = true; if ((size -= SFGENSIZE) < 0) throw(QString("2:Preset generator chunk size mismatch")); FSKIP (SFGENSIZE); z->gen.removeAt(i); } } if (discarded) qDebug("Preset \"%s\": Some invalid generators were discarded", qPrintable(p->name)); } /* in case there isn't a terminal record */ if (size == 0) return; size -= SFGENSIZE; if (size != 0) throw(QString("3:Preset generator chunk size mismatch")); FSKIP (SFGENSIZE); /* terminal gen */ } /* instrument header loader */ void SFont::load_ihdr(int size) { Instrument *p, *pr = 0; /* ptr to current & previous instrument */ unsigned short zndx, pzndx = 0; if (size % SFIHDRSIZE || size == 0) /* chunk size is valid? */ throw(QString("Instrumentrument header has invalid size")); size = size / SFIHDRSIZE - 1; if (size == 0) { /* at least one preset + term record */ qWarning("File contains no instruments"); FSKIP (SFIHDRSIZE); return; } for (int i = 0; i < size; i++) { /* load all instrument headers */ p = new Instrument; instruments.append(p); char buffer[21]; READSTR (buffer); /* Possible read failure ^ */ zndx = READW(); if (pr) { /* not first instrument? */ if (zndx < pzndx) throw(QString("Instrument header indices not monotonic")); int i2 = zndx - pzndx; while (i2--) pr->zones.prepend(0); } else if (zndx > 0) { /* 1st inst, warn if ofs >0 */ qWarning("%d instrument zones not referenced, discarding", zndx); } pzndx = zndx; pr = p; /* update instrument ptr */ } FSKIP (20); zndx = READW(); if (zndx < pzndx) throw(QString("Instrumentrument header indices not monotonic")); int i2 = zndx - pzndx; while (i2--) pr->zones.prepend(0); } /* instrument bag loader */ void SFont::load_ibag(int size) { Zone *z, *pz = 0; unsigned short genndx, modndx, pgenndx = 0, pmodndx = 0; if (size % SFBAGSIZE || size == 0) /* size is multiple of SFBAGSIZE? */ throw(QString("Instrumentrument bag chunk size is invalid")); foreach(Instrument* in, instruments) { int n = in->zones.size(); for (int i = 0; i < n; ++i) { if ((size -= SFBAGSIZE) < 0) { throw(QString("Instrument bag chunk size mismatch")); } z = new Zone; in->zones[i] = z; genndx = READW(); modndx = READW(); z->sample = 0; if (pz) { /* if not first zone */ if (genndx < pgenndx) throw(QString("Instrumentrument generator indices not monotonic")); if (modndx < pmodndx) throw(QString("Instrumentrument modulator indices not monotonic")); int i2 = genndx - pgenndx; while (i2--) pz->gen.prepend(0); i2 = modndx - pmodndx; while (i2--) pz->mod.prepend(0); } pz = z; /* update previous zone ptr */ pgenndx = genndx; pmodndx = modndx; } } size -= SFBAGSIZE; if (size != 0) throw(QString("Instrumentrument chunk size mismatch")); genndx = READW(); modndx = READW(); if (!pz) { /* in case that all are no zoners */ if (genndx > 0) qWarning("No instrument generators and terminal index not 0"); if (modndx > 0) qWarning("No instrument modulators and terminal index not 0"); return; } if (genndx < pgenndx) throw(QString("Instrumentrument generator indices not monotonic")); if (modndx < pmodndx) throw(QString("Instrumentrument modulator indices not monotonic")); int i = genndx - pgenndx; while (i--) pz->gen.prepend(0); i = modndx - pmodndx; while (i--) pz->mod.prepend(0); } /* instrument modulator loader */ void SFont::load_imod(int size) { foreach(Instrument* i, instruments) { foreach(Zone* p2, i->zones) { for (int k = 0; k < p2->mod.size(); ++k) { if ((size -= SFMODSIZE) < 0) throw(QString("Instrumentrument modulator chunk size mismatch")); SFMod* m = new SFMod; m->src = READW(); m->dest = READW(); m->amount = READW(); m->amtsrc = READW(); m->trans = READW(); p2->mod[k] = m; } } } /* If there isn't even a terminal record Hmmm, the specs say there should be one, but.. */ if (size == 0) return; size -= SFMODSIZE; if (size != 0) throw(QString("Instrumentrument modulator chunk size mismatch")); FSKIP (SFMODSIZE); /* terminal mod */ } //--------------------------------------------------------- // load_igen // load instrument generators // (see load_pgen for loading rules) //--------------------------------------------------------- void SFont::load_igen (int size) { foreach(Instrument* instr, instruments) { bool gzone = false; bool discarded = false; QList zl = instr->zones; for (int k = 0; k < zl.size(); ++k) { int level = 0; Zone* z = zl[k]; int i = 0; for (; i < z->gen.size();) { SFGenAmount genval; SFGen* dup = 0; bool skip = false; bool drop = false; if ((size -= SFGENSIZE) < 0) throw(QString("IGEN chunk size mismatch")); unsigned short genid = READW(); if (genid == Gen_KeyRange) { /* nothing precedes */ if (level == 0) { level = 1; genval.range.lo = READB(); genval.range.hi = READB(); } else skip = true; } else if (genid == Gen_VelRange) { // only KeyRange precedes if (level <= 1) { level = 2; genval.range.lo = READB(); genval.range.hi = READB(); } else skip = true; } else if (genid == Gen_SampleId) { // sample is last gen level = 3; genval.uword = READW(); z->sampIdx = genval.uword + 1; break; /* break out of generator loop */ } else { level = 2; if (gen_valid (genid)) { // gen valid? genval.sword = READW(); dup = gen_inlist (genid, z->gen); } else skip = true; } if (!skip) { SFGen* g; if (!dup) { /* if gen ! dup alloc new */ g = new SFGen; g->id = genid; z->gen[i] = g; } else { g = dup; drop = true; } g->amount = genval; } else { /* skip this generator */ discarded = true; drop = true; FSKIPW (); } if (!drop) ++i; else z->gen.removeAt(i); } if (level == 3) z->gen.removeAt(i); else { /* its a global zone */ if (!gzone) { gzone = true; /* if global zone is not 1st zone, relocate */ if (k != 0) { Zone* save = zl.takeAt(k); zl.prepend(save); continue; } } else { /* previous global zone exists, discard */ sfont_zone_delete (&zl, z); } } for (; i < z->gen.size();) { discarded = true; if ((size -= SFGENSIZE) < 0) throw(QString("Instrumentrument generator chunk size mismatch")); FSKIP (SFGENSIZE); z->gen.removeAt(i); } } if (discarded && debugMode) qWarning("Instrument: Some invalid generators were discarded"); } /* for those non-terminal record cases, grr! */ if (size == 0) return; size -= SFGENSIZE; if (size != 0) throw(QString("IGEN chunk size mismatch")); FSKIP (SFGENSIZE); /* terminal gen */ } //--------------------------------------------------------- // load_shdr // sample header loader //--------------------------------------------------------- void SFont::load_shdr (int size) { if (size % SFSHDRSIZE || size == 0) /* size is multiple of SHDR size? */ throw(QString("Sample header has invalid size")); size = size / SFSHDRSIZE - 1; if (size == 0) { // at least one sample + term record? qWarning("File contains no samples"); FSKIP (SFSHDRSIZE); return; } /* load all sample headers */ for (int i = 0; i < size; i++) { Sample* p = new Sample(this); sample.append(p); char buffer[21]; READSTR (buffer); // READSTR (p->name); READD (p->start); READD (p->end); /* - end, loopstart and loopend */ READD (p->loopstart); /* - will be checked and turned into */ READD (p->loopend); READD (p->samplerate); p->origpitch = READB(); p->pitchadj = READC(); FSKIPW (); // skip sample link p->sampletype = READW(); if (p->sampletype & FLUID_SAMPLETYPE_ROM) { p->setValid(false); continue; } if ((p->end > getSamplesize()) || (p->start > (p->end - 4))) { qWarning("Sample start/end file positions are invalid, disabling"); p->setValid(false); continue; } p->setValid(true); if (p->sampletype & FLUID_SAMPLETYPE_OGG_VORBIS) { } else { // loop is fowled?? (cluck cluck :) if (p->loopend > p->end || p->loopstart >= p->loopend || p->loopstart <= p->start) { /* can pad loop by 8 samples and ensure at least 4 for loop (2*8+4) */ if ((p->end - p->start) >= 20) { p->loopstart = p->start + 8; p->loopend = p->end - 8; } else { // loop is fowled, sample is tiny (can't pad 8 samples) p->loopstart = p->start + 1; p->loopend = p->end - 1; } } if ((p->end - p->start) < 8) p->setValid(false); } } FSKIP (SFSHDRSIZE); /* skip terminal shdr */ } //--------------------------------------------------------- // fixup_pgen // "fixup" (inst # -> inst ptr) instrument references // in preset list //--------------------------------------------------------- void SFont::fixup_pgen() { foreach(Preset* p, presets) { foreach(Zone* z, p->zones) { if (z->instIdx) { // load instrument # z->instrument = instruments[z->instIdx-1]; if (!z->instrument) throw(QString("Preset %1 %2: Invalid instrument reference").arg(p->bank).arg(p->num)); } } } } /* "fixup" (sample # -> sample ptr) sample references in instrument list */ void SFont::fixup_igen() { foreach(Instrument* p, instruments) { foreach(Zone* z, p->zones) { if (z->sampIdx) { z->sample = sample[z->sampIdx - 1]; if (!z->sample) throw(QString("Instrument: Invalid sample reference")); // throw(QString("Instrument <%1>: Invalid sample reference").arg(p->name)); } } } } //--------------------------------------------------------- // safe_fread //--------------------------------------------------------- void SFont::safe_fread(void* buf, int count) { if (f.read((char*)buf, count) != count) { if (f.atEnd()) throw(QString("EOF while attemping to read %1 bytes").arg(count)); else throw(QString("File read failed")); } } //--------------------------------------------------------- // safe_fseek //--------------------------------------------------------- void SFont::safe_fseek(long ofs) { qint64 newpos = ofs + f.pos(); if (!f.seek(newpos)) throw(QString("File seek failed with offset = %1").arg(ofs)); } }