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;
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) {
151 this->pCkSmpl = pCkSmpl;
152 this->pCkSm24 = pCkSm24;
154 LoadString(ck, Name, 20);
165 if (Start > End || !pCkSmpl || pCkSmpl->
GetSize() <= End) {
166 throw Exception(
"Broken SF2 file (invalid sample info)");
172 case sf2::Sample::MONO_SAMPLE :
173 case sf2::Sample::ROM_MONO_SAMPLE :
break;
174 case sf2::Sample::RIGHT_SAMPLE :
175 case sf2::Sample::LEFT_SAMPLE :
176 case sf2::Sample::ROM_RIGHT_SAMPLE :
177 case sf2::Sample::ROM_LEFT_SAMPLE : ChannelCount = 2;
break;
178 case sf2::Sample::LINKED_SAMPLE :
179 case sf2::Sample::ROM_LINKED_SAMPLE : std::cerr <<
"Linked samples not implemented yet";
break;
180 default:
throw Exception(
"Broken SF2 file (invalid sample type)");
184 RAMCache.pStart = NULL;
185 RAMCache.NullExtensionSize = 0;
188 int Sample::GetChannelCount() {
192 long Sample::GetTotalFrameCount() {
193 return (End - Start);
199 int Sample::GetFrameSize() {
200 return ChannelCount * ((pCkSm24 != NULL) ? 3 : 2);
203 bool Sample::HasLoops() {
204 return StartLoop != 0 && EndLoop != 0;
233 unsigned long Sample::ReadAndLoop (
235 unsigned long FrameCount,
236 PlaybackState* pPlaybackState,
240 unsigned long samplestoread = FrameCount, totalreadsamples = 0, readsamples, samplestoloopend;
241 uint8_t* pDst = (uint8_t*) pBuffer;
242 SetPos(pPlaybackState->position);
243 if (pRegion->HasLoop) {
245 samplestoloopend = pRegion->LoopEnd - GetPos();
246 readsamples = Read(&pDst[totalreadsamples * GetFrameSize()], Min(samplestoread, samplestoloopend));
247 samplestoread -= readsamples;
248 totalreadsamples += readsamples;
249 if (readsamples == samplestoloopend) {
250 SetPos(pRegion->LoopStart);
252 }
while (samplestoread && readsamples);
254 totalreadsamples = Read(pBuffer, FrameCount);
257 pPlaybackState->position = GetPos();
259 return totalreadsamples;
265 pParentInstrument = NULL;
266 loKey = hiKey = NONE;
267 minVel = maxVel = NONE;
268 startAddrsOffset = startAddrsCoarseOffset = endAddrsOffset = endAddrsCoarseOffset = 0;
269 startloopAddrsOffset = startloopAddrsCoarseOffset = endloopAddrsOffset = endloopAddrsCoarseOffset = 0;
270 pan = fineTune = coarseTune = 0;
271 overridingRootKey = -1;
274 LoopStart = LoopEnd = 0;
276 EG1PreAttackDelay = EG1Attack = EG1Hold = EG1Decay = EG1Release = -12000;
278 EG2PreAttackDelay = EG2Attack = EG2Hold = EG2Decay = EG2Release = -12000;
281 modEnvToPitch = modLfoToPitch = modEnvToFilterFc = modLfoToFilterFc = modLfoToVolume = 0;
283 delayModLfo = -12000;
286 delayVibLfo = -12000;
290 initialFilterFc = 13500;
294 int Region::GetUnityNote() {
295 return overridingRootKey != -1 ? overridingRootKey : pSample->OriginalPitch;
298 int CheckRange(std::string genName,
int min,
int max,
int& gen) {
299 if (gen == NONE)
return gen;
302 std::cerr <<
"sf2: " << genName;
303 std::cerr <<
" is below the minimum allowed value (min=" << min <<
"): " << gen << std::endl;
307 std::cerr <<
"sf2: " << genName;
308 std::cerr <<
" is above the maximum allowed value (max=" << max <<
"): " << gen << std::endl;
315 void Region::SetGenerator(sf2::File* pFile, GenList& Gen) {
316 switch(Gen.GenOper) {
317 case START_ADDRS_OFFSET:
318 startAddrsOffset = Gen.GenAmount.wAmount;
320 case END_ADDRS_OFFSET:
321 if (Gen.GenAmount.shAmount <= 0) {
322 endAddrsOffset = Gen.GenAmount.shAmount;
324 std::cerr <<
"Ignoring invalid endAddrsOffset" << std::endl;
327 case STARTLOOP_ADDRS_OFFSET:
328 startloopAddrsOffset = Gen.GenAmount.shAmount;
329 LoopStart += startloopAddrsOffset;
331 case ENDLOOP_ADDRS_OFFSET:
332 endloopAddrsOffset = Gen.GenAmount.shAmount;
333 LoopEnd += endloopAddrsOffset;
335 case START_ADDRS_COARSE_OFFSET:
336 startAddrsCoarseOffset = Gen.GenAmount.wAmount;
338 case MOD_LFO_TO_PITCH:
339 modLfoToPitch = Gen.GenAmount.shAmount;
340 CheckRange(
"modLfoToPitch", -12000, 12000, modLfoToPitch);
342 case VIB_LFO_TO_PITCH:
343 vibLfoToPitch = Gen.GenAmount.shAmount;
344 CheckRange(
"vibLfoToPitch", -12000, 12000, vibLfoToPitch);
346 case MOD_ENV_TO_PITCH:
347 modEnvToPitch = Gen.GenAmount.shAmount;
348 CheckRange(
"modEnvToPitch", -12000, 12000, modEnvToPitch);
350 case INITIAL_FILTER_FC:
351 initialFilterFc = Gen.GenAmount.wAmount;
352 CheckRange(
"initialFilterFc", 1500, 13500, initialFilterFc);
354 case INITIAL_FILTER_Q:
355 initialFilterQ = Gen.GenAmount.wAmount;
356 CheckRange(
"initialFilterQ", 0, 960, initialFilterQ);
358 case MOD_LFO_TO_FILTER_FC:
359 modLfoToFilterFc = Gen.GenAmount.shAmount;
360 CheckRange(
"modLfoToFilterFc", -12000, 12000, modLfoToFilterFc);
362 case MOD_ENV_TO_FILTER_FC:
363 modEnvToFilterFc = Gen.GenAmount.shAmount;
364 CheckRange(
"modEnvToFilterFc", -12000, 12000, modEnvToFilterFc);
366 case END_ADDRS_COARSE_OFFSET:
367 endAddrsCoarseOffset = Gen.GenAmount.wAmount;
369 case MOD_LFO_TO_VOLUME:
370 modLfoToVolume = Gen.GenAmount.shAmount;
371 CheckRange(
"modLfoToVolume", -960, 960, modLfoToVolume);
373 case CHORUS_EFFECTS_SEND:
375 case REVERB_EFFECTS_SEND:
378 pan = Gen.GenAmount.shAmount;
379 CheckRange(
"pan", -500, 500, pan);
380 pan = pan * 64 / 500;
381 if (pan > 63) pan = 63;
384 delayModLfo = Gen.GenAmount.shAmount;
385 CheckRange(
"delayModLfo", -12000, 5000, delayModLfo);
388 freqModLfo = Gen.GenAmount.shAmount;
389 CheckRange(
"freqModLfo", -16000, 4500, freqModLfo);
392 delayVibLfo = Gen.GenAmount.shAmount;
393 CheckRange(
"delayVibLfo", -12000, 5000, delayVibLfo);
396 freqVibLfo = Gen.GenAmount.shAmount;
397 CheckRange(
"freqModLfo", -16000, 4500, freqModLfo);
400 EG2PreAttackDelay = Gen.GenAmount.shAmount;
401 CheckRange(
"delayModEnv", -12000, 5000, EG2PreAttackDelay);
404 EG2Attack = Gen.GenAmount.shAmount;
405 CheckRange(
"attackModEnv", -12000, 8000, EG2Attack);
408 EG2Hold = Gen.GenAmount.shAmount;
409 CheckRange(
"holdModEnv", -12000, 5000, EG2Hold);
412 EG2Decay = Gen.GenAmount.shAmount;
413 CheckRange(
"decayModEnv", -12000, 8000, EG2Decay);
415 case SUSTAIN_MOD_ENV:
416 EG2Sustain = Gen.GenAmount.shAmount;
417 CheckRange(
"sustainModEnv", 0, 1000, EG2Sustain);
419 case RELEASE_MOD_ENV:
420 EG2Release = Gen.GenAmount.shAmount;
421 CheckRange(
"releaseModEnv", -12000, 8000, EG2Release);
423 case KEYNUM_TO_MOD_ENV_HOLD:
425 case KEYNUM_TO_MOD_ENV_DECAY:
428 EG1PreAttackDelay = Gen.GenAmount.shAmount;
429 CheckRange(
"delayVolEnv", -12000, 5000, EG1PreAttackDelay);
432 EG1Attack = Gen.GenAmount.shAmount;
433 CheckRange(
"attackVolEnv", -12000, 8000, EG1Attack);
436 EG1Hold = Gen.GenAmount.shAmount;
437 CheckRange(
"holdVolEnv", -12000, 5000, EG1Hold);
440 EG1Decay = Gen.GenAmount.shAmount;
441 CheckRange(
"decayVolEnv", -12000, 8000, EG1Decay);
443 case SUSTAIN_VOL_ENV:
444 EG1Sustain = Gen.GenAmount.shAmount;
445 CheckRange(
"sustainVolEnv", 0, 1440, EG1Sustain);
447 case RELEASE_VOL_ENV:
448 EG1Release = Gen.GenAmount.shAmount;
449 CheckRange(
"releaseVolEnv", -12000, 8000, EG1Release);
451 case KEYNUM_TO_VOL_ENV_HOLD:
453 case KEYNUM_TO_VOL_ENV_DECAY:
456 uint16_t
id = Gen.GenAmount.wAmount;
457 if (
id >= pFile->Instruments.size()) {
458 throw Exception(
"Broken SF2 file (missing instruments)");
460 pInstrument = pFile->Instruments[id];
464 loKey = Gen.GenAmount.ranges.byLo;
465 CheckRange(
"loKey", 0, 127, loKey);
466 hiKey = Gen.GenAmount.ranges.byHi;
467 CheckRange(
"hiKey", 0, 127, hiKey);
470 minVel = Gen.GenAmount.ranges.byLo;
471 CheckRange(
"minVel", 0, 127, minVel);
472 maxVel = Gen.GenAmount.ranges.byHi;
473 CheckRange(
"maxVel", 0, 127, maxVel);
475 case STARTLOOP_ADDRS_COARSE_OFFSET:
476 startloopAddrsCoarseOffset = Gen.GenAmount.wAmount;
477 LoopStart += startloopAddrsCoarseOffset * 32768;
483 case INITIAL_ATTENUATION:
485 case ENDLOOP_ADDRS_COARSE_OFFSET:
486 endloopAddrsCoarseOffset = Gen.GenAmount.wAmount;
487 LoopEnd += endloopAddrsCoarseOffset * 32768;
490 coarseTune = Gen.GenAmount.shAmount;
491 CheckRange(
"coarseTune", -120, 120, coarseTune);
494 fineTune = Gen.GenAmount.shAmount;
495 CheckRange(
"fineTune", -99, 99, fineTune);
498 uint16_t sid = Gen.GenAmount.wAmount;
499 if (sid >= pFile->Samples.size()) {
500 throw Exception(
"Broken SF2 file (missing samples)");
502 pSample = pFile->Samples[sid];
505 LoopStart += pSample->StartLoop;
506 LoopEnd += pSample->EndLoop;
507 if ( LoopStart < pSample->Start || LoopStart > pSample->End ||
508 LoopStart > LoopEnd || LoopEnd > pSample->End ) {
509 throw Exception(
"Broken SF2 file (invalid loops)");
511 LoopStart -= pSample->Start;
512 LoopEnd -= pSample->Start;
517 HasLoop = Gen.GenAmount.wAmount & 1;
523 case EXCLUSIVE_CLASS:
524 exclusiveClass = Gen.GenAmount.wAmount;
526 case OVERRIDING_ROOT_KEY:
527 overridingRootKey = Gen.GenAmount.shAmount;
528 CheckRange(
"overridingRootKey", -1, 127, overridingRootKey);
533 void Region::SetModulator(sf2::File* pFile, ModList& Mod) {
534 modulators.push_back(ModulatorItem(Mod));
556 int Region::GetPan(Region* pPresetRegion) {
557 if (pPresetRegion == NULL)
return pan;
558 int p = pPresetRegion->pan + pan;
559 if (p < -64) p = -64;
564 int Region::GetFineTune(Region* pPresetRegion) {
565 if (pPresetRegion == NULL)
return fineTune;
566 int t = pPresetRegion->fineTune + fineTune;
567 if (t < -99) t = -99;
572 int Region::GetCoarseTune(Region* pPresetRegion) {
573 if (pPresetRegion == NULL)
return coarseTune;
574 int t = pPresetRegion->coarseTune + coarseTune;
575 if (t < -120) t = -120;
576 if (t > 120) t = 120;
580 double Region::GetEG1PreAttackDelay(Region* pPresetRegion) {
581 int val = (pPresetRegion == NULL || pPresetRegion->EG1PreAttackDelay == NONE) ?
582 EG1PreAttackDelay : pPresetRegion->EG1PreAttackDelay + EG1PreAttackDelay;
583 return ToSeconds(CheckRange(
"GetEG1PreAttackDelay()", -12000, 5000, val));
586 double Region::GetEG1Attack(Region* pPresetRegion) {
587 int val = (pPresetRegion == NULL || pPresetRegion->EG1Attack == NONE) ?
588 EG1Attack : pPresetRegion->EG1Attack + EG1Attack;
589 return ToSeconds(CheckRange(
"GetEG1Attack()", -12000, 8000, val));
592 double Region::GetEG1Hold(Region* pPresetRegion) {
593 int val = (pPresetRegion == NULL || pPresetRegion->EG1Hold == NONE) ?
594 EG1Hold : pPresetRegion->EG1Hold + EG1Hold;
595 return ToSeconds(CheckRange(
"GetEG1Hold()", -12000, 5000, val));
598 double Region::GetEG1Decay(Region* pPresetRegion) {
599 int val = (pPresetRegion == NULL || pPresetRegion->EG1Decay == NONE) ?
600 EG1Decay : pPresetRegion->EG1Decay + EG1Decay;
601 return ToSeconds(CheckRange(
"GetEG1Decay()", -12000, 8000, val));
604 int Region::GetEG1Sustain(Region* pPresetRegion) {
605 int val = (pPresetRegion == NULL || pPresetRegion->EG1Sustain == NONE) ?
606 EG1Sustain : pPresetRegion->EG1Sustain + EG1Sustain;
607 return CheckRange(
"GetEG1Sustain()", 0, 1440, val);
610 double Region::GetEG1Release(Region* pPresetRegion) {
611 int val = (pPresetRegion == NULL || pPresetRegion->EG1Release == NONE) ?
612 EG1Release : pPresetRegion->EG1Release + EG1Release;
613 return ToSeconds(CheckRange(
"GetEG1Release()", -12000, 8000, val));
616 double Region::GetEG2PreAttackDelay(Region* pPresetRegion) {
617 int val = (pPresetRegion == NULL || pPresetRegion->EG2PreAttackDelay == NONE) ?
618 EG2PreAttackDelay : pPresetRegion->EG2PreAttackDelay + EG2PreAttackDelay;
619 return ToSeconds(CheckRange(
"GetEG2PreAttackDelay()", -12000, 5000, val));
622 double Region::GetEG2Attack(Region* pPresetRegion) {
623 int val = (pPresetRegion == NULL || pPresetRegion->EG2Attack == NONE) ?
624 EG2Attack : pPresetRegion->EG2Attack + EG2Attack;
625 return ToSeconds(CheckRange(
"GetEG2Attack()", -12000, 8000, val));
628 double Region::GetEG2Hold(Region* pPresetRegion) {
629 int val = (pPresetRegion == NULL || pPresetRegion->EG2Hold == NONE) ?
630 EG2Hold : pPresetRegion->EG2Hold + EG2Hold;
631 return ToSeconds(CheckRange(
"GetEG2Hold()", -12000, 5000, val));
634 double Region::GetEG2Decay(Region* pPresetRegion) {
635 int val = (pPresetRegion == NULL || pPresetRegion->EG2Decay == NONE) ?
636 EG2Decay : pPresetRegion->EG2Decay + EG2Decay;
637 return ToSeconds(CheckRange(
"GetEG2Decay()", -12000, 8000, val));
640 int Region::GetEG2Sustain(Region* pPresetRegion) {
641 int val = (pPresetRegion == NULL || pPresetRegion->EG2Sustain == NONE) ?
642 EG2Sustain : pPresetRegion->EG2Sustain + EG2Sustain;
643 return CheckRange(
"GetEG2Sustain()", 0, 1000, val);
646 double Region::GetEG2Release(Region* pPresetRegion) {
647 int val = (pPresetRegion == NULL || pPresetRegion->EG2Release == NONE) ?
648 EG2Release : pPresetRegion->EG2Release + EG2Release;
649 return ToSeconds(CheckRange(
"GetEG2Release()", -12000, 8000, val));
652 int Region::GetModEnvToPitch(Region* pPresetRegion) {
653 int val = (pPresetRegion == NULL || pPresetRegion->modEnvToPitch == NONE) ?
654 modEnvToPitch : pPresetRegion->modEnvToPitch + modEnvToPitch;
655 return CheckRange(
"GetModEnvToPitch()", -12000, 12000, val);
658 int Region::GetModLfoToPitch(Region* pPresetRegion) {
659 int val = (pPresetRegion == NULL || pPresetRegion->modLfoToPitch == NONE) ?
660 modLfoToPitch : pPresetRegion->modLfoToPitch + modLfoToPitch;
661 return CheckRange(
"GetModLfoToPitch()", -12000, 12000, val);
664 int Region::GetModEnvToFilterFc(Region* pPresetRegion) {
665 int val = (pPresetRegion == NULL || pPresetRegion->modEnvToFilterFc == NONE) ?
666 modEnvToFilterFc : pPresetRegion->modEnvToFilterFc + modEnvToFilterFc;
667 return CheckRange(
"GetModEnvToFilterFc()", -12000, +12000, val);
670 int Region::GetModLfoToFilterFc(Region* pPresetRegion) {
671 int val = (pPresetRegion == NULL || pPresetRegion->modLfoToFilterFc == NONE) ?
672 modLfoToFilterFc : pPresetRegion->modLfoToFilterFc + modLfoToFilterFc;
673 return CheckRange(
"GetModLfoToFilterFc()", -12000, +12000, val);
676 double Region::GetModLfoToVolume(Region* pPresetRegion) {
677 int val = (pPresetRegion == NULL || pPresetRegion->modLfoToVolume == NONE) ?
678 modLfoToVolume : pPresetRegion->modLfoToVolume + modLfoToVolume;
679 return CheckRange(
"GetModLfoToVolume()", -960, 960, val);
682 double Region::GetFreqModLfo(Region* pPresetRegion) {
683 int val = (pPresetRegion == NULL || pPresetRegion->freqModLfo == NONE) ?
684 freqModLfo : pPresetRegion->freqModLfo + freqModLfo;
685 return ToHz(CheckRange(
"GetFreqModLfo()", -16000, 4500, val));
688 double Region::GetDelayModLfo(Region* pPresetRegion) {
689 int val = (pPresetRegion == NULL || pPresetRegion->delayModLfo == NONE) ?
690 delayModLfo : pPresetRegion->delayModLfo + delayModLfo;
691 return ToSeconds(CheckRange(
"GetDelayModLfo()", -12000, 5000, val));
694 int Region::GetVibLfoToPitch(Region* pPresetRegion) {
695 int val = (pPresetRegion == NULL || pPresetRegion->vibLfoToPitch == NONE) ?
696 vibLfoToPitch : pPresetRegion->vibLfoToPitch + vibLfoToPitch;
697 return CheckRange(
"GetVibLfoToPitch()", -12000, 12000, val);
700 double Region::GetFreqVibLfo(Region* pPresetRegion) {
701 int val = (pPresetRegion == NULL || pPresetRegion->freqVibLfo == NONE) ?
702 freqVibLfo : pPresetRegion->freqVibLfo + freqVibLfo;
703 return ToHz(CheckRange(
"GetFreqVibLfo()", -16000, 4500, val));
706 double Region::GetDelayVibLfo(Region* pPresetRegion) {
707 int val = (pPresetRegion == NULL || pPresetRegion->delayVibLfo == NONE) ?
708 delayVibLfo : pPresetRegion->delayVibLfo + delayVibLfo;
709 return ToSeconds(CheckRange(
"GetDelayVibLfo()", -12000, 5000, val));
712 int Region::GetInitialFilterFc(Region* pPresetRegion) {
713 if (pPresetRegion == NULL || pPresetRegion->initialFilterFc == NONE)
return initialFilterFc;
714 int val = pPresetRegion->initialFilterFc + initialFilterFc;
715 return CheckRange(
"GetInitialFilterFc()", 1500, 13500, val);
718 int Region::GetInitialFilterQ(Region* pPresetRegion) {
719 int val = (pPresetRegion == NULL || pPresetRegion->initialFilterQ == NONE) ?
720 initialFilterQ : pPresetRegion->initialFilterQ + initialFilterQ;
721 return CheckRange(
"GetInitialFilterQ()", 0, 960, val);
724 InstrumentBase::InstrumentBase(sf2::File* pFile) {
726 pGlobalRegion = NULL;
729 InstrumentBase::~InstrumentBase() {
730 if (pGlobalRegion)
delete pGlobalRegion;
731 for (ssize_t i = regions.size() - 1; i >= 0; i--) {
732 if (regions[i])
delete (regions[i]);
736 int InstrumentBase::GetRegionCount() {
737 return (
int) regions.size();
740 Region* InstrumentBase::GetRegion(
int idx) {
741 if (idx < 0 || idx >= GetRegionCount()) {
742 throw Exception(
"Region index out of bounds");
748 Query::Query(InstrumentBase& instrument) : instrument(instrument) {
752 Region* Query::next() {
753 while (i < instrument.GetRegionCount()) {
754 Region* r = instrument.GetRegion(i++);
755 if (((r->loKey == NONE && r->hiKey == NONE) || (key >= r->loKey && key <= r->hiKey)) &&
756 ((r->minVel == NONE && r->maxVel == NONE) || (vel >= r->minVel && vel <= r->maxVel))) {
763 Instrument::Instrument(sf2::File* pFile,
RIFF::Chunk* ck) : InstrumentBase(pFile) {
765 LoadString(ck, Name, 20);
769 Instrument::~Instrument() {
772 Region* Instrument::CreateRegion() {
773 Region* r =
new Region;
774 r->pParentInstrument =
this;
776 if (pGlobalRegion != NULL) {
777 r->loKey = pGlobalRegion->loKey;
778 r->hiKey = pGlobalRegion->hiKey;
779 r->minVel = pGlobalRegion->minVel;
780 r->maxVel = pGlobalRegion->maxVel;
781 r->pan = pGlobalRegion->pan;
782 r->fineTune = pGlobalRegion->fineTune;
783 r->coarseTune = pGlobalRegion->coarseTune;
784 r->overridingRootKey = pGlobalRegion->overridingRootKey;
785 r->startAddrsOffset = pGlobalRegion->startAddrsOffset;
786 r->startAddrsCoarseOffset = pGlobalRegion->startAddrsCoarseOffset;
787 r->endAddrsOffset = pGlobalRegion->endAddrsOffset;
788 r->endAddrsCoarseOffset = pGlobalRegion->endAddrsCoarseOffset;
789 r->startloopAddrsOffset = pGlobalRegion->startloopAddrsOffset;
790 r->startloopAddrsCoarseOffset = pGlobalRegion->startloopAddrsCoarseOffset;
791 r->endloopAddrsOffset = pGlobalRegion->endloopAddrsOffset;
792 r->endloopAddrsCoarseOffset = pGlobalRegion->endloopAddrsCoarseOffset;
794 r->EG1PreAttackDelay = pGlobalRegion->EG1PreAttackDelay;
795 r->EG1Attack = pGlobalRegion->EG1Attack;
796 r->EG1Hold = pGlobalRegion->EG1Hold;
797 r->EG1Decay = pGlobalRegion->EG1Decay;
798 r->EG1Sustain = pGlobalRegion->EG1Sustain;
799 r->EG1Release = pGlobalRegion->EG1Release;
801 r->EG2PreAttackDelay = pGlobalRegion->EG2PreAttackDelay;
802 r->EG2Attack = pGlobalRegion->EG2Attack;
803 r->EG2Hold = pGlobalRegion->EG2Hold;
804 r->EG2Decay = pGlobalRegion->EG2Decay;
805 r->EG2Sustain = pGlobalRegion->EG2Sustain;
806 r->EG2Release = pGlobalRegion->EG2Release;
808 r->modEnvToPitch = pGlobalRegion->modEnvToPitch;
809 r->modLfoToPitch = pGlobalRegion->modLfoToPitch;
810 r->modEnvToFilterFc = pGlobalRegion->modEnvToFilterFc;
811 r->modLfoToFilterFc = pGlobalRegion->modLfoToFilterFc;
812 r->modLfoToVolume = pGlobalRegion->modLfoToVolume;
813 r->freqModLfo = pGlobalRegion->freqModLfo;
814 r->delayModLfo = pGlobalRegion->delayModLfo;
815 r->vibLfoToPitch = pGlobalRegion->vibLfoToPitch;
816 r->freqVibLfo = pGlobalRegion->freqVibLfo;
817 r->delayVibLfo = pGlobalRegion->delayVibLfo;
818 r->initialFilterFc = pGlobalRegion->initialFilterFc;
819 r->initialFilterQ = pGlobalRegion->initialFilterQ;
821 r->HasLoop = pGlobalRegion->HasLoop;
822 r->LoopStart = pGlobalRegion->LoopStart;
823 r->LoopEnd = pGlobalRegion->LoopEnd;
825 r->exclusiveClass = pGlobalRegion->exclusiveClass;
831 void Instrument::DeleteRegion(Region* pRegion) {
832 for (
int i = 0; i < regions.size(); i++) {
833 if (regions[i] == pRegion) {
840 std::cerr <<
"Can't remove unknown Region" << std::endl;
843 void Instrument::LoadRegions(
int idx1,
int idx2) {
844 for (
int i = idx1; i < idx2; i++) {
845 int gIdx1 = pFile->InstBags[i].InstGenNdx;
846 int gIdx2 = pFile->InstBags[i + 1].InstGenNdx;
848 if (gIdx1 < 0 || gIdx2 < 0 || gIdx1 > gIdx2 || gIdx2 >= pFile->InstGenLists.size()) {
849 throw Exception(
"Broken SF2 file (invalid InstGenNdx)");
852 int mIdx1 = pFile->InstBags[i].InstModNdx;
853 int mIdx2 = pFile->InstBags[i + 1].InstModNdx;
855 if (mIdx1 < 0 || mIdx2 < 0 || mIdx1 > mIdx2 || mIdx2 >= pFile->InstModLists.size()) {
856 throw Exception(
"Broken SF2 file (invalid InstModNdx)");
859 Region* reg = CreateRegion();
861 for (
int j = gIdx1; j < gIdx2; j++) {
862 reg->SetGenerator(pFile, pFile->InstGenLists[j]);
866 for (
int j = mIdx1; j < mIdx2; j++) {
867 reg->SetModulator(pFile, pFile->InstModLists[j]);
870 if (reg->pSample == NULL) {
871 if (i == idx1 && idx2 - idx1 > 1) {
874 std::cerr <<
"Ignoring instrument's region without sample" << std::endl;
878 regions.push_back(reg);
883 Preset::Preset(sf2::File* pFile,
RIFF::Chunk* ck): InstrumentBase(pFile) {
885 LoadString(ck, Name, 20);
897 Region* Preset::CreateRegion() {
898 Region* r =
new Region;
900 r->EG1PreAttackDelay = r->EG1Attack = r->EG1Hold = r->EG1Decay = r->EG1Sustain = r->EG1Release = NONE;
901 r->EG2PreAttackDelay = r->EG2Attack = r->EG2Hold = r->EG2Decay = r->EG2Sustain = r->EG2Release = NONE;
902 r->freqModLfo = r->delayModLfo = r->freqVibLfo = r->delayVibLfo = NONE;
903 r->initialFilterFc = r->initialFilterQ = NONE;
905 if (pGlobalRegion != NULL) {
906 r->pan = pGlobalRegion->pan;
907 r->fineTune = pGlobalRegion->fineTune;
908 r->coarseTune = pGlobalRegion->coarseTune;
910 r->EG1PreAttackDelay = pGlobalRegion->EG1PreAttackDelay;
911 r->EG1Attack = pGlobalRegion->EG1Attack;
912 r->EG1Hold = pGlobalRegion->EG1Hold;
913 r->EG1Decay = pGlobalRegion->EG1Decay;
914 r->EG1Sustain = pGlobalRegion->EG1Sustain;
915 r->EG1Release = pGlobalRegion->EG1Release;
917 r->EG2PreAttackDelay = pGlobalRegion->EG2PreAttackDelay;
918 r->EG2Attack = pGlobalRegion->EG2Attack;
919 r->EG2Hold = pGlobalRegion->EG2Hold;
920 r->EG2Decay = pGlobalRegion->EG2Decay;
921 r->EG2Sustain = pGlobalRegion->EG2Sustain;
922 r->EG2Release = pGlobalRegion->EG2Release;
924 r->modEnvToPitch = pGlobalRegion->modEnvToPitch;
925 r->modLfoToPitch = pGlobalRegion->modLfoToPitch;
926 r->modEnvToFilterFc = pGlobalRegion->modEnvToFilterFc;
927 r->modLfoToFilterFc = pGlobalRegion->modLfoToFilterFc;
928 r->modLfoToVolume = pGlobalRegion->modLfoToVolume;
929 r->freqModLfo = pGlobalRegion->freqModLfo;
930 r->delayModLfo = pGlobalRegion->delayModLfo;
931 r->vibLfoToPitch = pGlobalRegion->vibLfoToPitch;
932 r->freqVibLfo = pGlobalRegion->freqVibLfo;
933 r->delayVibLfo = pGlobalRegion->delayVibLfo;
934 r->initialFilterFc = pGlobalRegion->initialFilterFc;
935 r->initialFilterQ = pGlobalRegion->initialFilterQ;
941 void Preset::LoadRegions(
int idx1,
int idx2) {
942 for (
int i = idx1; i < idx2; i++) {
943 int gIdx1 = pFile->PresetBags[i].GenNdx;
944 int gIdx2 = pFile->PresetBags[i + 1].GenNdx;
946 if (gIdx1 < 0 || gIdx2 < 0 || gIdx1 > gIdx2 || gIdx2 >= pFile->PresetGenLists.size()) {
947 throw Exception(
"Broken SF2 file (invalid PresetGenNdx)");
950 Region* reg = CreateRegion();
952 for (
int j = gIdx1; j < gIdx2; j++) {
953 reg->SetGenerator(pFile, pFile->PresetGenLists[j]);
955 if (reg->pInstrument == NULL) {
956 if (i == idx1 && idx2 - idx1 > 1) {
959 std::cerr <<
"Ignoring preset's region without instrument" << std::endl;
963 regions.push_back(reg);
978 if (!pRIFF)
throw Exception(
"NULL pointer reference to RIFF::File object.");
982 throw Exception(
"Not a SF2 file");
985 pInfo =
new Info(pRIFF);
986 if (pInfo->pVer->Major != 2) {
987 throw Exception(
"Unsupported version: " + ToString(pInfo->pVer->Major));
991 if (lstSDTA == NULL) {
992 throw Exception(
"Broken SF2 file (missing sdta)");
997 if (pCkSmpl != NULL && pCkSm24 != NULL) {
998 long l = pCkSmpl->
GetSize() / 2;
1000 if (pCkSm24->
GetSize() != l) {
1006 if (lstPDTA == NULL) {
1007 throw Exception(
"Broken SF2 file (missing pdta)");
1012 throw Exception(
"Broken SF2 file (broken phdr)");
1015 int count = (int) ck->
GetSize() / 38;
1016 for (
int i = 0; i < count; i++) {
1017 Presets.push_back(
new Preset(
this, ck));
1020 ck = GetMandatoryChunk(lstPDTA, CHUNK_ID_PBAG);
1022 throw Exception(
"Broken SF2 file (broken pbag)");
1025 count = int(ck->
GetSize() / 4);
1026 for (
int i = 0; i < count; i++) {
1030 PresetBags.push_back(pb);
1034 ck = GetMandatoryChunk(lstPDTA, CHUNK_ID_PMOD);
1036 throw Exception(
"Broken SF2 file (broken pmod)");
1039 count = int(ck->
GetSize() / 10);
1040 for (
int i = 0; i < count; i++) {
1047 PresetModLists.push_back(ml);
1051 ck = GetMandatoryChunk(lstPDTA, CHUNK_ID_PGEN);
1053 throw Exception(
"Broken SF2 file (broken pgen)");
1056 count = int(ck->
GetSize() / 4);
1057 for (
int i = 0; i < count; i++) {
1061 PresetGenLists.push_back(gl);
1065 ck = GetMandatoryChunk(lstPDTA, CHUNK_ID_INST);
1067 throw Exception(
"Broken SF2 file (broken inst)");
1069 count = int(ck->
GetSize() / 22);
1070 for (
int i = 0; i < count; i++) {
1071 Instruments.push_back(
new Instrument(
this, ck));
1074 ck = GetMandatoryChunk(lstPDTA, CHUNK_ID_IBAG);
1076 throw Exception(
"Broken SF2 file (broken ibag)");
1079 count = int(ck->
GetSize() / 4);
1080 for (
int i = 0; i < count; i++) {
1084 InstBags.push_back(ib);
1088 ck = GetMandatoryChunk(lstPDTA, CHUNK_ID_IMOD);
1090 throw Exception(
"Broken SF2 file (broken imod)");
1093 count = int(ck->
GetSize() / 10);
1094 for (
int i = 0; i < count; i++) {
1101 InstModLists.push_back(ml);
1105 ck = GetMandatoryChunk(lstPDTA, CHUNK_ID_IGEN);
1107 throw Exception(
"Broken SF2 file (broken igen)");
1110 count = int(ck->
GetSize() / 4);
1111 for (
int i = 0; i < count; i++) {
1115 InstGenLists.push_back(gl);
1119 ck = GetMandatoryChunk(lstPDTA, CHUNK_ID_SHDR);
1121 throw Exception(
"Broken SF2 file (broken shdr)");
1123 count = int(ck->
GetSize() / 46);
1124 for (
int i = 0; i < count; i++) {
1125 Samples.push_back(
new Sample(ck, pCkSmpl, pCkSm24));
1129 for (
int i = 0; i < Instruments.size() - 1; i++) {
1130 Instrument* instr = Instruments[i];
1131 int x1 = instr->InstBagNdx;
1132 int x2 = Instruments[i + 1]->InstBagNdx;
1133 if (x1 < 0 || x2 < 0 || x1 > x2 || x2 >= InstBags.size()) {
1134 throw Exception(
"Broken SF2 file (invalid InstBagNdx)");
1137 instr->LoadRegions(x1, x2);
1141 for (
int i = 0; i < Presets.size() - 1; i++) {
1142 Preset* preset = Presets[i];
1143 int x1 = preset->PresetBagNdx;
1144 int x2 = Presets[i + 1]->PresetBagNdx;
1145 if (x1 < 0 || x2 < 0 || x1 > x2 || x2 >= PresetBags.size()) {
1146 throw Exception(
"Broken SF2 file (invalid PresetBagNdx)");
1149 preset->LoadRegions(x1, x2);
1155 for (ssize_t i = Presets.size() - 1; i >= 0; i--) {
1156 if (Presets[i])
delete (Presets[i]);
1158 for (ssize_t i = Instruments.size() - 1; i >= 0; i--) {
1159 if (Instruments[i])
delete (Instruments[i]);
1161 for (ssize_t i = Samples.size() - 1; i >= 0; i--) {
1162 if (Samples[i])
delete (Samples[i]);
1166 int File::GetPresetCount() {
1167 return (
int) Presets.size() - 1;
1170 Preset* File::GetPreset(
int idx) {
1171 if (idx < 0 || idx >= GetPresetCount()) {
1172 throw Exception(
"Preset index out of bounds");
1175 return Presets[idx];
1178 int File::GetInstrumentCount() {
1179 return (
int) Instruments.size() - 1;
1182 Instrument* File::GetInstrument(
int idx) {
1183 if (idx < 0 || idx >= GetInstrumentCount()) {
1184 throw Exception(
"Instrument index out of bounds");
1187 return Instruments[idx];
1190 void File::DeleteInstrument(Instrument* pInstrument) {
1191 for (
int i = 0; i < GetPresetCount(); i++) {
1192 Preset* p = GetPreset(i);
1193 if (p == NULL)
continue;
1194 for (
int j = p->GetRegionCount() - 1; j >= 0 ; j--) {
1195 if (p->GetRegion(j) && p->GetRegion(j)->pInstrument == pInstrument) {
1196 p->GetRegion(j)->pInstrument = NULL;
1201 for (
int i = 0; i < GetInstrumentCount(); i++) {
1202 if (GetInstrument(i) == pInstrument) {
1203 Instruments[i] = NULL;
1209 int File::GetSampleCount() {
1210 return (
int) Samples.size() - 1;
1213 Sample* File::GetSample(
int idx) {
1214 if (idx < 0 || idx >= GetSampleCount()) {
1215 throw Exception(
"Sample index out of bounds");
1218 return Samples[idx];
1221 void File::DeleteSample(Sample* pSample) {
1223 for (
int i = GetInstrumentCount() - 1; i >= 0; i--) {
1224 Instrument* pInstr = GetInstrument(i);
1225 if (pInstr == NULL)
continue;
1227 for (
int j = pInstr->GetRegionCount() - 1; j >= 0 ; j--) {
1228 if (pInstr->GetRegion(j) && pInstr->GetRegion(j)->GetSample() == pSample) {
1229 std::cerr <<
"Deleting sample which is still in use" << std::endl;
1235 for (
int i = 0; i < GetSampleCount(); i++) {
1236 if (Samples[i] == pSample) {
1243 throw Exception(
"Unknown sample: " + pSample->Name);
1246 bool File::HasSamples() {
1247 for (
int i = 0; i < GetSampleCount(); i++) {
1248 if (Samples[i] != NULL)
return true;
1263 Sample::buffer_t Sample::LoadSampleData() {
1264 return LoadSampleDataWithNullSamplesExtension(GetTotalFrameCount(), 0);
1285 Sample::buffer_t Sample::LoadSampleData(
unsigned long SampleCount) {
1286 return LoadSampleDataWithNullSamplesExtension(SampleCount, 0);
1308 Sample::buffer_t Sample::LoadSampleDataWithNullSamplesExtension(uint NullSamplesCount) {
1309 return LoadSampleDataWithNullSamplesExtension(GetTotalFrameCount(), NullSamplesCount);
1340 Sample::buffer_t Sample::LoadSampleDataWithNullSamplesExtension(
unsigned long SampleCount, uint NullSamplesCount) {
1341 if (SampleCount > GetTotalFrameCount()) SampleCount = GetTotalFrameCount();
1342 if (RAMCache.pStart)
delete[] (int8_t*) RAMCache.pStart;
1343 unsigned long allocationsize = (SampleCount + NullSamplesCount) * GetFrameSize();
1345 RAMCache.pStart =
new int8_t[allocationsize];
1346 RAMCache.Size = Read(RAMCache.pStart, SampleCount) * GetFrameSize();
1347 RAMCache.NullExtensionSize = allocationsize - RAMCache.Size;
1349 memset((int8_t*)RAMCache.pStart + RAMCache.Size, 0, RAMCache.NullExtensionSize);
1363 Sample::buffer_t Sample::GetCache() {
1366 result.
Size = this->RAMCache.Size;
1367 result.pStart = this->RAMCache.pStart;
1368 result.NullExtensionSize = this->RAMCache.NullExtensionSize;
1378 void Sample::ReleaseSampleData() {
1379 if (RAMCache.pStart)
delete[] (int8_t*) RAMCache.pStart;
1380 RAMCache.pStart = NULL;
1382 RAMCache.NullExtensionSize = 0;
1394 unsigned long Sample::SetPos(
unsigned long SampleCount) {
1395 pCkSmpl->
SetPos((Start * 2) + (SampleCount * 2), RIFF::stream_start);
1396 if(pCkSm24) pCkSm24->
SetPos(Start + SampleCount, RIFF::stream_start);
1403 unsigned long Sample::GetPos() {
1404 return (pCkSmpl->
GetPos() - (Start * 2)) / 2;
1408 template<
bool CLEAR>
1409 inline unsigned long ReadSample(Sample* pSample,
void* pBuffer,
unsigned long SampleCount, Sample::buffer_t* tempBuffer = NULL) {
1411 if (SampleCount == 0)
return 0;
1412 long pos = pSample->GetPos();
1413 if (pos + SampleCount > pSample->GetTotalFrameCount())
1414 SampleCount = pSample->GetTotalFrameCount() - pos;
1416 if (tempBuffer->Size < SampleCount * pSample->GetFrameSize()) {
1417 std::cerr <<
"sf2::Sample error: tempBuffer too small. This is a BUG!" << std::endl;
1422 if (pSample->GetFrameSize() / pSample->GetChannelCount() == 3 ) {
1423 uint8_t*
const pTmpBuf = (uint8_t*) ((CLEAR) ? pBuffer : tempBuffer->pStart);
1424 uint8_t*
const pBuf = (uint8_t*)pBuffer;
1425 if (pSample->SampleType == Sample::MONO_SAMPLE || pSample->SampleType == Sample::ROM_MONO_SAMPLE) {
1426 pSample->pCkSmpl->Read(pTmpBuf, SampleCount, 2);
1427 pSample->pCkSm24->Read(pTmpBuf + SampleCount * 2, SampleCount, 1);
1428 for (
long i = SampleCount - 1; i >= 0; i--) {
1429 pBuf[i*3] = pTmpBuf[(SampleCount * 2) + i];
1430 pBuf[i*3 + 2] = pTmpBuf[i*2 + 1];
1431 pBuf[i*3 + 1] = pTmpBuf[i*2];
1433 }
else if (pSample->SampleType == Sample::LEFT_SAMPLE || pSample->SampleType == Sample::ROM_LEFT_SAMPLE) {
1434 pSample->pCkSmpl->Read(pTmpBuf, SampleCount, 2);
1435 pSample->pCkSm24->Read(pTmpBuf + SampleCount * 2, SampleCount, 1);
1436 for (
long i = SampleCount - 1; i >= 0; i--) {
1437 pBuf[i*6] = pTmpBuf[(SampleCount * 2) + i];
1438 pBuf[i*6 + 2] = pTmpBuf[i*2 + 1];
1439 pBuf[i*6 + 1] = pTmpBuf[i*2];
1441 pBuf[i*6 + 3] = pBuf[i*6 + 4] = pBuf[i*6 + 5] = 0;
1443 }
else if (pSample->SampleType == Sample::RIGHT_SAMPLE || pSample->SampleType == Sample::ROM_RIGHT_SAMPLE) {
1444 pSample->pCkSmpl->Read(pTmpBuf, SampleCount, 2);
1445 pSample->pCkSm24->Read(pTmpBuf + SampleCount * 2, SampleCount, 1);
1446 for (
long i = SampleCount - 1; i >= 0; i--) {
1447 pBuf[i*6 + 3] = pTmpBuf[(SampleCount * 2) + i];
1448 pBuf[i*6 + 5] = pTmpBuf[i*2 + 1];
1449 pBuf[i*6 + 4] = pTmpBuf[i*2];
1451 pBuf[i*6] = pBuf[i*6 + 1] = pBuf[i*6 + 2] = 0;
1455 if (pSample->SampleType == Sample::MONO_SAMPLE || pSample->SampleType == Sample::ROM_MONO_SAMPLE) {
1456 return pSample->pCkSmpl->Read(pBuffer, SampleCount, 2);
1459 int16_t*
const pTmpBuf = (int16_t*) ((CLEAR) ? pBuffer : tempBuffer->pStart);
1460 int16_t*
const pBuf = (int16_t*) pBuffer;
1461 if (pSample->SampleType == Sample::LEFT_SAMPLE || pSample->SampleType == Sample::ROM_LEFT_SAMPLE) {
1462 pSample->pCkSmpl->Read(pTmpBuf, SampleCount, 2);
1463 for (
long i = SampleCount - 1; i >= 0; i--) {
1464 pBuf[i*2] = pTmpBuf[i];
1468 }
else if (pSample->SampleType == Sample::RIGHT_SAMPLE || pSample->SampleType == Sample::ROM_RIGHT_SAMPLE) {
1469 pSample->pCkSmpl->Read(pTmpBuf, SampleCount, 2);
1470 for (
long i = SampleCount - 1; i >= 0; i--) {
1473 pBuf[i*2 + 1] = pTmpBuf[i];
1478 if (pSample->pCkSmpl->GetPos() > (pSample->End * 2)) {
1479 std::cerr <<
"Read after the sample end. This is a BUG!" << std::endl;
1480 std::cerr <<
"Current position: " << pSample->GetPos() << std::endl;
1481 std::cerr <<
"Total number of frames: " << pSample->GetTotalFrameCount() << std::endl << std::endl;
1509 unsigned long Sample::Read(
void* pBuffer,
unsigned long SampleCount) {
1510 return ReadSample<true>(
this, pBuffer, SampleCount);
1543 unsigned long Sample::ReadNoClear(
void* pBuffer,
unsigned long SampleCount, buffer_t& tempBuffer) {
1544 return ReadSample<false>(
this, pBuffer, SampleCount, &tempBuffer);
1554 String libraryName() {
1561 String libraryVersion() {
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 GetSize() const
Chunk size in bytes (without header, thus the chunk data body)
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 Size
Size of the actual data in the buffer in bytes.
uint32_t Version
Version number data type.
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).
List * GetSubList(uint32_t ListType)
Returns sublist chunk with list type ListType within this chunk list.
SoundFont specific classes and definitions.
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).
Chunk * GetSubChunk(uint32_t ChunkID)
Returns subchunk with chunk ID ChunkID within this chunk list.
uint32_t GetChunkID() const
Chunk ID in unsigned integer representation.
uint32_t GetListType() const
Returns unsigned integer representation of the list's ID.
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 GetPos() const
Position within the chunk data body (starting with 0).
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.