31#define _1200TH_ROOT_OF_2 1.000577789506555
32#define _200TH_ROOT_OF_10 1.011579454259899
35 double ToSeconds(
int Timecents) {
36 if (Timecents == NONE)
return NONE;
37 if (Timecents == 0)
return 1.0;
38 if (Timecents == -32768)
return 0.0;
39 return pow(_1200TH_ROOT_OF_2, Timecents);
42 double ToRatio(
int Centibels) {
43 if (Centibels == NONE)
return NONE;
44 if (Centibels == 0)
return 1.0;
45 return pow(_200TH_ROOT_OF_10, Centibels);
48 double ToHz(
int cents) {
49 if (cents == NONE)
return NONE;
50 if (cents == 0)
return 8.176;
51 return pow(_1200TH_ROOT_OF_2, cents) * 8.176;
54 RIFF::Chunk* GetMandatoryChunk(RIFF::List* list, uint32_t chunkId) {
56 if(ck == NULL)
throw Exception(
"Mandatory chunk in RIFF list chunk not found: " + ToString(chunkId));
60 void LoadString(RIFF::Chunk* ck, std::string& s,
int strLength) {
61 if(ck == NULL)
return;
62 char* buf =
new char[strLength];
64 for(
int i = 0; i < strLength; i++) {
66 if(buf[i] == 0 && !len) len = i;
68 if(!len) len = strLength;
78 if (ck == NULL)
throw Exception(
"NULL chunk");
80 throw Exception(
"Invalid chunk size. Chunk ID: " + ToString(ck->
GetChunkID()));
84 Modulator::Modulator(SFModulator mod) {
86 Polarity = mod & (1 << 9);
87 Direction = mod & (1 << 8);
88 MidiPalete = mod & (1 << 7);
93 ModulatorItem::ModulatorItem(ModList& mod) :
94 ModSrcOper(Modulator(mod.ModSrcOper)),
95 ModAmtSrcOper(Modulator(mod.ModAmtSrcOper))
119 pVer =
new Version(GetMandatoryChunk(lstINFO, CHUNK_ID_IFIL));
120 LoadString(CHUNK_ID_ISNG, lstINFO, SoundEngine);
121 LoadString(CHUNK_ID_INAM, lstINFO, BankName);
122 LoadString(CHUNK_ID_IROM, lstINFO, RomName);
124 LoadString(CHUNK_ID_ICRD, lstINFO, CreationDate);
125 LoadString(CHUNK_ID_IENG, lstINFO, Engineers);
126 LoadString(CHUNK_ID_IPRD, lstINFO, Product);
127 LoadString(CHUNK_ID_ICOP, lstINFO, Copyright);
128 LoadString(CHUNK_ID_ICMT, lstINFO, Comments);
129 LoadString(CHUNK_ID_ISFT, lstINFO, Software);
145 void Info::LoadString(uint32_t ChunkID,
RIFF::List* lstINFO, String& s) {
152 this->pCkSmpl = pCkSmpl;
153 this->pCkSm24 = pCkSm24;
155 LoadString(ck, Name, 20);
166 if (Start > End || !pCkSmpl || pCkSmpl->
GetSize() <= End) {
167 throw Exception(
"Broken SF2 file (invalid sample info)");
173 case sf2::Sample::MONO_SAMPLE :
174 case sf2::Sample::ROM_MONO_SAMPLE :
break;
175 case sf2::Sample::RIGHT_SAMPLE :
176 case sf2::Sample::LEFT_SAMPLE :
177 case sf2::Sample::ROM_RIGHT_SAMPLE :
178 case sf2::Sample::ROM_LEFT_SAMPLE : ChannelCount = 2;
break;
179 case sf2::Sample::LINKED_SAMPLE :
180 case sf2::Sample::ROM_LINKED_SAMPLE : std::cerr <<
"Linked samples not implemented yet";
break;
181 default:
throw Exception(
"Broken SF2 file (invalid sample type)");
185 RAMCache.pStart = NULL;
186 RAMCache.NullExtensionSize = 0;
189 int Sample::GetChannelCount() {
193 long Sample::GetTotalFrameCount() {
194 return (End - Start);
200 int Sample::GetFrameSize() {
201 return ChannelCount * ((pCkSm24 != NULL) ? 3 : 2);
204 bool Sample::HasLoops() {
205 return StartLoop != 0 && EndLoop != 0;
234 unsigned long Sample::ReadAndLoop (
236 unsigned long FrameCount,
237 PlaybackState* pPlaybackState,
241 unsigned long samplestoread = FrameCount, totalreadsamples = 0, readsamples, samplestoloopend;
242 uint8_t* pDst = (uint8_t*) pBuffer;
243 SetPos(pPlaybackState->position);
244 if (pRegion->HasLoop) {
246 samplestoloopend = pRegion->LoopEnd - GetPos();
247 readsamples = Read(&pDst[totalreadsamples * GetFrameSize()], Min(samplestoread, samplestoloopend));
248 samplestoread -= readsamples;
249 totalreadsamples += readsamples;
250 if (readsamples == samplestoloopend) {
251 SetPos(pRegion->LoopStart);
253 }
while (samplestoread && readsamples);
255 totalreadsamples = Read(pBuffer, FrameCount);
258 pPlaybackState->position = GetPos();
260 return totalreadsamples;
266 pParentInstrument = NULL;
267 loKey = hiKey = NONE;
268 minVel = maxVel = NONE;
269 startAddrsOffset = startAddrsCoarseOffset = endAddrsOffset = endAddrsCoarseOffset = 0;
270 startloopAddrsOffset = startloopAddrsCoarseOffset = endloopAddrsOffset = endloopAddrsCoarseOffset = 0;
271 pan = fineTune = coarseTune = 0;
272 overridingRootKey = -1;
275 LoopStart = LoopEnd = 0;
277 EG1PreAttackDelay = EG1Attack = EG1Hold = EG1Decay = EG1Release = -12000;
279 EG2PreAttackDelay = EG2Attack = EG2Hold = EG2Decay = EG2Release = -12000;
282 modEnvToPitch = modLfoToPitch = modEnvToFilterFc = modLfoToFilterFc = modLfoToVolume = 0;
284 delayModLfo = -12000;
287 delayVibLfo = -12000;
291 initialFilterFc = 13500;
295 int Region::GetUnityNote() {
296 return overridingRootKey != -1 ? overridingRootKey : pSample->OriginalPitch;
299 int CheckRange(std::string genName,
int min,
int max,
int& gen) {
300 if (gen == NONE)
return gen;
303 std::cerr <<
"sf2: " << genName;
304 std::cerr <<
" is below the minimum allowed value (min=" << min <<
"): " << gen << std::endl;
308 std::cerr <<
"sf2: " << genName;
309 std::cerr <<
" is above the maximum allowed value (max=" << max <<
"): " << gen << std::endl;
316 void Region::SetGenerator(sf2::File* pFile, GenList& Gen) {
317 switch(Gen.GenOper) {
318 case START_ADDRS_OFFSET:
319 startAddrsOffset = Gen.GenAmount.wAmount;
321 case END_ADDRS_OFFSET:
322 if (Gen.GenAmount.shAmount <= 0) {
323 endAddrsOffset = Gen.GenAmount.shAmount;
325 std::cerr <<
"Ignoring invalid endAddrsOffset" << std::endl;
328 case STARTLOOP_ADDRS_OFFSET:
329 startloopAddrsOffset = Gen.GenAmount.shAmount;
330 LoopStart += startloopAddrsOffset;
332 case ENDLOOP_ADDRS_OFFSET:
333 endloopAddrsOffset = Gen.GenAmount.shAmount;
334 LoopEnd += endloopAddrsOffset;
336 case START_ADDRS_COARSE_OFFSET:
337 startAddrsCoarseOffset = Gen.GenAmount.wAmount;
339 case MOD_LFO_TO_PITCH:
340 modLfoToPitch = Gen.GenAmount.shAmount;
341 CheckRange(
"modLfoToPitch", -12000, 12000, modLfoToPitch);
343 case VIB_LFO_TO_PITCH:
344 vibLfoToPitch = Gen.GenAmount.shAmount;
345 CheckRange(
"vibLfoToPitch", -12000, 12000, vibLfoToPitch);
347 case MOD_ENV_TO_PITCH:
348 modEnvToPitch = Gen.GenAmount.shAmount;
349 CheckRange(
"modEnvToPitch", -12000, 12000, modEnvToPitch);
351 case INITIAL_FILTER_FC:
352 initialFilterFc = Gen.GenAmount.wAmount;
353 CheckRange(
"initialFilterFc", 1500, 13500, initialFilterFc);
355 case INITIAL_FILTER_Q:
356 initialFilterQ = Gen.GenAmount.wAmount;
357 CheckRange(
"initialFilterQ", 0, 960, initialFilterQ);
359 case MOD_LFO_TO_FILTER_FC:
360 modLfoToFilterFc = Gen.GenAmount.shAmount;
361 CheckRange(
"modLfoToFilterFc", -12000, 12000, modLfoToFilterFc);
363 case MOD_ENV_TO_FILTER_FC:
364 modEnvToFilterFc = Gen.GenAmount.shAmount;
365 CheckRange(
"modEnvToFilterFc", -12000, 12000, modEnvToFilterFc);
367 case END_ADDRS_COARSE_OFFSET:
368 endAddrsCoarseOffset = Gen.GenAmount.wAmount;
370 case MOD_LFO_TO_VOLUME:
371 modLfoToVolume = Gen.GenAmount.shAmount;
372 CheckRange(
"modLfoToVolume", -960, 960, modLfoToVolume);
374 case CHORUS_EFFECTS_SEND:
376 case REVERB_EFFECTS_SEND:
379 pan = Gen.GenAmount.shAmount;
380 CheckRange(
"pan", -500, 500, pan);
381 pan = pan * 64 / 500;
382 if (pan > 63) pan = 63;
385 delayModLfo = Gen.GenAmount.shAmount;
386 CheckRange(
"delayModLfo", -12000, 5000, delayModLfo);
389 freqModLfo = Gen.GenAmount.shAmount;
390 CheckRange(
"freqModLfo", -16000, 4500, freqModLfo);
393 delayVibLfo = Gen.GenAmount.shAmount;
394 CheckRange(
"delayVibLfo", -12000, 5000, delayVibLfo);
397 freqVibLfo = Gen.GenAmount.shAmount;
398 CheckRange(
"freqModLfo", -16000, 4500, freqModLfo);
401 EG2PreAttackDelay = Gen.GenAmount.shAmount;
402 CheckRange(
"delayModEnv", -12000, 5000, EG2PreAttackDelay);
405 EG2Attack = Gen.GenAmount.shAmount;
406 CheckRange(
"attackModEnv", -12000, 8000, EG2Attack);
409 EG2Hold = Gen.GenAmount.shAmount;
410 CheckRange(
"holdModEnv", -12000, 5000, EG2Hold);
413 EG2Decay = Gen.GenAmount.shAmount;
414 CheckRange(
"decayModEnv", -12000, 8000, EG2Decay);
416 case SUSTAIN_MOD_ENV:
417 EG2Sustain = Gen.GenAmount.shAmount;
418 CheckRange(
"sustainModEnv", 0, 1000, EG2Sustain);
420 case RELEASE_MOD_ENV:
421 EG2Release = Gen.GenAmount.shAmount;
422 CheckRange(
"releaseModEnv", -12000, 8000, EG2Release);
424 case KEYNUM_TO_MOD_ENV_HOLD:
426 case KEYNUM_TO_MOD_ENV_DECAY:
429 EG1PreAttackDelay = Gen.GenAmount.shAmount;
430 CheckRange(
"delayVolEnv", -12000, 5000, EG1PreAttackDelay);
433 EG1Attack = Gen.GenAmount.shAmount;
434 CheckRange(
"attackVolEnv", -12000, 8000, EG1Attack);
437 EG1Hold = Gen.GenAmount.shAmount;
438 CheckRange(
"holdVolEnv", -12000, 5000, EG1Hold);
441 EG1Decay = Gen.GenAmount.shAmount;
442 CheckRange(
"decayVolEnv", -12000, 8000, EG1Decay);
444 case SUSTAIN_VOL_ENV:
445 EG1Sustain = Gen.GenAmount.shAmount;
446 CheckRange(
"sustainVolEnv", 0, 1440, EG1Sustain);
448 case RELEASE_VOL_ENV:
449 EG1Release = Gen.GenAmount.shAmount;
450 CheckRange(
"releaseVolEnv", -12000, 8000, EG1Release);
452 case KEYNUM_TO_VOL_ENV_HOLD:
454 case KEYNUM_TO_VOL_ENV_DECAY:
457 uint16_t
id = Gen.GenAmount.wAmount;
458 if (
id >= pFile->Instruments.size()) {
459 throw Exception(
"Broken SF2 file (missing instruments)");
461 pInstrument = pFile->Instruments[id];
465 loKey = Gen.GenAmount.ranges.byLo;
466 CheckRange(
"loKey", 0, 127, loKey);
467 hiKey = Gen.GenAmount.ranges.byHi;
468 CheckRange(
"hiKey", 0, 127, hiKey);
471 minVel = Gen.GenAmount.ranges.byLo;
472 CheckRange(
"minVel", 0, 127, minVel);
473 maxVel = Gen.GenAmount.ranges.byHi;
474 CheckRange(
"maxVel", 0, 127, maxVel);
476 case STARTLOOP_ADDRS_COARSE_OFFSET:
477 startloopAddrsCoarseOffset = Gen.GenAmount.shAmount;
478 LoopStart += uint(startloopAddrsCoarseOffset) << 15;
484 case INITIAL_ATTENUATION:
486 case ENDLOOP_ADDRS_COARSE_OFFSET:
487 endloopAddrsCoarseOffset = Gen.GenAmount.shAmount;
488 LoopEnd += uint(endloopAddrsCoarseOffset) << 15;
491 coarseTune = Gen.GenAmount.shAmount;
492 CheckRange(
"coarseTune", -120, 120, coarseTune);
495 fineTune = Gen.GenAmount.shAmount;
496 CheckRange(
"fineTune", -99, 99, fineTune);
499 uint16_t sid = Gen.GenAmount.wAmount;
500 if (sid >= pFile->Samples.size()) {
501 throw Exception(
"Broken SF2 file (missing samples)");
503 pSample = pFile->Samples[sid];
506 LoopStart += pSample->StartLoop;
507 LoopEnd += pSample->EndLoop;
508 if (LoopStart < pSample->Start) {
509 std::cerr <<
"sf2: loop start is below the sample start (min=" << pSample->Start <<
"): " << LoopStart << std::endl;
510 LoopStart = pSample->Start;
512 if (LoopEnd > pSample->End) {
513 std::cerr <<
"sf2: loop end is above the sample end (max=" << pSample->End <<
"): " << LoopEnd << std::endl;
514 LoopEnd = pSample->End;
516 if (LoopStart > LoopEnd) {
517 std::cerr <<
"sf2: loop start is above loop end (max=" << LoopEnd <<
"): " << LoopStart << std::endl;
520 LoopStart -= pSample->Start;
521 LoopEnd -= pSample->Start;
526 HasLoop = Gen.GenAmount.wAmount & 1;
532 case EXCLUSIVE_CLASS:
533 exclusiveClass = Gen.GenAmount.wAmount;
535 case OVERRIDING_ROOT_KEY:
536 overridingRootKey = Gen.GenAmount.shAmount;
537 CheckRange(
"overridingRootKey", -1, 127, overridingRootKey);
542 void Region::SetModulator(sf2::File* , ModList& Mod) {
543 modulators.push_back(ModulatorItem(Mod));
565 int Region::GetPan(Region* pPresetRegion) {
566 if (pPresetRegion == NULL)
return pan;
567 int p = pPresetRegion->pan + pan;
568 if (p < -64) p = -64;
573 int Region::GetFineTune(Region* pPresetRegion) {
574 if (pPresetRegion == NULL)
return fineTune;
575 int t = pPresetRegion->fineTune + fineTune;
576 if (t < -99) t = -99;
581 int Region::GetCoarseTune(Region* pPresetRegion) {
582 if (pPresetRegion == NULL)
return coarseTune;
583 int t = pPresetRegion->coarseTune + coarseTune;
584 if (t < -120) t = -120;
585 if (t > 120) t = 120;
589 double Region::GetEG1PreAttackDelay(Region* pPresetRegion) {
590 int val = (pPresetRegion == NULL || pPresetRegion->EG1PreAttackDelay == NONE) ?
591 EG1PreAttackDelay : pPresetRegion->EG1PreAttackDelay + EG1PreAttackDelay;
592 return ToSeconds(CheckRange(
"GetEG1PreAttackDelay()", -12000, 5000, val));
595 double Region::GetEG1Attack(Region* pPresetRegion) {
596 int val = (pPresetRegion == NULL || pPresetRegion->EG1Attack == NONE) ?
597 EG1Attack : pPresetRegion->EG1Attack + EG1Attack;
598 return ToSeconds(CheckRange(
"GetEG1Attack()", -12000, 8000, val));
601 double Region::GetEG1Hold(Region* pPresetRegion) {
602 int val = (pPresetRegion == NULL || pPresetRegion->EG1Hold == NONE) ?
603 EG1Hold : pPresetRegion->EG1Hold + EG1Hold;
604 return ToSeconds(CheckRange(
"GetEG1Hold()", -12000, 5000, val));
607 double Region::GetEG1Decay(Region* pPresetRegion) {
608 int val = (pPresetRegion == NULL || pPresetRegion->EG1Decay == NONE) ?
609 EG1Decay : pPresetRegion->EG1Decay + EG1Decay;
610 return ToSeconds(CheckRange(
"GetEG1Decay()", -12000, 8000, val));
613 int Region::GetEG1Sustain(Region* pPresetRegion) {
614 int val = (pPresetRegion == NULL || pPresetRegion->EG1Sustain == NONE) ?
615 EG1Sustain : pPresetRegion->EG1Sustain + EG1Sustain;
616 return CheckRange(
"GetEG1Sustain()", 0, 1440, val);
619 double Region::GetEG1Release(Region* pPresetRegion) {
620 int val = (pPresetRegion == NULL || pPresetRegion->EG1Release == NONE) ?
621 EG1Release : pPresetRegion->EG1Release + EG1Release;
622 return ToSeconds(CheckRange(
"GetEG1Release()", -12000, 8000, val));
625 double Region::GetEG2PreAttackDelay(Region* pPresetRegion) {
626 int val = (pPresetRegion == NULL || pPresetRegion->EG2PreAttackDelay == NONE) ?
627 EG2PreAttackDelay : pPresetRegion->EG2PreAttackDelay + EG2PreAttackDelay;
628 return ToSeconds(CheckRange(
"GetEG2PreAttackDelay()", -12000, 5000, val));
631 double Region::GetEG2Attack(Region* pPresetRegion) {
632 int val = (pPresetRegion == NULL || pPresetRegion->EG2Attack == NONE) ?
633 EG2Attack : pPresetRegion->EG2Attack + EG2Attack;
634 return ToSeconds(CheckRange(
"GetEG2Attack()", -12000, 8000, val));
637 double Region::GetEG2Hold(Region* pPresetRegion) {
638 int val = (pPresetRegion == NULL || pPresetRegion->EG2Hold == NONE) ?
639 EG2Hold : pPresetRegion->EG2Hold + EG2Hold;
640 return ToSeconds(CheckRange(
"GetEG2Hold()", -12000, 5000, val));
643 double Region::GetEG2Decay(Region* pPresetRegion) {
644 int val = (pPresetRegion == NULL || pPresetRegion->EG2Decay == NONE) ?
645 EG2Decay : pPresetRegion->EG2Decay + EG2Decay;
646 return ToSeconds(CheckRange(
"GetEG2Decay()", -12000, 8000, val));
649 int Region::GetEG2Sustain(Region* pPresetRegion) {
650 int val = (pPresetRegion == NULL || pPresetRegion->EG2Sustain == NONE) ?
651 EG2Sustain : pPresetRegion->EG2Sustain + EG2Sustain;
652 return CheckRange(
"GetEG2Sustain()", 0, 1000, val);
655 double Region::GetEG2Release(Region* pPresetRegion) {
656 int val = (pPresetRegion == NULL || pPresetRegion->EG2Release == NONE) ?
657 EG2Release : pPresetRegion->EG2Release + EG2Release;
658 return ToSeconds(CheckRange(
"GetEG2Release()", -12000, 8000, val));
661 int Region::GetModEnvToPitch(Region* pPresetRegion) {
662 int val = (pPresetRegion == NULL || pPresetRegion->modEnvToPitch == NONE) ?
663 modEnvToPitch : pPresetRegion->modEnvToPitch + modEnvToPitch;
664 return CheckRange(
"GetModEnvToPitch()", -12000, 12000, val);
667 int Region::GetModLfoToPitch(Region* pPresetRegion) {
668 int val = (pPresetRegion == NULL || pPresetRegion->modLfoToPitch == NONE) ?
669 modLfoToPitch : pPresetRegion->modLfoToPitch + modLfoToPitch;
670 return CheckRange(
"GetModLfoToPitch()", -12000, 12000, val);
673 int Region::GetModEnvToFilterFc(Region* pPresetRegion) {
674 int val = (pPresetRegion == NULL || pPresetRegion->modEnvToFilterFc == NONE) ?
675 modEnvToFilterFc : pPresetRegion->modEnvToFilterFc + modEnvToFilterFc;
676 return CheckRange(
"GetModEnvToFilterFc()", -12000, +12000, val);
679 int Region::GetModLfoToFilterFc(Region* pPresetRegion) {
680 int val = (pPresetRegion == NULL || pPresetRegion->modLfoToFilterFc == NONE) ?
681 modLfoToFilterFc : pPresetRegion->modLfoToFilterFc + modLfoToFilterFc;
682 return CheckRange(
"GetModLfoToFilterFc()", -12000, +12000, val);
685 double Region::GetModLfoToVolume(Region* pPresetRegion) {
686 int val = (pPresetRegion == NULL || pPresetRegion->modLfoToVolume == NONE) ?
687 modLfoToVolume : pPresetRegion->modLfoToVolume + modLfoToVolume;
688 return CheckRange(
"GetModLfoToVolume()", -960, 960, val);
691 double Region::GetFreqModLfo(Region* pPresetRegion) {
692 int val = (pPresetRegion == NULL || pPresetRegion->freqModLfo == NONE) ?
693 freqModLfo : pPresetRegion->freqModLfo + freqModLfo;
694 return ToHz(CheckRange(
"GetFreqModLfo()", -16000, 4500, val));
697 double Region::GetDelayModLfo(Region* pPresetRegion) {
698 int val = (pPresetRegion == NULL || pPresetRegion->delayModLfo == NONE) ?
699 delayModLfo : pPresetRegion->delayModLfo + delayModLfo;
700 return ToSeconds(CheckRange(
"GetDelayModLfo()", -12000, 5000, val));
703 int Region::GetVibLfoToPitch(Region* pPresetRegion) {
704 int val = (pPresetRegion == NULL || pPresetRegion->vibLfoToPitch == NONE) ?
705 vibLfoToPitch : pPresetRegion->vibLfoToPitch + vibLfoToPitch;
706 return CheckRange(
"GetVibLfoToPitch()", -12000, 12000, val);
709 double Region::GetFreqVibLfo(Region* pPresetRegion) {
710 int val = (pPresetRegion == NULL || pPresetRegion->freqVibLfo == NONE) ?
711 freqVibLfo : pPresetRegion->freqVibLfo + freqVibLfo;
712 return ToHz(CheckRange(
"GetFreqVibLfo()", -16000, 4500, val));
715 double Region::GetDelayVibLfo(Region* pPresetRegion) {
716 int val = (pPresetRegion == NULL || pPresetRegion->delayVibLfo == NONE) ?
717 delayVibLfo : pPresetRegion->delayVibLfo + delayVibLfo;
718 return ToSeconds(CheckRange(
"GetDelayVibLfo()", -12000, 5000, val));
721 int Region::GetInitialFilterFc(Region* pPresetRegion) {
722 if (pPresetRegion == NULL || pPresetRegion->initialFilterFc == NONE)
return initialFilterFc;
723 int val = pPresetRegion->initialFilterFc + initialFilterFc;
724 return CheckRange(
"GetInitialFilterFc()", 1500, 13500, val);
727 int Region::GetInitialFilterQ(Region* pPresetRegion) {
728 int val = (pPresetRegion == NULL || pPresetRegion->initialFilterQ == NONE) ?
729 initialFilterQ : pPresetRegion->initialFilterQ + initialFilterQ;
730 return CheckRange(
"GetInitialFilterQ()", 0, 960, val);
733 InstrumentBase::InstrumentBase(sf2::File* pFile) {
735 pGlobalRegion = NULL;
738 InstrumentBase::~InstrumentBase() {
739 if (pGlobalRegion)
delete pGlobalRegion;
740 for (ssize_t i = regions.size() - 1; i >= 0; i--) {
741 if (regions[i])
delete (regions[i]);
745 int InstrumentBase::GetRegionCount() {
746 return (
int) regions.size();
749 Region* InstrumentBase::GetRegion(
int idx) {
750 if (idx < 0 || idx >= GetRegionCount()) {
751 throw Exception(
"Region index out of bounds");
757 Query::Query(InstrumentBase& instrument) : instrument(instrument) {
761 Region* Query::next() {
762 while (i < instrument.GetRegionCount()) {
763 Region* r = instrument.GetRegion(i++);
764 if (((r->loKey == NONE && r->hiKey == NONE) || (key >= r->loKey && key <= r->hiKey)) &&
765 ((r->minVel == NONE && r->maxVel == NONE) || (vel >= r->minVel && vel <= r->maxVel))) {
772 Instrument::Instrument(sf2::File* pFile,
RIFF::Chunk* ck) : InstrumentBase(pFile) {
774 LoadString(ck, Name, 20);
778 Instrument::~Instrument() {
781 Region* Instrument::CreateRegion() {
782 Region* r =
new Region;
783 r->pParentInstrument =
this;
785 if (pGlobalRegion != NULL) {
786 r->loKey = pGlobalRegion->loKey;
787 r->hiKey = pGlobalRegion->hiKey;
788 r->minVel = pGlobalRegion->minVel;
789 r->maxVel = pGlobalRegion->maxVel;
790 r->pan = pGlobalRegion->pan;
791 r->fineTune = pGlobalRegion->fineTune;
792 r->coarseTune = pGlobalRegion->coarseTune;
793 r->overridingRootKey = pGlobalRegion->overridingRootKey;
794 r->startAddrsOffset = pGlobalRegion->startAddrsOffset;
795 r->startAddrsCoarseOffset = pGlobalRegion->startAddrsCoarseOffset;
796 r->endAddrsOffset = pGlobalRegion->endAddrsOffset;
797 r->endAddrsCoarseOffset = pGlobalRegion->endAddrsCoarseOffset;
798 r->startloopAddrsOffset = pGlobalRegion->startloopAddrsOffset;
799 r->startloopAddrsCoarseOffset = pGlobalRegion->startloopAddrsCoarseOffset;
800 r->endloopAddrsOffset = pGlobalRegion->endloopAddrsOffset;
801 r->endloopAddrsCoarseOffset = pGlobalRegion->endloopAddrsCoarseOffset;
803 r->EG1PreAttackDelay = pGlobalRegion->EG1PreAttackDelay;
804 r->EG1Attack = pGlobalRegion->EG1Attack;
805 r->EG1Hold = pGlobalRegion->EG1Hold;
806 r->EG1Decay = pGlobalRegion->EG1Decay;
807 r->EG1Sustain = pGlobalRegion->EG1Sustain;
808 r->EG1Release = pGlobalRegion->EG1Release;
810 r->EG2PreAttackDelay = pGlobalRegion->EG2PreAttackDelay;
811 r->EG2Attack = pGlobalRegion->EG2Attack;
812 r->EG2Hold = pGlobalRegion->EG2Hold;
813 r->EG2Decay = pGlobalRegion->EG2Decay;
814 r->EG2Sustain = pGlobalRegion->EG2Sustain;
815 r->EG2Release = pGlobalRegion->EG2Release;
817 r->modEnvToPitch = pGlobalRegion->modEnvToPitch;
818 r->modLfoToPitch = pGlobalRegion->modLfoToPitch;
819 r->modEnvToFilterFc = pGlobalRegion->modEnvToFilterFc;
820 r->modLfoToFilterFc = pGlobalRegion->modLfoToFilterFc;
821 r->modLfoToVolume = pGlobalRegion->modLfoToVolume;
822 r->freqModLfo = pGlobalRegion->freqModLfo;
823 r->delayModLfo = pGlobalRegion->delayModLfo;
824 r->vibLfoToPitch = pGlobalRegion->vibLfoToPitch;
825 r->freqVibLfo = pGlobalRegion->freqVibLfo;
826 r->delayVibLfo = pGlobalRegion->delayVibLfo;
827 r->initialFilterFc = pGlobalRegion->initialFilterFc;
828 r->initialFilterQ = pGlobalRegion->initialFilterQ;
830 r->HasLoop = pGlobalRegion->HasLoop;
831 r->LoopStart = pGlobalRegion->LoopStart;
832 r->LoopEnd = pGlobalRegion->LoopEnd;
834 r->exclusiveClass = pGlobalRegion->exclusiveClass;
840 void Instrument::DeleteRegion(Region* pRegion) {
841 for (
int i = 0; i < regions.size(); i++) {
842 if (regions[i] == pRegion) {
849 std::cerr <<
"Can't remove unknown Region" << std::endl;
852 void Instrument::LoadRegions(
int idx1,
int idx2) {
853 for (
int i = idx1; i < idx2; i++) {
854 int gIdx1 = pFile->InstBags[i].InstGenNdx;
855 int gIdx2 = pFile->InstBags[i + 1].InstGenNdx;
857 if (gIdx1 < 0 || gIdx2 < 0 || gIdx1 > gIdx2 || gIdx2 >= pFile->InstGenLists.size()) {
858 throw Exception(
"Broken SF2 file (invalid InstGenNdx)");
861 int mIdx1 = pFile->InstBags[i].InstModNdx;
862 int mIdx2 = pFile->InstBags[i + 1].InstModNdx;
864 if (mIdx1 < 0 || mIdx2 < 0 || mIdx1 > mIdx2 || mIdx2 >= pFile->InstModLists.size()) {
865 throw Exception(
"Broken SF2 file (invalid InstModNdx)");
868 Region* reg = CreateRegion();
870 for (
int j = gIdx1; j < gIdx2; j++) {
871 reg->SetGenerator(pFile, pFile->InstGenLists[j]);
875 for (
int j = mIdx1; j < mIdx2; j++) {
876 reg->SetModulator(pFile, pFile->InstModLists[j]);
879 if (reg->pSample == NULL) {
880 if (i == idx1 && idx2 - idx1 > 1) {
883 std::cerr <<
"Ignoring instrument's region without sample" << std::endl;
887 regions.push_back(reg);
892 Preset::Preset(sf2::File* pFile,
RIFF::Chunk* ck): InstrumentBase(pFile) {
894 LoadString(ck, Name, 20);
906 Region* Preset::CreateRegion() {
907 Region* r =
new Region;
909 r->EG1PreAttackDelay = r->EG1Attack = r->EG1Hold = r->EG1Decay = r->EG1Sustain = r->EG1Release = NONE;
910 r->EG2PreAttackDelay = r->EG2Attack = r->EG2Hold = r->EG2Decay = r->EG2Sustain = r->EG2Release = NONE;
911 r->freqModLfo = r->delayModLfo = r->freqVibLfo = r->delayVibLfo = NONE;
912 r->initialFilterFc = r->initialFilterQ = NONE;
914 if (pGlobalRegion != NULL) {
915 r->pan = pGlobalRegion->pan;
916 r->fineTune = pGlobalRegion->fineTune;
917 r->coarseTune = pGlobalRegion->coarseTune;
919 r->EG1PreAttackDelay = pGlobalRegion->EG1PreAttackDelay;
920 r->EG1Attack = pGlobalRegion->EG1Attack;
921 r->EG1Hold = pGlobalRegion->EG1Hold;
922 r->EG1Decay = pGlobalRegion->EG1Decay;
923 r->EG1Sustain = pGlobalRegion->EG1Sustain;
924 r->EG1Release = pGlobalRegion->EG1Release;
926 r->EG2PreAttackDelay = pGlobalRegion->EG2PreAttackDelay;
927 r->EG2Attack = pGlobalRegion->EG2Attack;
928 r->EG2Hold = pGlobalRegion->EG2Hold;
929 r->EG2Decay = pGlobalRegion->EG2Decay;
930 r->EG2Sustain = pGlobalRegion->EG2Sustain;
931 r->EG2Release = pGlobalRegion->EG2Release;
933 r->modEnvToPitch = pGlobalRegion->modEnvToPitch;
934 r->modLfoToPitch = pGlobalRegion->modLfoToPitch;
935 r->modEnvToFilterFc = pGlobalRegion->modEnvToFilterFc;
936 r->modLfoToFilterFc = pGlobalRegion->modLfoToFilterFc;
937 r->modLfoToVolume = pGlobalRegion->modLfoToVolume;
938 r->freqModLfo = pGlobalRegion->freqModLfo;
939 r->delayModLfo = pGlobalRegion->delayModLfo;
940 r->vibLfoToPitch = pGlobalRegion->vibLfoToPitch;
941 r->freqVibLfo = pGlobalRegion->freqVibLfo;
942 r->delayVibLfo = pGlobalRegion->delayVibLfo;
943 r->initialFilterFc = pGlobalRegion->initialFilterFc;
944 r->initialFilterQ = pGlobalRegion->initialFilterQ;
950 void Preset::LoadRegions(
int idx1,
int idx2) {
951 for (
int i = idx1; i < idx2; i++) {
952 int gIdx1 = pFile->PresetBags[i].GenNdx;
953 int gIdx2 = pFile->PresetBags[i + 1].GenNdx;
955 if (gIdx1 < 0 || gIdx2 < 0 || gIdx1 > gIdx2 || gIdx2 >= pFile->PresetGenLists.size()) {
956 throw Exception(
"Broken SF2 file (invalid PresetGenNdx)");
959 Region* reg = CreateRegion();
961 for (
int j = gIdx1; j < gIdx2; j++) {
962 reg->SetGenerator(pFile, pFile->PresetGenLists[j]);
964 if (reg->pInstrument == NULL) {
965 if (i == idx1 && idx2 - idx1 > 1) {
968 std::cerr <<
"Ignoring preset's region without instrument" << std::endl;
972 regions.push_back(reg);
987 if (!pRIFF)
throw Exception(
"NULL pointer reference to RIFF::File object.");
991 throw Exception(
"Not a SF2 file");
994 pInfo =
new Info(pRIFF);
995 if (pInfo->pVer->Major != 2) {
996 throw Exception(
"Unsupported version: " + ToString(pInfo->pVer->Major));
1000 if (lstSDTA == NULL) {
1001 throw Exception(
"Broken SF2 file (missing sdta)");
1006 if (pCkSmpl != NULL && pCkSm24 != NULL) {
1007 long l = pCkSmpl->
GetSize() / 2;
1009 if (pCkSm24->
GetSize() != l) {
1015 if (lstPDTA == NULL) {
1016 throw Exception(
"Broken SF2 file (missing pdta)");
1021 throw Exception(
"Broken SF2 file (broken phdr)");
1024 int count = (int) ck->
GetSize() / 38;
1025 for (
int i = 0; i < count; i++) {
1026 Presets.push_back(
new Preset(
this, ck));
1029 ck = GetMandatoryChunk(lstPDTA, CHUNK_ID_PBAG);
1031 throw Exception(
"Broken SF2 file (broken pbag)");
1034 count = int(ck->
GetSize() / 4);
1035 for (
int i = 0; i < count; i++) {
1039 PresetBags.push_back(pb);
1043 ck = GetMandatoryChunk(lstPDTA, CHUNK_ID_PMOD);
1045 throw Exception(
"Broken SF2 file (broken pmod)");
1048 count = int(ck->
GetSize() / 10);
1049 for (
int i = 0; i < count; i++) {
1056 PresetModLists.push_back(ml);
1060 ck = GetMandatoryChunk(lstPDTA, CHUNK_ID_PGEN);
1062 throw Exception(
"Broken SF2 file (broken pgen)");
1065 count = int(ck->
GetSize() / 4);
1066 for (
int i = 0; i < count; i++) {
1070 PresetGenLists.push_back(gl);
1074 ck = GetMandatoryChunk(lstPDTA, CHUNK_ID_INST);
1076 throw Exception(
"Broken SF2 file (broken inst)");
1078 count = int(ck->
GetSize() / 22);
1079 for (
int i = 0; i < count; i++) {
1080 Instruments.push_back(
new Instrument(
this, ck));
1083 ck = GetMandatoryChunk(lstPDTA, CHUNK_ID_IBAG);
1085 throw Exception(
"Broken SF2 file (broken ibag)");
1088 count = int(ck->
GetSize() / 4);
1089 for (
int i = 0; i < count; i++) {
1093 InstBags.push_back(ib);
1097 ck = GetMandatoryChunk(lstPDTA, CHUNK_ID_IMOD);
1099 throw Exception(
"Broken SF2 file (broken imod)");
1102 count = int(ck->
GetSize() / 10);
1103 for (
int i = 0; i < count; i++) {
1110 InstModLists.push_back(ml);
1114 ck = GetMandatoryChunk(lstPDTA, CHUNK_ID_IGEN);
1116 throw Exception(
"Broken SF2 file (broken igen)");
1119 count = int(ck->
GetSize() / 4);
1120 for (
int i = 0; i < count; i++) {
1124 InstGenLists.push_back(gl);
1128 ck = GetMandatoryChunk(lstPDTA, CHUNK_ID_SHDR);
1130 throw Exception(
"Broken SF2 file (broken shdr)");
1132 count = int(ck->
GetSize() / 46);
1133 for (
int i = 0; i < count; i++) {
1134 Samples.push_back(
new Sample(
this, ck, pCkSmpl, pCkSm24));
1138 for (
int i = 0; i < Instruments.size() - 1; i++) {
1139 Instrument* instr = Instruments[i];
1140 int x1 = instr->InstBagNdx;
1141 int x2 = Instruments[i + 1]->InstBagNdx;
1142 if (x1 < 0 || x2 < 0 || x1 > x2 || x2 >= InstBags.size()) {
1143 throw Exception(
"Broken SF2 file (invalid InstBagNdx)");
1146 instr->LoadRegions(x1, x2);
1150 for (
int i = 0; i < Presets.size() - 1; i++) {
1151 Preset* preset = Presets[i];
1152 int x1 = preset->PresetBagNdx;
1153 int x2 = Presets[i + 1]->PresetBagNdx;
1154 if (x1 < 0 || x2 < 0 || x1 > x2 || x2 >= PresetBags.size()) {
1155 throw Exception(
"Broken SF2 file (invalid PresetBagNdx)");
1158 preset->LoadRegions(x1, x2);
1164 for (ssize_t i = Presets.size() - 1; i >= 0; i--) {
1165 if (Presets[i])
delete (Presets[i]);
1167 for (ssize_t i = Instruments.size() - 1; i >= 0; i--) {
1168 if (Instruments[i])
delete (Instruments[i]);
1170 for (ssize_t i = Samples.size() - 1; i >= 0; i--) {
1171 if (Samples[i])
delete (Samples[i]);
1175 int File::GetPresetCount() {
1176 return (
int) Presets.size() - 1;
1179 Preset* File::GetPreset(
int idx) {
1180 if (idx < 0 || idx >= GetPresetCount()) {
1181 throw Exception(
"Preset index out of bounds");
1184 return Presets[idx];
1187 int File::GetInstrumentCount() {
1188 return (
int) Instruments.size() - 1;
1191 Instrument* File::GetInstrument(
int idx) {
1192 if (idx < 0 || idx >= GetInstrumentCount()) {
1193 throw Exception(
"Instrument index out of bounds");
1196 return Instruments[idx];
1199 void File::DeleteInstrument(Instrument* pInstrument) {
1200 if (!pInstrument)
return;
1202 for (
int i = 0; i < GetPresetCount(); i++) {
1203 Preset* p = GetPreset(i);
1204 if (p == NULL)
continue;
1205 for (
int j = p->GetRegionCount() - 1; j >= 0 ; j--) {
1206 if (p->GetRegion(j) && p->GetRegion(j)->pInstrument == pInstrument) {
1207 p->GetRegion(j)->pInstrument = NULL;
1212 for (
int i = 0; i < GetInstrumentCount(); i++) {
1213 if (GetInstrument(i) == pInstrument) {
1214 Instruments[i] = NULL;
1224 int File::GetSampleCount() {
1225 return (
int) Samples.size() - 1;
1228 Sample* File::GetSample(
int idx) {
1229 if (idx < 0 || idx >= GetSampleCount()) {
1230 throw Exception(
"Sample index out of bounds");
1233 return Samples[idx];
1236 void File::DeleteSample(Sample* pSample) {
1238 for (
int i = GetInstrumentCount() - 1; i >= 0; i--) {
1239 Instrument* pInstr = GetInstrument(i);
1240 if (pInstr == NULL)
continue;
1242 for (
int j = pInstr->GetRegionCount() - 1; j >= 0 ; j--) {
1243 if (pInstr->GetRegion(j) && pInstr->GetRegion(j)->GetSample() == pSample) {
1244 std::cerr <<
"Deleting sample which is still in use" << std::endl;
1250 for (
int i = 0; i < GetSampleCount(); i++) {
1251 if (Samples[i] == pSample) {
1258 throw Exception(
"Unknown sample: " + pSample->Name);
1261 bool File::HasSamples() {
1262 for (
int i = 0; i < GetSampleCount(); i++) {
1263 if (Samples[i] != NULL)
return true;
1282 Sample::buffer_t Sample::LoadSampleData() {
1283 return LoadSampleDataWithNullSamplesExtension(GetTotalFrameCount(), 0);
1304 Sample::buffer_t Sample::LoadSampleData(
unsigned long SampleCount) {
1305 return LoadSampleDataWithNullSamplesExtension(SampleCount, 0);
1327 Sample::buffer_t Sample::LoadSampleDataWithNullSamplesExtension(uint NullSamplesCount) {
1328 return LoadSampleDataWithNullSamplesExtension(GetTotalFrameCount(), NullSamplesCount);
1359 Sample::buffer_t Sample::LoadSampleDataWithNullSamplesExtension(
unsigned long SampleCount, uint NullSamplesCount) {
1360 if (SampleCount > GetTotalFrameCount()) SampleCount = GetTotalFrameCount();
1361 if (RAMCache.pStart)
delete[] (int8_t*) RAMCache.pStart;
1362 unsigned long allocationsize = (SampleCount + NullSamplesCount) * GetFrameSize();
1364 RAMCache.pStart =
new int8_t[allocationsize];
1365 RAMCache.Size = Read(RAMCache.pStart, SampleCount) * GetFrameSize();
1366 RAMCache.NullExtensionSize = allocationsize - RAMCache.Size;
1368 memset((int8_t*)RAMCache.pStart + RAMCache.Size, 0, RAMCache.NullExtensionSize);
1382 Sample::buffer_t Sample::GetCache() {
1385 result.
Size = this->RAMCache.Size;
1386 result.pStart = this->RAMCache.pStart;
1387 result.NullExtensionSize = this->RAMCache.NullExtensionSize;
1397 void Sample::ReleaseSampleData() {
1398 if (RAMCache.pStart)
delete[] (int8_t*) RAMCache.pStart;
1399 RAMCache.pStart = NULL;
1401 RAMCache.NullExtensionSize = 0;
1413 unsigned long Sample::SetPos(
unsigned long SampleCount) {
1414 pCkSmpl->
SetPos((Start * 2) + (SampleCount * 2), RIFF::stream_start);
1415 if(pCkSm24) pCkSm24->
SetPos(Start + SampleCount, RIFF::stream_start);
1422 unsigned long Sample::GetPos() {
1423 return (pCkSmpl->
GetPos() - (Start * 2)) / 2;
1427 template<
bool CLEAR>
1428 inline unsigned long ReadSample(Sample* pSample,
void* pBuffer,
unsigned long SampleCount, Sample::buffer_t* tempBuffer = NULL) {
1430 if (SampleCount == 0)
return 0;
1431 long pos = pSample->GetPos();
1433 if (pos >= pSample->GetTotalFrameCount())
1435 if (pos + SampleCount > pSample->GetTotalFrameCount())
1436 SampleCount = pSample->GetTotalFrameCount() - pos;
1438 if (tempBuffer->Size < SampleCount * pSample->GetFrameSize()) {
1439 std::cerr <<
"sf2::Sample error: tempBuffer too small. This is a BUG!" << std::endl;
1445 const bool bMono = (pSample->GetChannelCount() == 1);
1447 if (pSample->GetFrameSize() / pSample->GetChannelCount() == 3 ) {
1448 uint8_t*
const pBuf = (uint8_t*) pBuffer;
1451 uint8_t*
const pStage = (CLEAR) ? pBuf : (uint8_t*) tempBuffer->pStart;
1452 pSample->pCkSmpl->Read(pStage, SampleCount * 2, 1);
1453 pSample->pCkSm24->Read(pStage + SampleCount * 2, SampleCount, 1);
1458 interleave16_8to24(pStage, SampleCount);
1464 if (pSample->SampleType == Sample::LEFT_SAMPLE || pSample->SampleType == Sample::ROM_LEFT_SAMPLE) {
1465 for (
long i = SampleCount - 1; i >= 0; i--) {
1466 pBuf[i*6 + 2] = pStage[i*3 + 2];
1467 pBuf[i*6 + 1] = pStage[i*3 + 1];
1468 pBuf[i*6] = pStage[i*3];
1469 pBuf[i*6 + 3] = pBuf[i*6 + 4] = pBuf[i*6 + 5] = 0;
1471 }
else if (pSample->SampleType == Sample::RIGHT_SAMPLE || pSample->SampleType == Sample::ROM_RIGHT_SAMPLE) {
1472 for (
long i = SampleCount - 1; i >= 0; i--) {
1473 pBuf[i*6 + 5] = pStage[i*3 + 2];
1474 pBuf[i*6 + 4] = pStage[i*3 + 1];
1475 pBuf[i*6 + 3] = pStage[i*3];
1476 pBuf[i*6] = pBuf[i*6 + 1] = pBuf[i*6 + 2] = 0;
1485 for (
unsigned long i = 0; i < SampleCount; i++) {
1486 pBuf[i*3] = pStage[SampleCount * 2 + i];
1487 pBuf[i*3 + 1] = pStage[i * 2];
1488 pBuf[i*3 + 2] = pStage[i * 2 + 1];
1490 }
else if (pSample->SampleType == Sample::LEFT_SAMPLE || pSample->SampleType == Sample::ROM_LEFT_SAMPLE) {
1491 for (
unsigned long i = 0; i < SampleCount; i++) {
1492 pBuf[i*6] = pStage[SampleCount * 2 + i];
1493 pBuf[i*6 + 1] = pStage[i * 2];
1494 pBuf[i*6 + 2] = pStage[i * 2 + 1];
1496 }
else if (pSample->SampleType == Sample::RIGHT_SAMPLE || pSample->SampleType == Sample::ROM_RIGHT_SAMPLE) {
1497 for (
unsigned long i = 0; i < SampleCount; i++) {
1498 pBuf[i*6 + 3] = pStage[SampleCount * 2 + i];
1499 pBuf[i*6 + 4] = pStage[i * 2];
1500 pBuf[i*6 + 5] = pStage[i * 2 + 1];
1506 return pSample->pCkSmpl->Read(pBuffer, SampleCount, 2);
1509 int16_t*
const pTmpBuf = (int16_t*) ((CLEAR) ? pBuffer : tempBuffer->pStart);
1510 int16_t*
const pBuf = (int16_t*) pBuffer;
1511 if (pSample->SampleType == Sample::LEFT_SAMPLE || pSample->SampleType == Sample::ROM_LEFT_SAMPLE) {
1512 pSample->pCkSmpl->Read(pTmpBuf, SampleCount, 2);
1513 for (
long i = SampleCount - 1; i >= 0; i--) {
1514 pBuf[i*2] = pTmpBuf[i];
1518 }
else if (pSample->SampleType == Sample::RIGHT_SAMPLE || pSample->SampleType == Sample::ROM_RIGHT_SAMPLE) {
1519 pSample->pCkSmpl->Read(pTmpBuf, SampleCount, 2);
1520 for (
long i = SampleCount - 1; i >= 0; i--) {
1524 pBuf[i*2 + 1] = pTmpBuf[i];
1531 if (pSample->pCkSmpl->GetPos() > (pSample->End * 2)) {
1532 std::cerr <<
"Read after the sample end. This is a BUG!" << std::endl;
1533 std::cerr <<
"Current position: " << pSample->GetPos() << std::endl;
1534 std::cerr <<
"Total number of frames: " << pSample->GetTotalFrameCount() << std::endl << std::endl;
1562 unsigned long Sample::Read(
void* pBuffer,
unsigned long SampleCount) {
1563 return ReadSample<true>(
this, pBuffer, SampleCount);
1596 unsigned long Sample::ReadNoClear(
void* pBuffer,
unsigned long SampleCount, buffer_t& tempBuffer) {
1597 return ReadSample<false>(
this, pBuffer, SampleCount, &tempBuffer);
file_offset_t ReadInt8(int8_t *pData, file_offset_t WordCount=1)
Reads WordCount number of 8 Bit signed integer words and copies it into the buffer pointed by pData.
file_offset_t SetPos(file_offset_t Where, stream_whence_t Whence=stream_start)
Sets the position within the chunk body, thus within the data portion of the chunk (in bytes).
file_offset_t GetPos() const
Current read/write position within the chunk data body (starting with 0).
file_offset_t ReadUint16(uint16_t *pData, file_offset_t WordCount=1)
Reads WordCount number of 16 Bit unsigned integer words and copies it into the buffer pointed by pDat...
file_offset_t ReadInt16(int16_t *pData, file_offset_t WordCount=1)
Reads WordCount number of 16 Bit signed integer words and copies it into the buffer pointed by pData.
uint32_t GetChunkID() const
Chunk ID in unsigned integer representation.
file_offset_t ReadInt32(int32_t *pData, file_offset_t WordCount=1)
Reads WordCount number of 32 Bit signed integer words and copies it into the buffer pointed by pData.
file_offset_t GetSize() const
Chunk size in bytes (without header, thus the chunk data body).
Chunk * GetSubChunk(uint32_t ChunkID)
Returns subchunk with chunk ID ChunkID within this chunk list.
List * GetSubList(uint32_t ListType)
Returns sublist chunk with list type ListType within this chunk list.
uint32_t GetListType() const
Returns unsigned integer representation of the list's ID.
uint32_t Version
Version number data type.
SoundFont specific classes and definitions.
void VerifySize(RIFF::Chunk *ck, int size)
Throws an error if the chunk is NULL or the chunk data size is less than size (in bytes).
String libraryVersion()
Returns version of this C++ library.
String libraryName()
Returns the name of this C++ library.
file_offset_t Size
Size of the actual data in the buffer in bytes.