27 #include "Serialization.h" 36 #define GIG_FILE_EXT_VERSION 2 43 #define INITIAL_SAMPLE_BUFFER_SIZE 512000 // 512 kB 46 #define GIG_EXP_DECODE(x) (pow(1.000000008813822, x)) 47 #define GIG_EXP_ENCODE(x) (log(x) / log(1.000000008813822)) 48 #define GIG_PITCH_TRACK_EXTRACT(x) (!(x & 0x01)) 49 #define GIG_PITCH_TRACK_ENCODE(x) ((x) ? 0x00 : 0x01) 50 #define GIG_VCF_RESONANCE_CTRL_EXTRACT(x) ((x >> 4) & 0x03) 51 #define GIG_VCF_RESONANCE_CTRL_ENCODE(x) ((x & 0x03) << 4) 52 #define GIG_EG_CTR_ATTACK_INFLUENCE_EXTRACT(x) ((x >> 1) & 0x03) 53 #define GIG_EG_CTR_DECAY_INFLUENCE_EXTRACT(x) ((x >> 3) & 0x03) 54 #define GIG_EG_CTR_RELEASE_INFLUENCE_EXTRACT(x) ((x >> 5) & 0x03) 55 #define GIG_EG_CTR_ATTACK_INFLUENCE_ENCODE(x) ((x & 0x03) << 1) 56 #define GIG_EG_CTR_DECAY_INFLUENCE_ENCODE(x) ((x & 0x03) << 3) 57 #define GIG_EG_CTR_RELEASE_INFLUENCE_ENCODE(x) ((x & 0x03) << 5) 59 #define SRLZ(member) \ 60 archive->serializeMember(*this, member, #member); 69 inline int get12lo(
const unsigned char* pSrc)
71 const int x = pSrc[0] | (pSrc[1] & 0x0f) << 8;
72 return x & 0x800 ? x - 0x1000 : x;
75 inline int get12hi(
const unsigned char* pSrc)
77 const int x = pSrc[1] >> 4 | pSrc[2] << 4;
78 return x & 0x800 ? x - 0x1000 : x;
81 inline int16_t get16(
const unsigned char* pSrc)
83 return int16_t(pSrc[0] | pSrc[1] << 8);
86 inline int get24(
const unsigned char* pSrc)
88 const int x = pSrc[0] | pSrc[1] << 8 | pSrc[2] << 16;
89 return x & 0x800000 ? x - 0x1000000 : x;
92 inline void store24(
unsigned char* pDst,
int x)
99 void Decompress16(
int compressionmode,
const unsigned char* params,
100 int srcStep,
int dstStep,
101 const unsigned char* pSrc, int16_t* pDst,
102 file_offset_t currentframeoffset,
103 file_offset_t copysamples)
105 switch (compressionmode) {
107 pSrc += currentframeoffset * srcStep;
108 while (copysamples) {
117 int y = get16(params);
118 int dy = get16(params + 2);
119 while (currentframeoffset) {
123 currentframeoffset--;
125 while (copysamples) {
137 void Decompress24(
int compressionmode,
const unsigned char* params,
138 int dstStep,
const unsigned char* pSrc, uint8_t* pDst,
139 file_offset_t currentframeoffset,
140 file_offset_t copysamples,
int truncatedBits)
142 int y, dy, ddy, dddy;
144 #define GET_PARAMS(params) \ 146 dy = y - get24((params) + 3); \ 147 ddy = get24((params) + 6); \ 148 dddy = get24((params) + 9) 150 #define SKIP_ONE(x) \ 156 #define COPY_ONE(x) \ 158 store24(pDst, y << truncatedBits); \ 161 switch (compressionmode) {
163 pSrc += currentframeoffset * 3;
164 while (copysamples) {
165 store24(pDst, get24(pSrc) << truncatedBits);
174 while (currentframeoffset) {
175 SKIP_ONE(get16(pSrc));
177 currentframeoffset--;
179 while (copysamples) {
180 COPY_ONE(get16(pSrc));
188 while (currentframeoffset > 1) {
189 SKIP_ONE(get12lo(pSrc));
190 SKIP_ONE(get12hi(pSrc));
192 currentframeoffset -= 2;
194 if (currentframeoffset) {
195 SKIP_ONE(get12lo(pSrc));
196 currentframeoffset--;
198 COPY_ONE(get12hi(pSrc));
203 while (copysamples > 1) {
204 COPY_ONE(get12lo(pSrc));
205 COPY_ONE(get12hi(pSrc));
210 COPY_ONE(get12lo(pSrc));
216 while (currentframeoffset) {
217 SKIP_ONE(int8_t(*pSrc++));
218 currentframeoffset--;
220 while (copysamples) {
221 COPY_ONE(int8_t(*pSrc++));
228 const int bytesPerFrame[] = { 4096, 2052, 768, 524, 396, 268 };
229 const int bytesPerFrameNoHdr[] = { 4096, 2048, 768, 512, 384, 256 };
230 const int headerSize[] = { 0, 4, 0, 12, 12, 12 };
231 const int bitsPerSample[] = { 16, 8, 24, 16, 12, 8 };
239 static uint32_t* __initCRCTable() {
240 static uint32_t res[256];
242 for (
int i = 0 ; i < 256 ; i++) {
244 for (
int j = 0 ; j < 8 ; j++) {
245 c = (c & 1) ? 0xedb88320 ^ (c >> 1) : c >> 1;
252 static const uint32_t* __CRCTable = __initCRCTable();
259 inline static void __resetCRC(uint32_t& crc) {
282 static void __calculateCRC(
unsigned char* buf,
size_t bufSize, uint32_t& crc) {
283 for (
size_t i = 0 ; i < bufSize ; i++) {
284 crc = __CRCTable[(crc ^ buf[i]) & 0xff] ^ (crc >> 8);
293 inline static void __finalizeCRC(uint32_t& crc) {
302 static split_type_t __resolveSplitType(dimension_t dimension) {
304 dimension == dimension_layer ||
305 dimension == dimension_samplechannel ||
306 dimension == dimension_releasetrigger ||
307 dimension == dimension_keyboard ||
308 dimension == dimension_roundrobin ||
309 dimension == dimension_random ||
310 dimension == dimension_smartmidi ||
311 dimension == dimension_roundrobinkeyboard
312 ) ? split_type_bit : split_type_normal;
315 static int __resolveZoneSize(dimension_def_t& dimension_definition) {
316 return (dimension_definition.split_type == split_type_normal)
317 ? int(128.0 / dimension_definition.zones) : 0;
327 SRLZ(controller_number);
347 eg_opt_t::eg_opt_t() {
349 AttackHoldCancel =
true;
352 ReleaseCancel =
true;
357 SRLZ(AttackHoldCancel);
368 size_t Sample::Instances = 0;
369 buffer_t Sample::InternalDecompressionBuffer;
390 Sample::Sample(File* pFile,
RIFF::List* waveList, file_offset_t WavePoolOffset,
unsigned long fileNo,
int index)
391 :
DLS::Sample((
DLS::File*) pFile, waveList, WavePoolOffset)
393 static const DLS::Info::string_length_t fixedStringLengths[] = {
394 { CHUNK_ID_INAM, 64 },
397 pInfo->SetFixedStringLengths(fixedStringLengths);
408 uint32_t crc = pFile->GetSampleChecksumByIndex(index);
415 uint16_t iSampleGroup = pCk3gix->
ReadInt16();
416 pGroup = pFile->GetGroup(iSampleGroup);
419 pGroup = pFile->GetGroup(0);
425 Product = pCkSmpl->ReadInt32();
426 SamplePeriod = pCkSmpl->ReadInt32();
427 MIDIUnityNote = pCkSmpl->ReadInt32();
428 FineTune = pCkSmpl->ReadInt32();
429 pCkSmpl->Read(&SMPTEFormat, 1, 4);
430 SMPTEOffset = pCkSmpl->ReadInt32();
431 Loops = pCkSmpl->ReadInt32();
432 pCkSmpl->ReadInt32();
433 LoopID = pCkSmpl->ReadInt32();
434 pCkSmpl->Read(&LoopType, 1, 4);
435 LoopStart = pCkSmpl->ReadInt32();
436 LoopEnd = pCkSmpl->ReadInt32();
437 LoopFraction = pCkSmpl->ReadInt32();
438 LoopPlayCount = pCkSmpl->ReadInt32();
443 SamplePeriod = uint32_t(1000000000.0 / SamplesPerSecond + 0.5);
446 SMPTEFormat = smpte_format_no_offset;
450 LoopType = loop_type_normal;
460 RAMCache.pStart = NULL;
461 RAMCache.NullExtensionSize = 0;
463 if (BitDepth > 24)
throw gig::Exception(
"Only samples up to 24 bit supported");
471 if (version > 2 && BitDepth == 24) {
473 ewav->
SetPos(Channels == 2 ? 84 : 64);
476 ScanCompressedSample();
480 if ((Compressed || BitDepth == 24) && !InternalDecompressionBuffer.Size) {
481 InternalDecompressionBuffer.pStart =
new unsigned char[INITIAL_SAMPLE_BUFFER_SIZE];
482 InternalDecompressionBuffer.Size = INITIAL_SAMPLE_BUFFER_SIZE;
486 LoopSize = LoopEnd - LoopStart + 1;
504 void Sample::CopyAssignMeta(
const Sample* orig) {
509 Manufacturer = orig->Manufacturer;
510 Product = orig->Product;
511 SamplePeriod = orig->SamplePeriod;
512 MIDIUnityNote = orig->MIDIUnityNote;
513 FineTune = orig->FineTune;
514 SMPTEFormat = orig->SMPTEFormat;
515 SMPTEOffset = orig->SMPTEOffset;
517 LoopID = orig->LoopID;
518 LoopType = orig->LoopType;
519 LoopStart = orig->LoopStart;
520 LoopEnd = orig->LoopEnd;
521 LoopSize = orig->LoopSize;
522 LoopFraction = orig->LoopFraction;
523 LoopPlayCount = orig->LoopPlayCount;
540 void Sample::CopyAssignWave(
const Sample* orig) {
541 const int iReadAtOnce = 32*1024;
542 char* buf =
new char[iReadAtOnce * orig->FrameSize];
547 for (file_offset_t n = pOrig->Read(buf, iReadAtOnce); n;
548 n = pOrig->Read(buf, iReadAtOnce))
552 pOrig->SetPos(restorePos);
575 pCkSmpl = pWaveList->
AddSubChunk(CHUNK_ID_SMPL, 60);
576 memset(pCkSmpl->LoadChunkData(), 0, 60);
581 store32(&pData[0], Manufacturer);
582 store32(&pData[4], Product);
583 store32(&pData[8], SamplePeriod);
584 store32(&pData[12], MIDIUnityNote);
585 store32(&pData[16], FineTune);
586 store32(&pData[20], SMPTEFormat);
587 store32(&pData[24], SMPTEOffset);
588 store32(&pData[28], Loops);
592 store32(&pData[36], LoopID);
593 store32(&pData[40], LoopType);
594 store32(&pData[44], LoopStart);
595 store32(&pData[48], LoopEnd);
596 store32(&pData[52], LoopFraction);
597 store32(&pData[56], LoopPlayCount);
601 if (!pCk3gix) pCk3gix = pWaveList->
AddSubChunk(CHUNK_ID_3GIX, 4);
603 uint16_t iSampleGroup = 0;
604 File* pFile =
static_cast<File*
>(pParent);
605 if (pFile->pGroups) {
606 std::list<Group*>::iterator iter = pFile->pGroups->begin();
607 std::list<Group*>::iterator end = pFile->pGroups->end();
608 for (
int i = 0; iter != end; i++, iter++) {
609 if (*iter == pGroup) {
617 store16(&pData[0], iSampleGroup);
623 if (ewav && !Compressed) {
629 void Sample::ScanCompressedSample() {
632 std::list<file_offset_t> frameOffsets;
634 SamplesPerFrame =
BitDepth == 24 ? 256 : 2048;
640 for (
int i = 0 ; ; i++) {
643 if (
BitDepth != 24 || (i & 7) == 0) frameOffsets.push_back(pCkData->
GetPos());
647 if (mode_l > 5 || mode_r > 5)
throw gig::Exception(
"Unknown compression mode");
648 const file_offset_t frameSize = bytesPerFrame[mode_l] + bytesPerFrame[mode_r];
652 ((pCkData->
RemainingBytes() - headerSize[mode_l] - headerSize[mode_r]) << 3) /
653 (bitsPerSample[mode_l] + bitsPerSample[mode_r]);
658 pCkData->
SetPos(frameSize, RIFF::stream_curpos);
662 for (
int i = 0 ; ; i++) {
663 if (
BitDepth != 24 || (i & 7) == 0) frameOffsets.push_back(pCkData->
GetPos());
666 if (mode > 5)
throw gig::Exception(
"Unknown compression mode");
671 ((pCkData->
RemainingBytes() - headerSize[mode]) << 3) / bitsPerSample[mode];
676 pCkData->
SetPos(frameSize, RIFF::stream_curpos);
682 if (FrameTable)
delete[] FrameTable;
684 std::list<file_offset_t>::iterator end = frameOffsets.end();
685 std::list<file_offset_t>::iterator iter = frameOffsets.begin();
686 for (
int i = 0; iter != end; i++, iter++) {
687 FrameTable[i] = *iter;
701 return LoadSampleDataWithNullSamplesExtension(this->
SamplesTotal, 0);
727 return LoadSampleDataWithNullSamplesExtension(SampleCount, 0);
749 buffer_t Sample::LoadSampleDataWithNullSamplesExtension(uint NullSamplesCount) {
750 return LoadSampleDataWithNullSamplesExtension(this->
SamplesTotal, NullSamplesCount);
785 buffer_t Sample::LoadSampleDataWithNullSamplesExtension(file_offset_t SampleCount, uint NullSamplesCount) {
787 if (RAMCache.pStart)
delete[] (int8_t*) RAMCache.pStart;
788 file_offset_t allocationsize = (SampleCount + NullSamplesCount) * this->
FrameSize;
790 RAMCache.pStart =
new int8_t[allocationsize];
791 RAMCache.Size =
Read(RAMCache.pStart, SampleCount) * this->
FrameSize;
792 RAMCache.NullExtensionSize = allocationsize - RAMCache.Size;
794 memset((int8_t*)RAMCache.pStart + RAMCache.Size, 0, RAMCache.NullExtensionSize);
808 buffer_t Sample::GetCache() {
811 result.Size = this->RAMCache.Size;
812 result.pStart = this->RAMCache.pStart;
813 result.NullExtensionSize = this->RAMCache.NullExtensionSize;
824 if (RAMCache.pStart)
delete[] (int8_t*) RAMCache.pStart;
825 RAMCache.pStart = NULL;
827 RAMCache.NullExtensionSize = 0;
861 if (Compressed)
throw gig::Exception(
"There is no support for modifying compressed samples (yet)");
889 case RIFF::stream_curpos:
890 this->SamplePos += SampleCount;
892 case RIFF::stream_end:
895 case RIFF::stream_backward:
896 this->SamplePos -= SampleCount;
898 case RIFF::stream_start:
default:
899 this->SamplePos = SampleCount;
905 this->FrameOffset = this->SamplePos % 2048;
906 pCkData->
SetPos(FrameTable[frame]);
907 return this->SamplePos;
912 return (result == orderedBytes) ? SampleCount
921 if (Compressed)
return SamplePos;
959 file_offset_t Sample::ReadAndLoop(
void* pBuffer, file_offset_t SampleCount, playback_state_t* pPlaybackState,
960 DimensionRegion* pDimRgn, buffer_t* pExternalDecompressionBuffer) {
961 file_offset_t samplestoread = SampleCount, totalreadsamples = 0, readsamples, samplestoloopend;
962 uint8_t* pDst = (uint8_t*) pBuffer;
964 SetPos(pPlaybackState->position);
966 if (pDimRgn->SampleLoops) {
971 if (GetPos() <= loopEnd) {
974 case loop_type_bidirectional: {
977 if (this->LoopPlayCount && !pPlaybackState->loop_cycles_left)
break;
979 if (!pPlaybackState->reverse) {
981 samplestoloopend = loopEnd - GetPos();
982 readsamples =
Read(&pDst[totalreadsamples * this->FrameSize], Min(samplestoread, samplestoloopend), pExternalDecompressionBuffer);
983 samplestoread -= readsamples;
984 totalreadsamples += readsamples;
985 if (readsamples == samplestoloopend) {
986 pPlaybackState->reverse =
true;
989 }
while (samplestoread && readsamples);
1001 file_offset_t samplestoreadinloop = Min(samplestoread, loopoffset);
1002 file_offset_t reverseplaybackend = GetPos() - samplestoreadinloop;
1004 SetPos(reverseplaybackend);
1008 readsamples =
Read(&pDst[totalreadsamples * this->FrameSize], samplestoreadinloop, pExternalDecompressionBuffer);
1009 samplestoreadinloop -= readsamples;
1010 samplestoread -= readsamples;
1011 totalreadsamples += readsamples;
1012 }
while (samplestoreadinloop && readsamples);
1014 SetPos(reverseplaybackend);
1016 if (reverseplaybackend == loop.
LoopStart) {
1017 pPlaybackState->loop_cycles_left--;
1018 pPlaybackState->reverse =
false;
1022 if (totalreadsamples > swapareastart)
1023 SwapMemoryArea(&pDst[swapareastart * this->FrameSize], (totalreadsamples - swapareastart) * this->FrameSize, this->FrameSize);
1025 }
while (samplestoread && readsamples);
1029 case loop_type_backward: {
1031 if (!pPlaybackState->reverse)
do {
1032 samplestoloopend = loopEnd - GetPos();
1033 readsamples =
Read(&pDst[totalreadsamples * this->FrameSize], Min(samplestoread, samplestoloopend), pExternalDecompressionBuffer);
1034 samplestoread -= readsamples;
1035 totalreadsamples += readsamples;
1036 if (readsamples == samplestoloopend) {
1037 pPlaybackState->reverse =
true;
1040 }
while (samplestoread && readsamples);
1042 if (!samplestoread)
break;
1052 file_offset_t samplestoreadinloop = (this->LoopPlayCount) ? Min(samplestoread, pPlaybackState->loop_cycles_left * loop.
LoopLength - loopoffset)
1056 SetPos(reverseplaybackend);
1061 if (this->LoopPlayCount && !pPlaybackState->loop_cycles_left)
break;
1062 samplestoloopend = loopEnd - GetPos();
1063 readsamples =
Read(&pDst[totalreadsamples * this->FrameSize], Min(samplestoreadinloop, samplestoloopend), pExternalDecompressionBuffer);
1064 samplestoreadinloop -= readsamples;
1065 samplestoread -= readsamples;
1066 totalreadsamples += readsamples;
1067 if (readsamples == samplestoloopend) {
1068 pPlaybackState->loop_cycles_left--;
1071 }
while (samplestoreadinloop && readsamples);
1073 SetPos(reverseplaybackend);
1076 SwapMemoryArea(&pDst[swapareastart * this->FrameSize], (totalreadsamples - swapareastart) * this->FrameSize, this->FrameSize);
1080 default:
case loop_type_normal: {
1083 if (this->LoopPlayCount && !pPlaybackState->loop_cycles_left)
break;
1084 samplestoloopend = loopEnd - GetPos();
1085 readsamples =
Read(&pDst[totalreadsamples * this->FrameSize], Min(samplestoread, samplestoloopend), pExternalDecompressionBuffer);
1086 samplestoread -= readsamples;
1087 totalreadsamples += readsamples;
1088 if (readsamples == samplestoloopend) {
1089 pPlaybackState->loop_cycles_left--;
1092 }
while (samplestoread && readsamples);
1100 if (samplestoread)
do {
1101 readsamples =
Read(&pDst[totalreadsamples * this->FrameSize], samplestoread, pExternalDecompressionBuffer);
1102 samplestoread -= readsamples;
1103 totalreadsamples += readsamples;
1104 }
while (readsamples && samplestoread);
1107 pPlaybackState->position = GetPos();
1109 return totalreadsamples;
1135 if (SampleCount == 0)
return 0;
1142 return Channels == 2 ? pCkData->
Read(pBuffer, SampleCount << 1, 2) >> 1
1143 : pCkData->
Read(pBuffer, SampleCount, 2);
1151 remainingsamples = SampleCount,
1152 copysamples, skipsamples,
1153 currentframeoffset = this->FrameOffset;
1154 this->FrameOffset = 0;
1156 buffer_t* pDecompressionBuffer = (pExternalDecompressionBuffer) ? pExternalDecompressionBuffer : &InternalDecompressionBuffer;
1159 if (pDecompressionBuffer->Size < assumedsize) {
1160 std::cerr <<
"gig::Read(): WARNING - decompression buffer size too small!" << std::endl;
1161 SampleCount = WorstCaseMaxSamples(pDecompressionBuffer);
1162 remainingsamples = SampleCount;
1163 assumedsize = GuessSize(SampleCount);
1166 unsigned char* pSrc = (
unsigned char*) pDecompressionBuffer->pStart;
1167 int16_t* pDst = static_cast<int16_t*>(pBuffer);
1168 uint8_t* pDst24 =
static_cast<uint8_t*
>(pBuffer);
1169 remainingbytes = pCkData->
Read(pSrc, assumedsize, 1);
1171 while (remainingsamples && remainingbytes) {
1173 file_offset_t framebytes, rightChannelOffset = 0, nextFrameOffset;
1175 int mode_l = *pSrc++, mode_r = 0;
1179 framebytes = bytesPerFrame[mode_l] + bytesPerFrame[mode_r] + 2;
1180 rightChannelOffset = bytesPerFrameNoHdr[mode_l];
1181 nextFrameOffset = rightChannelOffset + bytesPerFrameNoHdr[mode_r];
1182 if (remainingbytes < framebytes) {
1183 framesamples = SamplesInLastFrame;
1184 if (mode_l == 4 && (framesamples & 1)) {
1185 rightChannelOffset = ((framesamples + 1) * bitsPerSample[mode_l]) >> 3;
1188 rightChannelOffset = (framesamples * bitsPerSample[mode_l]) >> 3;
1193 framebytes = bytesPerFrame[mode_l] + 1;
1194 nextFrameOffset = bytesPerFrameNoHdr[mode_l];
1195 if (remainingbytes < framebytes) {
1196 framesamples = SamplesInLastFrame;
1201 if (currentframeoffset + remainingsamples >= framesamples) {
1202 if (currentframeoffset <= framesamples) {
1203 copysamples = framesamples - currentframeoffset;
1204 skipsamples = currentframeoffset;
1208 skipsamples = framesamples;
1215 copysamples = remainingsamples;
1216 skipsamples = currentframeoffset;
1217 pCkData->
SetPos(remainingbytes, RIFF::stream_backward);
1218 this->FrameOffset = currentframeoffset + copysamples;
1220 remainingsamples -= copysamples;
1222 if (remainingbytes > framebytes) {
1223 remainingbytes -= framebytes;
1224 if (remainingsamples == 0 &&
1225 currentframeoffset + copysamples == framesamples) {
1230 pCkData->
SetPos(remainingbytes, RIFF::stream_backward);
1233 else remainingbytes = 0;
1235 currentframeoffset -= skipsamples;
1237 if (copysamples == 0) {
1242 const unsigned char*
const param_l = pSrc;
1244 if (mode_l != 2) pSrc += 12;
1247 const unsigned char*
const param_r = pSrc;
1248 if (mode_r != 2) pSrc += 12;
1250 Decompress24(mode_l, param_l, 6, pSrc, pDst24,
1251 skipsamples, copysamples, TruncatedBits);
1252 Decompress24(mode_r, param_r, 6, pSrc + rightChannelOffset, pDst24 + 3,
1253 skipsamples, copysamples, TruncatedBits);
1254 pDst24 += copysamples * 6;
1257 Decompress24(mode_l, param_l, 3, pSrc, pDst24,
1258 skipsamples, copysamples, TruncatedBits);
1259 pDst24 += copysamples * 3;
1263 if (mode_l) pSrc += 4;
1267 const unsigned char*
const param_r = pSrc;
1268 if (mode_r) pSrc += 4;
1270 step = (2 - mode_l) + (2 - mode_r);
1271 Decompress16(mode_l, param_l, step, 2, pSrc, pDst, skipsamples, copysamples);
1272 Decompress16(mode_r, param_r, step, 2, pSrc + (2 - mode_l), pDst + 1,
1273 skipsamples, copysamples);
1274 pDst += copysamples << 1;
1278 Decompress16(mode_l, param_l, step, 1, pSrc, pDst, skipsamples, copysamples);
1279 pDst += copysamples;
1282 pSrc += nextFrameOffset;
1286 if (remainingsamples && remainingbytes < WorstCaseFrameSize && pCkData->GetState() == RIFF::stream_ready) {
1287 assumedsize = GuessSize(remainingsamples);
1288 pCkData->
SetPos(remainingbytes, RIFF::stream_backward);
1290 remainingbytes = pCkData->
Read(pDecompressionBuffer->pStart, assumedsize, 1);
1291 pSrc = (
unsigned char*) pDecompressionBuffer->pStart;
1295 this->SamplePos += (SampleCount - remainingsamples);
1297 return (SampleCount - remainingsamples);
1324 if (Compressed)
throw gig::Exception(
"There is no support for writing compressed gig samples (yet)");
1328 if (pCkData->
GetPos() == 0) {
1331 if (
GetSize() < SampleCount)
throw Exception(
"Could not write sample data, current sample size to small");
1336 res =
Channels == 2 ? pCkData->
Write(pBuffer, SampleCount << 1, 2) >> 1
1337 : pCkData->
Write(pBuffer, SampleCount, 2);
1339 __calculateCRC((
unsigned char *)pBuffer, SampleCount *
FrameSize, crc);
1345 File* pFile =
static_cast<File*
>(GetParent());
1346 pFile->SetSampleChecksum(
this, crc);
1367 buffer_t Sample::CreateDecompressionBuffer(file_offset_t MaxReadSize) {
1369 const double worstCaseHeaderOverhead =
1370 (256.0 + 12.0 + 2.0 ) / 256.0;
1371 result.Size = (
file_offset_t) (
double(MaxReadSize) * 3.0 * 2.0 * worstCaseHeaderOverhead);
1372 result.pStart =
new int8_t[result.Size];
1373 result.NullExtensionSize = 0;
1384 void Sample::DestroyDecompressionBuffer(buffer_t& DecompressionBuffer) {
1385 if (DecompressionBuffer.Size && DecompressionBuffer.pStart) {
1386 delete[] (int8_t*) DecompressionBuffer.pStart;
1387 DecompressionBuffer.pStart = NULL;
1388 DecompressionBuffer.Size = 0;
1389 DecompressionBuffer.NullExtensionSize = 0;
1401 Group* Sample::GetGroup()
const {
1417 uint32_t Sample::GetWaveDataCRC32Checksum() {
1446 bool Sample::VerifyWaveData(uint32_t* pActually) {
1448 uint32_t crc = CalculateWaveDataChecksum();
1449 if (pActually) *pActually = crc;
1450 return crc == this->crc;
1453 uint32_t Sample::CalculateWaveDataChecksum() {
1454 const size_t sz = 20*1024;
1455 std::vector<uint8_t> buffer(sz);
1464 if (nRead <= 0)
break;
1465 __calculateCRC(&buffer[0], nRead *
FrameSize, crc);
1473 if (!Instances && InternalDecompressionBuffer.Size) {
1474 delete[] (
unsigned char*) InternalDecompressionBuffer.pStart;
1475 InternalDecompressionBuffer.pStart = NULL;
1476 InternalDecompressionBuffer.Size = 0;
1478 if (FrameTable)
delete[] FrameTable;
1479 if (RAMCache.pStart)
delete[] (int8_t*) RAMCache.pStart;
1487 size_t DimensionRegion::Instances = 0;
1488 DimensionRegion::VelocityTableMap* DimensionRegion::pVelocityTables = NULL;
1490 DimensionRegion::DimensionRegion(Region* pParent,
RIFF::List* _3ewl) :
DLS::Sampler(_3ewl) {
1496 if (_3ewl->
GetSubChunk(CHUNK_ID_WSMP)) memcpy(&Crossfade, &SamplerOptions, 4);
1497 else memset(&Crossfade, 0, 4);
1499 if (!pVelocityTables) pVelocityTables =
new VelocityTableMap;
1504 LFO3Frequency = (double) GIG_EXP_DECODE(_3ewa->
ReadInt32());
1505 EG3Attack = (double) GIG_EXP_DECODE(_3ewa->
ReadInt32());
1514 EG1Attack = (double) GIG_EXP_DECODE(_3ewa->
ReadInt32());
1515 EG1Decay1 = (double) GIG_EXP_DECODE(_3ewa->
ReadInt32());
1518 EG1Release = (double) GIG_EXP_DECODE(_3ewa->
ReadInt32());
1519 EG1Controller = DecodeLeverageController(static_cast<_lev_ctrl_t>(_3ewa->
ReadUint8()));
1520 uint8_t eg1ctrloptions = _3ewa->
ReadUint8();
1521 EG1ControllerInvert = eg1ctrloptions & 0x01;
1522 EG1ControllerAttackInfluence = GIG_EG_CTR_ATTACK_INFLUENCE_EXTRACT(eg1ctrloptions);
1523 EG1ControllerDecayInfluence = GIG_EG_CTR_DECAY_INFLUENCE_EXTRACT(eg1ctrloptions);
1524 EG1ControllerReleaseInfluence = GIG_EG_CTR_RELEASE_INFLUENCE_EXTRACT(eg1ctrloptions);
1525 EG2Controller = DecodeLeverageController(static_cast<_lev_ctrl_t>(_3ewa->
ReadUint8()));
1526 uint8_t eg2ctrloptions = _3ewa->
ReadUint8();
1527 EG2ControllerInvert = eg2ctrloptions & 0x01;
1528 EG2ControllerAttackInfluence = GIG_EG_CTR_ATTACK_INFLUENCE_EXTRACT(eg2ctrloptions);
1529 EG2ControllerDecayInfluence = GIG_EG_CTR_DECAY_INFLUENCE_EXTRACT(eg2ctrloptions);
1530 EG2ControllerReleaseInfluence = GIG_EG_CTR_RELEASE_INFLUENCE_EXTRACT(eg2ctrloptions);
1531 LFO1Frequency = (double) GIG_EXP_DECODE(_3ewa->
ReadInt32());
1532 EG2Attack = (double) GIG_EXP_DECODE(_3ewa->
ReadInt32());
1533 EG2Decay1 = (double) GIG_EXP_DECODE(_3ewa->
ReadInt32());
1536 EG2Release = (double) GIG_EXP_DECODE(_3ewa->
ReadInt32());
1539 LFO2Frequency = (double) GIG_EXP_DECODE(_3ewa->
ReadInt32());
1543 EG1Decay2 = (double) GIG_EXP_DECODE(eg1decay2);
1544 EG1InfiniteSustain = (eg1decay2 == 0x7fffffff);
1548 EG2Decay2 = (double) GIG_EXP_DECODE(eg2decay2);
1549 EG2InfiniteSustain = (eg2decay2 == 0x7fffffff);
1552 uint8_t velocityresponse = _3ewa->
ReadUint8();
1553 if (velocityresponse < 5) {
1554 VelocityResponseCurve = curve_type_nonlinear;
1555 VelocityResponseDepth = velocityresponse;
1556 }
else if (velocityresponse < 10) {
1557 VelocityResponseCurve = curve_type_linear;
1558 VelocityResponseDepth = velocityresponse - 5;
1559 }
else if (velocityresponse < 15) {
1560 VelocityResponseCurve = curve_type_special;
1561 VelocityResponseDepth = velocityresponse - 10;
1563 VelocityResponseCurve = curve_type_unknown;
1564 VelocityResponseDepth = 0;
1566 uint8_t releasevelocityresponse = _3ewa->
ReadUint8();
1567 if (releasevelocityresponse < 5) {
1568 ReleaseVelocityResponseCurve = curve_type_nonlinear;
1569 ReleaseVelocityResponseDepth = releasevelocityresponse;
1570 }
else if (releasevelocityresponse < 10) {
1571 ReleaseVelocityResponseCurve = curve_type_linear;
1572 ReleaseVelocityResponseDepth = releasevelocityresponse - 5;
1573 }
else if (releasevelocityresponse < 15) {
1574 ReleaseVelocityResponseCurve = curve_type_special;
1575 ReleaseVelocityResponseDepth = releasevelocityresponse - 10;
1577 ReleaseVelocityResponseCurve = curve_type_unknown;
1578 ReleaseVelocityResponseDepth = 0;
1580 VelocityResponseCurveScaling = _3ewa->
ReadUint8();
1581 AttenuationControllerThreshold = _3ewa->
ReadInt8();
1583 SampleStartOffset = (uint16_t) _3ewa->
ReadInt16();
1585 uint8_t pitchTrackDimensionBypass = _3ewa->
ReadInt8();
1586 PitchTrack = GIG_PITCH_TRACK_EXTRACT(pitchTrackDimensionBypass);
1587 if (pitchTrackDimensionBypass & 0x10) DimensionBypass = dim_bypass_ctrl_94;
1588 else if (pitchTrackDimensionBypass & 0x20) DimensionBypass = dim_bypass_ctrl_95;
1589 else DimensionBypass = dim_bypass_ctrl_none;
1591 Pan = (pan < 64) ? pan : -((
int)pan - 63);
1592 SelfMask = _3ewa->
ReadInt8() & 0x01;
1595 LFO3Controller =
static_cast<lfo3_ctrl_t
>(lfo3ctrl & 0x07);
1596 LFO3Sync = lfo3ctrl & 0x20;
1597 InvertAttenuationController = lfo3ctrl & 0x80;
1598 AttenuationController = DecodeLeverageController(static_cast<_lev_ctrl_t>(_3ewa->
ReadUint8()));
1600 LFO2Controller =
static_cast<lfo2_ctrl_t
>(lfo2ctrl & 0x07);
1601 LFO2FlipPhase = lfo2ctrl & 0x80;
1602 LFO2Sync = lfo2ctrl & 0x20;
1603 bool extResonanceCtrl = lfo2ctrl & 0x40;
1605 LFO1Controller =
static_cast<lfo1_ctrl_t
>(lfo1ctrl & 0x07);
1606 LFO1FlipPhase = lfo1ctrl & 0x80;
1607 LFO1Sync = lfo1ctrl & 0x40;
1608 VCFResonanceController = (extResonanceCtrl) ? static_cast<vcf_res_ctrl_t>(GIG_VCF_RESONANCE_CTRL_EXTRACT(lfo1ctrl))
1609 : vcf_res_ctrl_none;
1611 EG3Depth = (eg3depth <= 1200) ? eg3depth
1612 : (-1) * (int16_t) ((eg3depth ^ 0xfff) + 1);
1615 uint8_t regoptions = _3ewa->
ReadUint8();
1616 MSDecode = regoptions & 0x01;
1617 SustainDefeat = regoptions & 0x02;
1619 VelocityUpperLimit = _3ewa->
ReadInt8();
1622 ReleaseTriggerDecay = _3ewa->
ReadUint8();
1627 VCFEnabled = vcfcutoff & 0x80;
1628 VCFCutoff = vcfcutoff & 0x7f;
1629 VCFCutoffController =
static_cast<vcf_cutoff_ctrl_t
>(_3ewa->
ReadUint8());
1630 uint8_t vcfvelscale = _3ewa->
ReadUint8();
1631 VCFCutoffControllerInvert = vcfvelscale & 0x80;
1632 VCFVelocityScale = vcfvelscale & 0x7f;
1634 uint8_t vcfresonance = _3ewa->
ReadUint8();
1635 VCFResonance = vcfresonance & 0x7f;
1636 VCFResonanceDynamic = !(vcfresonance & 0x80);
1637 uint8_t vcfbreakpoint = _3ewa->
ReadUint8();
1638 VCFKeyboardTracking = vcfbreakpoint & 0x80;
1639 VCFKeyboardTrackingBreakpoint = vcfbreakpoint & 0x7f;
1640 uint8_t vcfvelocity = _3ewa->
ReadUint8();
1641 VCFVelocityDynamicRange = vcfvelocity % 5;
1642 VCFVelocityCurve =
static_cast<curve_type_t
>(vcfvelocity / 5);
1643 VCFType =
static_cast<vcf_type_t
>(_3ewa->
ReadUint8());
1644 if (VCFType == vcf_type_lowpass) {
1645 if (lfo3ctrl & 0x40)
1646 VCFType = vcf_type_lowpassturbo;
1649 _3ewa->
Read(DimensionUpperLimits, 1, 8);
1651 memset(DimensionUpperLimits, 0, 8);
1655 LFO3Frequency = 1.0;
1657 LFO1InternalDepth = 0;
1658 LFO3InternalDepth = 0;
1659 LFO1ControlDepth = 0;
1660 LFO3ControlDepth = 0;
1665 EG1Controller.type = eg1_ctrl_t::type_none;
1666 EG1Controller.controller_number = 0;
1667 EG1ControllerInvert =
false;
1668 EG1ControllerAttackInfluence = 0;
1669 EG1ControllerDecayInfluence = 0;
1670 EG1ControllerReleaseInfluence = 0;
1671 EG2Controller.type = eg2_ctrl_t::type_none;
1672 EG2Controller.controller_number = 0;
1673 EG2ControllerInvert =
false;
1674 EG2ControllerAttackInfluence = 0;
1675 EG2ControllerDecayInfluence = 0;
1676 EG2ControllerReleaseInfluence = 0;
1677 LFO1Frequency = 1.0;
1682 LFO2ControlDepth = 0;
1683 LFO2Frequency = 1.0;
1684 LFO2InternalDepth = 0;
1686 EG1InfiniteSustain =
true;
1689 EG2InfiniteSustain =
true;
1691 VelocityResponseCurve = curve_type_nonlinear;
1692 VelocityResponseDepth = 3;
1693 ReleaseVelocityResponseCurve = curve_type_nonlinear;
1694 ReleaseVelocityResponseDepth = 3;
1695 VelocityResponseCurveScaling = 32;
1696 AttenuationControllerThreshold = 0;
1697 SampleStartOffset = 0;
1699 DimensionBypass = dim_bypass_ctrl_none;
1702 LFO3Controller = lfo3_ctrl_modwheel;
1704 InvertAttenuationController =
false;
1705 AttenuationController.type = attenuation_ctrl_t::type_none;
1706 AttenuationController.controller_number = 0;
1707 LFO2Controller = lfo2_ctrl_internal;
1708 LFO2FlipPhase =
false;
1710 LFO1Controller = lfo1_ctrl_internal;
1711 LFO1FlipPhase =
false;
1713 VCFResonanceController = vcf_res_ctrl_none;
1717 SustainDefeat =
false;
1718 VelocityUpperLimit = 0;
1719 ReleaseTriggerDecay = 0;
1723 VCFCutoffController = vcf_cutoff_ctrl_none;
1724 VCFCutoffControllerInvert =
false;
1725 VCFVelocityScale = 0;
1727 VCFResonanceDynamic =
false;
1728 VCFKeyboardTracking =
false;
1729 VCFKeyboardTrackingBreakpoint = 0;
1730 VCFVelocityDynamicRange = 0x04;
1731 VCFVelocityCurve = curve_type_linear;
1732 VCFType = vcf_type_lowpass;
1733 memset(DimensionUpperLimits, 127, 8);
1738 eg_opt_t* pEGOpts[2] = { &EG1Options, &EG2Options };
1739 for (
int i = 0; i < 2; ++i) {
1741 pEGOpts[i]->AttackCancel = byte & 1;
1742 pEGOpts[i]->AttackHoldCancel = byte & (1 << 1);
1743 pEGOpts[i]->Decay1Cancel = byte & (1 << 2);
1744 pEGOpts[i]->Decay2Cancel = byte & (1 << 3);
1745 pEGOpts[i]->ReleaseCancel = byte & (1 << 4);
1749 if (lsde && lsde->
GetSize() > 3) {
1752 SustainReleaseTrigger =
static_cast<sust_rel_trg_t
>(byte & 0x03);
1753 NoNoteOffReleaseTrigger = byte >> 7;
1755 SustainReleaseTrigger = sust_rel_trg_none;
1756 NoNoteOffReleaseTrigger =
false;
1759 pVelocityAttenuationTable = GetVelocityTable(VelocityResponseCurve,
1760 VelocityResponseDepth,
1761 VelocityResponseCurveScaling);
1763 pVelocityReleaseTable = GetReleaseVelocityTable(
1764 ReleaseVelocityResponseCurve,
1765 ReleaseVelocityResponseDepth
1768 pVelocityCutoffTable = GetCutoffVelocityTable(VCFVelocityCurve,
1769 VCFVelocityDynamicRange,
1771 VCFCutoffController);
1773 SampleAttenuation = pow(10.0, -Gain / (20.0 * 655360));
1781 DimensionRegion::DimensionRegion(
RIFF::List* _3ewl,
const DimensionRegion& src) :
DLS::Sampler(_3ewl) {
1785 pParentList = _3ewl;
1788 if (src.VelocityTable) {
1789 VelocityTable =
new uint8_t[128];
1790 for (
int k = 0 ; k < 128 ; k++)
1791 VelocityTable[k] = src.VelocityTable[k];
1793 if (src.pSampleLoops) {
1795 for (
int k = 0 ; k < src.SampleLoops ; k++)
1796 pSampleLoops[k] = src.pSampleLoops[k];
1809 void DimensionRegion::CopyAssign(
const DimensionRegion* orig) {
1810 CopyAssign(orig, NULL);
1821 void DimensionRegion::CopyAssign(
const DimensionRegion* orig,
const std::map<Sample*,Sample*>* mSamples) {
1823 if (VelocityTable)
delete [] VelocityTable;
1824 if (pSampleLoops)
delete [] pSampleLoops;
1829 gig::Sample* pOriginalSample = pSample;
1830 gig::Region* pOriginalRegion = pRegion;
1838 pRegion = pOriginalRegion;
1842 if (pOriginalRegion->GetParent()->GetParent() != orig->pRegion->GetParent()->GetParent()) {
1843 pSample = pOriginalSample;
1846 if (mSamples && mSamples->count(orig->pSample)) {
1847 pSample = mSamples->find(orig->pSample)->second;
1851 if (orig->VelocityTable) {
1852 VelocityTable =
new uint8_t[128];
1853 for (
int k = 0 ; k < 128 ; k++)
1854 VelocityTable[k] = orig->VelocityTable[k];
1856 if (orig->pSampleLoops) {
1858 for (
int k = 0 ; k < orig->SampleLoops ; k++)
1859 pSampleLoops[k] = orig->pSampleLoops[k];
1869 SRLZ(VelocityUpperLimit);
1874 SRLZ(EG1InfiniteSustain);
1878 SRLZ(EG1Controller);
1879 SRLZ(EG1ControllerInvert);
1880 SRLZ(EG1ControllerAttackInfluence);
1881 SRLZ(EG1ControllerDecayInfluence);
1882 SRLZ(EG1ControllerReleaseInfluence);
1883 SRLZ(LFO1Frequency);
1884 SRLZ(LFO1InternalDepth);
1885 SRLZ(LFO1ControlDepth);
1886 SRLZ(LFO1Controller);
1887 SRLZ(LFO1FlipPhase);
1893 SRLZ(EG2InfiniteSustain);
1896 SRLZ(EG2Controller);
1897 SRLZ(EG2ControllerInvert);
1898 SRLZ(EG2ControllerAttackInfluence);
1899 SRLZ(EG2ControllerDecayInfluence);
1900 SRLZ(EG2ControllerReleaseInfluence);
1901 SRLZ(LFO2Frequency);
1902 SRLZ(LFO2InternalDepth);
1903 SRLZ(LFO2ControlDepth);
1904 SRLZ(LFO2Controller);
1905 SRLZ(LFO2FlipPhase);
1909 SRLZ(LFO3Frequency);
1910 SRLZ(LFO3InternalDepth);
1911 SRLZ(LFO3ControlDepth);
1912 SRLZ(LFO3Controller);
1916 SRLZ(VCFCutoffController);
1917 SRLZ(VCFCutoffControllerInvert);
1919 SRLZ(VCFVelocityCurve);
1920 SRLZ(VCFVelocityScale);
1921 SRLZ(VCFVelocityDynamicRange);
1923 SRLZ(VCFResonanceDynamic);
1924 SRLZ(VCFResonanceController);
1925 SRLZ(VCFKeyboardTracking);
1926 SRLZ(VCFKeyboardTrackingBreakpoint);
1927 SRLZ(VelocityResponseCurve);
1928 SRLZ(VelocityResponseDepth);
1929 SRLZ(VelocityResponseCurveScaling);
1930 SRLZ(ReleaseVelocityResponseCurve);
1931 SRLZ(ReleaseVelocityResponseDepth);
1932 SRLZ(ReleaseTriggerDecay);
1935 SRLZ(DimensionBypass);
1938 SRLZ(AttenuationController);
1939 SRLZ(InvertAttenuationController);
1940 SRLZ(AttenuationControllerThreshold);
1941 SRLZ(ChannelOffset);
1942 SRLZ(SustainDefeat);
1945 SRLZ(SampleAttenuation);
1948 SRLZ(SustainReleaseTrigger);
1949 SRLZ(NoNoteOffReleaseTrigger);
1960 void DimensionRegion::SetGain(int32_t gain) {
1961 DLS::Sampler::SetGain(gain);
1962 SampleAttenuation = pow(10.0, -Gain / (20.0 * 655360));
1974 void DimensionRegion::UpdateChunks(progress_t* pProgress) {
1978 RIFF::Chunk* wsmp = pParentList->GetSubChunk(CHUNK_ID_WSMP);
1980 pData[12] = Crossfade.in_start;
1981 pData[13] = Crossfade.in_end;
1982 pData[14] = Crossfade.out_start;
1983 pData[15] = Crossfade.out_end;
1986 RIFF::Chunk* _3ewa = pParentList->GetSubChunk(CHUNK_ID_3EWA);
1989 bool versiongt2 = pFile->pVersion && pFile->pVersion->major > 2;
1990 _3ewa = pParentList->AddSubChunk(CHUNK_ID_3EWA, versiongt2 ? 148 : 140);
1996 const uint32_t chunksize = (uint32_t) _3ewa->
GetNewSize();
1997 store32(&pData[0], chunksize);
1999 const int32_t lfo3freq = (int32_t) GIG_EXP_ENCODE(LFO3Frequency);
2000 store32(&pData[4], lfo3freq);
2002 const int32_t eg3attack = (int32_t) GIG_EXP_ENCODE(EG3Attack);
2003 store32(&pData[8], eg3attack);
2007 store16(&pData[14], LFO1InternalDepth);
2011 store16(&pData[18], LFO3InternalDepth);
2015 store16(&pData[22], LFO1ControlDepth);
2019 store16(&pData[26], LFO3ControlDepth);
2021 const int32_t eg1attack = (int32_t) GIG_EXP_ENCODE(EG1Attack);
2022 store32(&pData[28], eg1attack);
2024 const int32_t eg1decay1 = (int32_t) GIG_EXP_ENCODE(EG1Decay1);
2025 store32(&pData[32], eg1decay1);
2029 store16(&pData[38], EG1Sustain);
2031 const int32_t eg1release = (int32_t) GIG_EXP_ENCODE(EG1Release);
2032 store32(&pData[40], eg1release);
2034 const uint8_t eg1ctl = (uint8_t) EncodeLeverageController(EG1Controller);
2037 const uint8_t eg1ctrloptions =
2038 (EG1ControllerInvert ? 0x01 : 0x00) |
2039 GIG_EG_CTR_ATTACK_INFLUENCE_ENCODE(EG1ControllerAttackInfluence) |
2040 GIG_EG_CTR_DECAY_INFLUENCE_ENCODE(EG1ControllerDecayInfluence) |
2041 GIG_EG_CTR_RELEASE_INFLUENCE_ENCODE(EG1ControllerReleaseInfluence);
2042 pData[45] = eg1ctrloptions;
2044 const uint8_t eg2ctl = (uint8_t) EncodeLeverageController(EG2Controller);
2047 const uint8_t eg2ctrloptions =
2048 (EG2ControllerInvert ? 0x01 : 0x00) |
2049 GIG_EG_CTR_ATTACK_INFLUENCE_ENCODE(EG2ControllerAttackInfluence) |
2050 GIG_EG_CTR_DECAY_INFLUENCE_ENCODE(EG2ControllerDecayInfluence) |
2051 GIG_EG_CTR_RELEASE_INFLUENCE_ENCODE(EG2ControllerReleaseInfluence);
2052 pData[47] = eg2ctrloptions;
2054 const int32_t lfo1freq = (int32_t) GIG_EXP_ENCODE(LFO1Frequency);
2055 store32(&pData[48], lfo1freq);
2057 const int32_t eg2attack = (int32_t) GIG_EXP_ENCODE(EG2Attack);
2058 store32(&pData[52], eg2attack);
2060 const int32_t eg2decay1 = (int32_t) GIG_EXP_ENCODE(EG2Decay1);
2061 store32(&pData[56], eg2decay1);
2065 store16(&pData[62], EG2Sustain);
2067 const int32_t eg2release = (int32_t) GIG_EXP_ENCODE(EG2Release);
2068 store32(&pData[64], eg2release);
2072 store16(&pData[70], LFO2ControlDepth);
2074 const int32_t lfo2freq = (int32_t) GIG_EXP_ENCODE(LFO2Frequency);
2075 store32(&pData[72], lfo2freq);
2079 store16(&pData[78], LFO2InternalDepth);
2081 const int32_t eg1decay2 = (int32_t) (EG1InfiniteSustain) ? 0x7fffffff : (int32_t) GIG_EXP_ENCODE(EG1Decay2);
2082 store32(&pData[80], eg1decay2);
2086 store16(&pData[86], EG1PreAttack);
2088 const int32_t eg2decay2 = (int32_t) (EG2InfiniteSustain) ? 0x7fffffff : (int32_t) GIG_EXP_ENCODE(EG2Decay2);
2089 store32(&pData[88], eg2decay2);
2093 store16(&pData[94], EG2PreAttack);
2096 if (VelocityResponseDepth > 4)
throw Exception(
"VelocityResponseDepth must be between 0 and 4");
2097 uint8_t velocityresponse = VelocityResponseDepth;
2098 switch (VelocityResponseCurve) {
2099 case curve_type_nonlinear:
2101 case curve_type_linear:
2102 velocityresponse += 5;
2104 case curve_type_special:
2105 velocityresponse += 10;
2107 case curve_type_unknown:
2109 throw Exception(
"Could not update DimensionRegion's chunk, unknown VelocityResponseCurve selected");
2111 pData[96] = velocityresponse;
2115 if (ReleaseVelocityResponseDepth > 4)
throw Exception(
"ReleaseVelocityResponseDepth must be between 0 and 4");
2116 uint8_t releasevelocityresponse = ReleaseVelocityResponseDepth;
2117 switch (ReleaseVelocityResponseCurve) {
2118 case curve_type_nonlinear:
2120 case curve_type_linear:
2121 releasevelocityresponse += 5;
2123 case curve_type_special:
2124 releasevelocityresponse += 10;
2126 case curve_type_unknown:
2128 throw Exception(
"Could not update DimensionRegion's chunk, unknown ReleaseVelocityResponseCurve selected");
2130 pData[97] = releasevelocityresponse;
2133 pData[98] = VelocityResponseCurveScaling;
2135 pData[99] = AttenuationControllerThreshold;
2139 store16(&pData[104], SampleStartOffset);
2144 uint8_t pitchTrackDimensionBypass = GIG_PITCH_TRACK_ENCODE(PitchTrack);
2145 switch (DimensionBypass) {
2146 case dim_bypass_ctrl_94:
2147 pitchTrackDimensionBypass |= 0x10;
2149 case dim_bypass_ctrl_95:
2150 pitchTrackDimensionBypass |= 0x20;
2152 case dim_bypass_ctrl_none:
2156 throw Exception(
"Could not update DimensionRegion's chunk, unknown DimensionBypass selected");
2158 pData[108] = pitchTrackDimensionBypass;
2161 const uint8_t pan = (Pan >= 0) ? Pan : ((-Pan) + 63);
2164 const uint8_t selfmask = (SelfMask) ? 0x01 : 0x00;
2165 pData[110] = selfmask;
2170 uint8_t lfo3ctrl = LFO3Controller & 0x07;
2171 if (LFO3Sync) lfo3ctrl |= 0x20;
2172 if (InvertAttenuationController) lfo3ctrl |= 0x80;
2173 if (VCFType == vcf_type_lowpassturbo) lfo3ctrl |= 0x40;
2174 pData[112] = lfo3ctrl;
2177 const uint8_t attenctl = EncodeLeverageController(AttenuationController);
2178 pData[113] = attenctl;
2181 uint8_t lfo2ctrl = LFO2Controller & 0x07;
2182 if (LFO2FlipPhase) lfo2ctrl |= 0x80;
2183 if (LFO2Sync) lfo2ctrl |= 0x20;
2184 if (VCFResonanceController != vcf_res_ctrl_none) lfo2ctrl |= 0x40;
2185 pData[114] = lfo2ctrl;
2189 uint8_t lfo1ctrl = LFO1Controller & 0x07;
2190 if (LFO1FlipPhase) lfo1ctrl |= 0x80;
2191 if (LFO1Sync) lfo1ctrl |= 0x40;
2192 if (VCFResonanceController != vcf_res_ctrl_none)
2193 lfo1ctrl |= GIG_VCF_RESONANCE_CTRL_ENCODE(VCFResonanceController);
2194 pData[115] = lfo1ctrl;
2197 const uint16_t eg3depth = (EG3Depth >= 0) ? EG3Depth
2198 : uint16_t(((-EG3Depth) - 1) ^ 0xfff);
2199 store16(&pData[116], eg3depth);
2203 const uint8_t channeloffset = ChannelOffset * 4;
2204 pData[120] = channeloffset;
2207 uint8_t regoptions = 0;
2208 if (MSDecode) regoptions |= 0x01;
2209 if (SustainDefeat) regoptions |= 0x02;
2210 pData[121] = regoptions;
2215 pData[124] = VelocityUpperLimit;
2219 pData[128] = ReleaseTriggerDecay;
2223 const uint8_t eg1hold = (EG1Hold) ? 0x80 : 0x00;
2224 pData[131] = eg1hold;
2226 const uint8_t vcfcutoff = (VCFEnabled ? 0x80 : 0x00) |
2228 pData[132] = vcfcutoff;
2230 pData[133] = VCFCutoffController;
2232 const uint8_t vcfvelscale = (VCFCutoffControllerInvert ? 0x80 : 0x00) |
2233 (VCFVelocityScale & 0x7f);
2234 pData[134] = vcfvelscale;
2238 const uint8_t vcfresonance = (VCFResonanceDynamic ? 0x00 : 0x80) |
2239 (VCFResonance & 0x7f);
2240 pData[136] = vcfresonance;
2242 const uint8_t vcfbreakpoint = (VCFKeyboardTracking ? 0x80 : 0x00) |
2243 (VCFKeyboardTrackingBreakpoint & 0x7f);
2244 pData[137] = vcfbreakpoint;
2246 const uint8_t vcfvelocity = VCFVelocityDynamicRange % 5 +
2247 VCFVelocityCurve * 5;
2248 pData[138] = vcfvelocity;
2250 const uint8_t vcftype = (VCFType == vcf_type_lowpassturbo) ? vcf_type_lowpass : VCFType;
2251 pData[139] = vcftype;
2253 if (chunksize >= 148) {
2254 memcpy(&pData[140], DimensionUpperLimits, 8);
2259 RIFF::Chunk* lsde = pParentList->GetSubChunk(CHUNK_ID_LSDE);
2260 const int lsdeSize = 4;
2264 eg_opt_t defaultOpt;
2265 if (memcmp(&EG1Options, &defaultOpt,
sizeof(eg_opt_t)) ||
2266 memcmp(&EG2Options, &defaultOpt,
sizeof(eg_opt_t)) ||
2267 SustainReleaseTrigger || NoNoteOffReleaseTrigger)
2269 lsde = pParentList->AddSubChunk(CHUNK_ID_LSDE, lsdeSize);
2271 pParentList->MoveSubChunk(lsde, (
RIFF::Chunk*)NULL);
2278 unsigned char* pData = (
unsigned char*) lsde->
LoadChunkData();
2279 eg_opt_t* pEGOpts[2] = { &EG1Options, &EG2Options };
2280 for (
int i = 0; i < 2; ++i) {
2282 (pEGOpts[i]->AttackCancel ? 1 : 0) |
2283 (pEGOpts[i]->AttackHoldCancel ? (1<<1) : 0) |
2284 (pEGOpts[i]->Decay1Cancel ? (1<<2) : 0) |
2285 (pEGOpts[i]->Decay2Cancel ? (1<<3) : 0) |
2286 (pEGOpts[i]->ReleaseCancel ? (1<<4) : 0);
2289 pData[3] =
static_cast<uint8_t
>(SustainReleaseTrigger) | (NoNoteOffReleaseTrigger ? (1<<7) : 0);
2293 double* DimensionRegion::GetReleaseVelocityTable(curve_type_t releaseVelocityResponseCurve, uint8_t releaseVelocityResponseDepth) {
2294 curve_type_t curveType = releaseVelocityResponseCurve;
2295 uint8_t depth = releaseVelocityResponseDepth;
2299 if ((curveType == curve_type_nonlinear && depth == 0) ||
2300 (curveType == curve_type_special && depth == 4)) {
2301 curveType = curve_type_nonlinear;
2304 return GetVelocityTable(curveType, depth, 0);
2307 double* DimensionRegion::GetCutoffVelocityTable(curve_type_t vcfVelocityCurve,
2308 uint8_t vcfVelocityDynamicRange,
2309 uint8_t vcfVelocityScale,
2310 vcf_cutoff_ctrl_t vcfCutoffController)
2312 curve_type_t curveType = vcfVelocityCurve;
2313 uint8_t depth = vcfVelocityDynamicRange;
2317 if ((curveType == curve_type_nonlinear && depth == 0) ||
2318 (curveType == curve_type_special && depth == 4)) {
2319 curveType = curve_type_special;
2322 return GetVelocityTable(curveType, depth,
2323 (vcfCutoffController <= vcf_cutoff_ctrl_none2)
2324 ? vcfVelocityScale : 0);
2328 double* DimensionRegion::GetVelocityTable(curve_type_t curveType, uint8_t depth, uint8_t scaling)
2332 switch (curveType) {
2333 case curve_type_nonlinear:
2334 case curve_type_linear:
2336 printf(
"Warning: Invalid depth (0x%x) for velocity curve type (0x%x).\n", depth, curveType);
2341 case curve_type_special:
2343 printf(
"Warning: Invalid depth (0x%x) for velocity curve type 'special'.\n", depth);
2348 case curve_type_unknown:
2350 printf(
"Warning: Unknown velocity curve type (0x%x).\n", curveType);
2351 curveType = curve_type_linear;
2358 uint32_t tableKey = (curveType<<16) | (depth<<8) | scaling;
2359 if (pVelocityTables->count(tableKey)) {
2360 table = (*pVelocityTables)[tableKey];
2363 table = CreateVelocityTable(curveType, depth, scaling);
2364 (*pVelocityTables)[tableKey] = table;
2369 Region* DimensionRegion::GetParent()
const {
2379 leverage_ctrl_t DimensionRegion::DecodeLeverageController(_lev_ctrl_t EncodedController) {
2380 leverage_ctrl_t decodedcontroller;
2381 switch (EncodedController) {
2383 case _lev_ctrl_none:
2384 decodedcontroller.type = leverage_ctrl_t::type_none;
2385 decodedcontroller.controller_number = 0;
2387 case _lev_ctrl_velocity:
2388 decodedcontroller.type = leverage_ctrl_t::type_velocity;
2389 decodedcontroller.controller_number = 0;
2391 case _lev_ctrl_channelaftertouch:
2392 decodedcontroller.type = leverage_ctrl_t::type_channelaftertouch;
2393 decodedcontroller.controller_number = 0;
2397 case _lev_ctrl_modwheel:
2398 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2399 decodedcontroller.controller_number = 1;
2401 case _lev_ctrl_breath:
2402 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2403 decodedcontroller.controller_number = 2;
2405 case _lev_ctrl_foot:
2406 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2407 decodedcontroller.controller_number = 4;
2409 case _lev_ctrl_effect1:
2410 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2411 decodedcontroller.controller_number = 12;
2413 case _lev_ctrl_effect2:
2414 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2415 decodedcontroller.controller_number = 13;
2417 case _lev_ctrl_genpurpose1:
2418 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2419 decodedcontroller.controller_number = 16;
2421 case _lev_ctrl_genpurpose2:
2422 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2423 decodedcontroller.controller_number = 17;
2425 case _lev_ctrl_genpurpose3:
2426 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2427 decodedcontroller.controller_number = 18;
2429 case _lev_ctrl_genpurpose4:
2430 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2431 decodedcontroller.controller_number = 19;
2433 case _lev_ctrl_portamentotime:
2434 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2435 decodedcontroller.controller_number = 5;
2437 case _lev_ctrl_sustainpedal:
2438 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2439 decodedcontroller.controller_number = 64;
2441 case _lev_ctrl_portamento:
2442 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2443 decodedcontroller.controller_number = 65;
2445 case _lev_ctrl_sostenutopedal:
2446 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2447 decodedcontroller.controller_number = 66;
2449 case _lev_ctrl_softpedal:
2450 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2451 decodedcontroller.controller_number = 67;
2453 case _lev_ctrl_genpurpose5:
2454 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2455 decodedcontroller.controller_number = 80;
2457 case _lev_ctrl_genpurpose6:
2458 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2459 decodedcontroller.controller_number = 81;
2461 case _lev_ctrl_genpurpose7:
2462 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2463 decodedcontroller.controller_number = 82;
2465 case _lev_ctrl_genpurpose8:
2466 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2467 decodedcontroller.controller_number = 83;
2469 case _lev_ctrl_effect1depth:
2470 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2471 decodedcontroller.controller_number = 91;
2473 case _lev_ctrl_effect2depth:
2474 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2475 decodedcontroller.controller_number = 92;
2477 case _lev_ctrl_effect3depth:
2478 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2479 decodedcontroller.controller_number = 93;
2481 case _lev_ctrl_effect4depth:
2482 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2483 decodedcontroller.controller_number = 94;
2485 case _lev_ctrl_effect5depth:
2486 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2487 decodedcontroller.controller_number = 95;
2493 case _lev_ctrl_CC3_EXT:
2494 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2495 decodedcontroller.controller_number = 3;
2497 case _lev_ctrl_CC6_EXT:
2498 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2499 decodedcontroller.controller_number = 6;
2501 case _lev_ctrl_CC7_EXT:
2502 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2503 decodedcontroller.controller_number = 7;
2505 case _lev_ctrl_CC8_EXT:
2506 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2507 decodedcontroller.controller_number = 8;
2509 case _lev_ctrl_CC9_EXT:
2510 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2511 decodedcontroller.controller_number = 9;
2513 case _lev_ctrl_CC10_EXT:
2514 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2515 decodedcontroller.controller_number = 10;
2517 case _lev_ctrl_CC11_EXT:
2518 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2519 decodedcontroller.controller_number = 11;
2521 case _lev_ctrl_CC14_EXT:
2522 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2523 decodedcontroller.controller_number = 14;
2525 case _lev_ctrl_CC15_EXT:
2526 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2527 decodedcontroller.controller_number = 15;
2529 case _lev_ctrl_CC20_EXT:
2530 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2531 decodedcontroller.controller_number = 20;
2533 case _lev_ctrl_CC21_EXT:
2534 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2535 decodedcontroller.controller_number = 21;
2537 case _lev_ctrl_CC22_EXT:
2538 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2539 decodedcontroller.controller_number = 22;
2541 case _lev_ctrl_CC23_EXT:
2542 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2543 decodedcontroller.controller_number = 23;
2545 case _lev_ctrl_CC24_EXT:
2546 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2547 decodedcontroller.controller_number = 24;
2549 case _lev_ctrl_CC25_EXT:
2550 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2551 decodedcontroller.controller_number = 25;
2553 case _lev_ctrl_CC26_EXT:
2554 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2555 decodedcontroller.controller_number = 26;
2557 case _lev_ctrl_CC27_EXT:
2558 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2559 decodedcontroller.controller_number = 27;
2561 case _lev_ctrl_CC28_EXT:
2562 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2563 decodedcontroller.controller_number = 28;
2565 case _lev_ctrl_CC29_EXT:
2566 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2567 decodedcontroller.controller_number = 29;
2569 case _lev_ctrl_CC30_EXT:
2570 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2571 decodedcontroller.controller_number = 30;
2573 case _lev_ctrl_CC31_EXT:
2574 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2575 decodedcontroller.controller_number = 31;
2577 case _lev_ctrl_CC68_EXT:
2578 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2579 decodedcontroller.controller_number = 68;
2581 case _lev_ctrl_CC69_EXT:
2582 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2583 decodedcontroller.controller_number = 69;
2585 case _lev_ctrl_CC70_EXT:
2586 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2587 decodedcontroller.controller_number = 70;
2589 case _lev_ctrl_CC71_EXT:
2590 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2591 decodedcontroller.controller_number = 71;
2593 case _lev_ctrl_CC72_EXT:
2594 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2595 decodedcontroller.controller_number = 72;
2597 case _lev_ctrl_CC73_EXT:
2598 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2599 decodedcontroller.controller_number = 73;
2601 case _lev_ctrl_CC74_EXT:
2602 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2603 decodedcontroller.controller_number = 74;
2605 case _lev_ctrl_CC75_EXT:
2606 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2607 decodedcontroller.controller_number = 75;
2609 case _lev_ctrl_CC76_EXT:
2610 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2611 decodedcontroller.controller_number = 76;
2613 case _lev_ctrl_CC77_EXT:
2614 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2615 decodedcontroller.controller_number = 77;
2617 case _lev_ctrl_CC78_EXT:
2618 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2619 decodedcontroller.controller_number = 78;
2621 case _lev_ctrl_CC79_EXT:
2622 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2623 decodedcontroller.controller_number = 79;
2625 case _lev_ctrl_CC84_EXT:
2626 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2627 decodedcontroller.controller_number = 84;
2629 case _lev_ctrl_CC85_EXT:
2630 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2631 decodedcontroller.controller_number = 85;
2633 case _lev_ctrl_CC86_EXT:
2634 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2635 decodedcontroller.controller_number = 86;
2637 case _lev_ctrl_CC87_EXT:
2638 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2639 decodedcontroller.controller_number = 87;
2641 case _lev_ctrl_CC89_EXT:
2642 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2643 decodedcontroller.controller_number = 89;
2645 case _lev_ctrl_CC90_EXT:
2646 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2647 decodedcontroller.controller_number = 90;
2649 case _lev_ctrl_CC96_EXT:
2650 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2651 decodedcontroller.controller_number = 96;
2653 case _lev_ctrl_CC97_EXT:
2654 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2655 decodedcontroller.controller_number = 97;
2657 case _lev_ctrl_CC102_EXT:
2658 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2659 decodedcontroller.controller_number = 102;
2661 case _lev_ctrl_CC103_EXT:
2662 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2663 decodedcontroller.controller_number = 103;
2665 case _lev_ctrl_CC104_EXT:
2666 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2667 decodedcontroller.controller_number = 104;
2669 case _lev_ctrl_CC105_EXT:
2670 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2671 decodedcontroller.controller_number = 105;
2673 case _lev_ctrl_CC106_EXT:
2674 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2675 decodedcontroller.controller_number = 106;
2677 case _lev_ctrl_CC107_EXT:
2678 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2679 decodedcontroller.controller_number = 107;
2681 case _lev_ctrl_CC108_EXT:
2682 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2683 decodedcontroller.controller_number = 108;
2685 case _lev_ctrl_CC109_EXT:
2686 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2687 decodedcontroller.controller_number = 109;
2689 case _lev_ctrl_CC110_EXT:
2690 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2691 decodedcontroller.controller_number = 110;
2693 case _lev_ctrl_CC111_EXT:
2694 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2695 decodedcontroller.controller_number = 111;
2697 case _lev_ctrl_CC112_EXT:
2698 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2699 decodedcontroller.controller_number = 112;
2701 case _lev_ctrl_CC113_EXT:
2702 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2703 decodedcontroller.controller_number = 113;
2705 case _lev_ctrl_CC114_EXT:
2706 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2707 decodedcontroller.controller_number = 114;
2709 case _lev_ctrl_CC115_EXT:
2710 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2711 decodedcontroller.controller_number = 115;
2713 case _lev_ctrl_CC116_EXT:
2714 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2715 decodedcontroller.controller_number = 116;
2717 case _lev_ctrl_CC117_EXT:
2718 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2719 decodedcontroller.controller_number = 117;
2721 case _lev_ctrl_CC118_EXT:
2722 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2723 decodedcontroller.controller_number = 118;
2725 case _lev_ctrl_CC119_EXT:
2726 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2727 decodedcontroller.controller_number = 119;
2732 decodedcontroller.type = leverage_ctrl_t::type_none;
2733 decodedcontroller.controller_number = 0;
2734 printf(
"Warning: Unknown leverage controller type (0x%x).\n", EncodedController);
2737 return decodedcontroller;
2743 DimensionRegion::_lev_ctrl_t DimensionRegion::EncodeLeverageController(leverage_ctrl_t DecodedController) {
2744 _lev_ctrl_t encodedcontroller;
2745 switch (DecodedController.type) {
2747 case leverage_ctrl_t::type_none:
2748 encodedcontroller = _lev_ctrl_none;
2750 case leverage_ctrl_t::type_velocity:
2751 encodedcontroller = _lev_ctrl_velocity;
2753 case leverage_ctrl_t::type_channelaftertouch:
2754 encodedcontroller = _lev_ctrl_channelaftertouch;
2758 case leverage_ctrl_t::type_controlchange:
2759 switch (DecodedController.controller_number) {
2761 encodedcontroller = _lev_ctrl_modwheel;
2764 encodedcontroller = _lev_ctrl_breath;
2767 encodedcontroller = _lev_ctrl_foot;
2770 encodedcontroller = _lev_ctrl_effect1;
2773 encodedcontroller = _lev_ctrl_effect2;
2776 encodedcontroller = _lev_ctrl_genpurpose1;
2779 encodedcontroller = _lev_ctrl_genpurpose2;
2782 encodedcontroller = _lev_ctrl_genpurpose3;
2785 encodedcontroller = _lev_ctrl_genpurpose4;
2788 encodedcontroller = _lev_ctrl_portamentotime;
2791 encodedcontroller = _lev_ctrl_sustainpedal;
2794 encodedcontroller = _lev_ctrl_portamento;
2797 encodedcontroller = _lev_ctrl_sostenutopedal;
2800 encodedcontroller = _lev_ctrl_softpedal;
2803 encodedcontroller = _lev_ctrl_genpurpose5;
2806 encodedcontroller = _lev_ctrl_genpurpose6;
2809 encodedcontroller = _lev_ctrl_genpurpose7;
2812 encodedcontroller = _lev_ctrl_genpurpose8;
2815 encodedcontroller = _lev_ctrl_effect1depth;
2818 encodedcontroller = _lev_ctrl_effect2depth;
2821 encodedcontroller = _lev_ctrl_effect3depth;
2824 encodedcontroller = _lev_ctrl_effect4depth;
2827 encodedcontroller = _lev_ctrl_effect5depth;
2834 encodedcontroller = _lev_ctrl_CC3_EXT;
2837 encodedcontroller = _lev_ctrl_CC6_EXT;
2840 encodedcontroller = _lev_ctrl_CC7_EXT;
2843 encodedcontroller = _lev_ctrl_CC8_EXT;
2846 encodedcontroller = _lev_ctrl_CC9_EXT;
2849 encodedcontroller = _lev_ctrl_CC10_EXT;
2852 encodedcontroller = _lev_ctrl_CC11_EXT;
2855 encodedcontroller = _lev_ctrl_CC14_EXT;
2858 encodedcontroller = _lev_ctrl_CC15_EXT;
2861 encodedcontroller = _lev_ctrl_CC20_EXT;
2864 encodedcontroller = _lev_ctrl_CC21_EXT;
2867 encodedcontroller = _lev_ctrl_CC22_EXT;
2870 encodedcontroller = _lev_ctrl_CC23_EXT;
2873 encodedcontroller = _lev_ctrl_CC24_EXT;
2876 encodedcontroller = _lev_ctrl_CC25_EXT;
2879 encodedcontroller = _lev_ctrl_CC26_EXT;
2882 encodedcontroller = _lev_ctrl_CC27_EXT;
2885 encodedcontroller = _lev_ctrl_CC28_EXT;
2888 encodedcontroller = _lev_ctrl_CC29_EXT;
2891 encodedcontroller = _lev_ctrl_CC30_EXT;
2894 encodedcontroller = _lev_ctrl_CC31_EXT;
2897 encodedcontroller = _lev_ctrl_CC68_EXT;
2900 encodedcontroller = _lev_ctrl_CC69_EXT;
2903 encodedcontroller = _lev_ctrl_CC70_EXT;
2906 encodedcontroller = _lev_ctrl_CC71_EXT;
2909 encodedcontroller = _lev_ctrl_CC72_EXT;
2912 encodedcontroller = _lev_ctrl_CC73_EXT;
2915 encodedcontroller = _lev_ctrl_CC74_EXT;
2918 encodedcontroller = _lev_ctrl_CC75_EXT;
2921 encodedcontroller = _lev_ctrl_CC76_EXT;
2924 encodedcontroller = _lev_ctrl_CC77_EXT;
2927 encodedcontroller = _lev_ctrl_CC78_EXT;
2930 encodedcontroller = _lev_ctrl_CC79_EXT;
2933 encodedcontroller = _lev_ctrl_CC84_EXT;
2936 encodedcontroller = _lev_ctrl_CC85_EXT;
2939 encodedcontroller = _lev_ctrl_CC86_EXT;
2942 encodedcontroller = _lev_ctrl_CC87_EXT;
2945 encodedcontroller = _lev_ctrl_CC89_EXT;
2948 encodedcontroller = _lev_ctrl_CC90_EXT;
2951 encodedcontroller = _lev_ctrl_CC96_EXT;
2954 encodedcontroller = _lev_ctrl_CC97_EXT;
2957 encodedcontroller = _lev_ctrl_CC102_EXT;
2960 encodedcontroller = _lev_ctrl_CC103_EXT;
2963 encodedcontroller = _lev_ctrl_CC104_EXT;
2966 encodedcontroller = _lev_ctrl_CC105_EXT;
2969 encodedcontroller = _lev_ctrl_CC106_EXT;
2972 encodedcontroller = _lev_ctrl_CC107_EXT;
2975 encodedcontroller = _lev_ctrl_CC108_EXT;
2978 encodedcontroller = _lev_ctrl_CC109_EXT;
2981 encodedcontroller = _lev_ctrl_CC110_EXT;
2984 encodedcontroller = _lev_ctrl_CC111_EXT;
2987 encodedcontroller = _lev_ctrl_CC112_EXT;
2990 encodedcontroller = _lev_ctrl_CC113_EXT;
2993 encodedcontroller = _lev_ctrl_CC114_EXT;
2996 encodedcontroller = _lev_ctrl_CC115_EXT;
2999 encodedcontroller = _lev_ctrl_CC116_EXT;
3002 encodedcontroller = _lev_ctrl_CC117_EXT;
3005 encodedcontroller = _lev_ctrl_CC118_EXT;
3008 encodedcontroller = _lev_ctrl_CC119_EXT;
3012 throw gig::Exception(
"leverage controller number is not supported by the gig format");
3016 throw gig::Exception(
"Unknown leverage controller type.");
3018 return encodedcontroller;
3021 DimensionRegion::~DimensionRegion() {
3025 VelocityTableMap::iterator iter;
3026 for (iter = pVelocityTables->begin(); iter != pVelocityTables->end(); iter++) {
3027 double* pTable = iter->second;
3028 if (pTable)
delete[] pTable;
3030 pVelocityTables->clear();
3031 delete pVelocityTables;
3032 pVelocityTables = NULL;
3034 if (VelocityTable)
delete[] VelocityTable;
3048 double DimensionRegion::GetVelocityAttenuation(uint8_t MIDIKeyVelocity) {
3049 return pVelocityAttenuationTable[MIDIKeyVelocity];
3052 double DimensionRegion::GetVelocityRelease(uint8_t MIDIKeyVelocity) {
3053 return pVelocityReleaseTable[MIDIKeyVelocity];
3056 double DimensionRegion::GetVelocityCutoff(uint8_t MIDIKeyVelocity) {
3057 return pVelocityCutoffTable[MIDIKeyVelocity];
3064 void DimensionRegion::SetVelocityResponseCurve(curve_type_t curve) {
3065 pVelocityAttenuationTable =
3067 curve, VelocityResponseDepth, VelocityResponseCurveScaling
3069 VelocityResponseCurve = curve;
3076 void DimensionRegion::SetVelocityResponseDepth(uint8_t depth) {
3077 pVelocityAttenuationTable =
3079 VelocityResponseCurve, depth, VelocityResponseCurveScaling
3081 VelocityResponseDepth = depth;
3088 void DimensionRegion::SetVelocityResponseCurveScaling(uint8_t scaling) {
3089 pVelocityAttenuationTable =
3091 VelocityResponseCurve, VelocityResponseDepth, scaling
3093 VelocityResponseCurveScaling = scaling;
3100 void DimensionRegion::SetReleaseVelocityResponseCurve(curve_type_t curve) {
3101 pVelocityReleaseTable = GetReleaseVelocityTable(curve, ReleaseVelocityResponseDepth);
3102 ReleaseVelocityResponseCurve = curve;
3109 void DimensionRegion::SetReleaseVelocityResponseDepth(uint8_t depth) {
3110 pVelocityReleaseTable = GetReleaseVelocityTable(ReleaseVelocityResponseCurve, depth);
3111 ReleaseVelocityResponseDepth = depth;
3118 void DimensionRegion::SetVCFCutoffController(vcf_cutoff_ctrl_t controller) {
3119 pVelocityCutoffTable = GetCutoffVelocityTable(VCFVelocityCurve, VCFVelocityDynamicRange, VCFVelocityScale, controller);
3120 VCFCutoffController = controller;
3127 void DimensionRegion::SetVCFVelocityCurve(curve_type_t curve) {
3128 pVelocityCutoffTable = GetCutoffVelocityTable(curve, VCFVelocityDynamicRange, VCFVelocityScale, VCFCutoffController);
3129 VCFVelocityCurve = curve;
3136 void DimensionRegion::SetVCFVelocityDynamicRange(uint8_t range) {
3137 pVelocityCutoffTable = GetCutoffVelocityTable(VCFVelocityCurve, range, VCFVelocityScale, VCFCutoffController);
3138 VCFVelocityDynamicRange = range;
3145 void DimensionRegion::SetVCFVelocityScale(uint8_t scaling) {
3146 pVelocityCutoffTable = GetCutoffVelocityTable(VCFVelocityCurve, VCFVelocityDynamicRange, scaling, VCFCutoffController);
3147 VCFVelocityScale = scaling;
3150 double* DimensionRegion::CreateVelocityTable(curve_type_t curveType, uint8_t depth, uint8_t scaling) {
3155 const int lin0[] = { 1, 1, 127, 127 };
3156 const int lin1[] = { 1, 21, 127, 127 };
3157 const int lin2[] = { 1, 45, 127, 127 };
3158 const int lin3[] = { 1, 74, 127, 127 };
3159 const int lin4[] = { 1, 127, 127, 127 };
3162 const int non0[] = { 1, 4, 24, 5, 57, 17, 92, 57, 122, 127, 127, 127 };
3163 const int non1[] = { 1, 4, 46, 9, 93, 56, 118, 106, 123, 127,
3165 const int non2[] = { 1, 4, 46, 9, 57, 20, 102, 107, 107, 127,
3167 const int non3[] = { 1, 15, 10, 19, 67, 73, 80, 80, 90, 98, 98, 127,
3169 const int non4[] = { 1, 25, 33, 57, 82, 81, 92, 127, 127, 127 };
3172 const int spe0[] = { 1, 2, 76, 10, 90, 15, 95, 20, 99, 28, 103, 44,
3173 113, 127, 127, 127 };
3174 const int spe1[] = { 1, 2, 27, 5, 67, 18, 89, 29, 95, 35, 107, 67,
3175 118, 127, 127, 127 };
3176 const int spe2[] = { 1, 1, 33, 1, 53, 5, 61, 13, 69, 32, 79, 74,
3177 85, 90, 91, 127, 127, 127 };
3178 const int spe3[] = { 1, 32, 28, 35, 66, 48, 89, 59, 95, 65, 99, 73,
3179 117, 127, 127, 127 };
3180 const int spe4[] = { 1, 4, 23, 5, 49, 13, 57, 17, 92, 57, 122, 127,
3184 const int spe5[] = { 1, 2, 30, 5, 60, 19, 77, 70, 83, 85, 88, 106,
3185 91, 127, 127, 127 };
3187 const int*
const curves[] = { non0, non1, non2, non3, non4,
3188 lin0, lin1, lin2, lin3, lin4,
3189 spe0, spe1, spe2, spe3, spe4, spe5 };
3191 double*
const table =
new double[128];
3193 const int* curve = curves[curveType * 5 + depth];
3194 const int s = scaling == 0 ? 20 : scaling;
3197 for (
int x = 1 ; x < 128 ; x++) {
3199 if (x > curve[2]) curve += 2;
3200 double y = curve[1] + (x - curve[0]) *
3201 (
double(curve[3] - curve[1]) / (curve[2] - curve[0]));
3206 if (s < 20 && y >= 0.5)
3207 y = y / ((2 - 40.0 / s) * y + 40.0 / s - 1);
3221 Region::Region(Instrument* pInstrument,
RIFF::List* rgnList) :
DLS::Region((
DLS::Instrument*) pInstrument, rgnList) {
3224 for (
int i = 0; i < 256; i++) {
3225 pDimensionRegions[i] = NULL;
3228 File* file = (File*) GetParent()->GetParent();
3229 int dimensionBits = (file->pVersion && file->pVersion->major > 2) ? 8 : 5;
3233 if (!file->GetAutoLoad())
return;
3235 LoadDimensionRegions(rgnList);
3240 for (
int i = 0; i < dimensionBits; i++) {
3241 dimension_t dimension =
static_cast<dimension_t
>(_3lnk->
ReadUint8());
3246 if (dimension == dimension_none) {
3247 pDimensionDefinitions[i].dimension = dimension_none;
3248 pDimensionDefinitions[i].bits = 0;
3249 pDimensionDefinitions[i].zones = 0;
3250 pDimensionDefinitions[i].split_type = split_type_bit;
3251 pDimensionDefinitions[i].zone_size = 0;
3254 pDimensionDefinitions[i].dimension = dimension;
3255 pDimensionDefinitions[i].bits = bits;
3256 pDimensionDefinitions[i].zones = zones ? zones : 0x01 << bits;
3257 pDimensionDefinitions[i].split_type = __resolveSplitType(dimension);
3258 pDimensionDefinitions[i].zone_size = __resolveZoneSize(pDimensionDefinitions[i]);
3262 if (dimension == dimension_layer) Layers = pDimensionDefinitions[i].zones;
3264 _3lnk->
SetPos(3, RIFF::stream_curpos);
3266 for (
int i = dimensionBits ; i < 8 ; i++) pDimensionDefinitions[i].bits = 0;
3270 UpdateVelocityTable();
3273 if (file->pVersion && file->pVersion->major > 2)
3279 if (file->GetAutoLoad()) {
3280 for (uint i = 0; i < DimensionRegions; i++) {
3281 uint32_t wavepoolindex = _3lnk->
ReadUint32();
3282 if (file->pWavePoolTable && pDimensionRegions[i])
3283 pDimensionRegions[i]->pSample = GetSampleFromWavePool(wavepoolindex);
3288 DimensionRegions = 0;
3289 for (
int i = 0 ; i < 8 ; i++) {
3290 pDimensionDefinitions[i].dimension = dimension_none;
3291 pDimensionDefinitions[i].bits = 0;
3292 pDimensionDefinitions[i].zones = 0;
3297 if (!DimensionRegions) {
3299 if (!_3prg) _3prg = rgnList->
AddSubList(LIST_TYPE_3PRG);
3301 pDimensionRegions[0] =
new DimensionRegion(
this, _3ewl);
3302 DimensionRegions = 1;
3321 pSample = pDimensionRegions[0]->pSample;
3327 for (
int i = 0; i < DimensionRegions; i++) {
3328 pDimensionRegions[i]->UpdateChunks(pProgress);
3331 File* pFile = (File*) GetParent()->GetParent();
3332 bool versiongt2 = pFile->pVersion && pFile->pVersion->major > 2;
3333 const int iMaxDimensions = versiongt2 ? 8 : 5;
3334 const int iMaxDimensionRegions = versiongt2 ? 256 : 32;
3339 const int _3lnkChunkSize = versiongt2 ? 1092 : 172;
3340 _3lnk = pCkRegion->
AddSubChunk(CHUNK_ID_3LNK, _3lnkChunkSize);
3349 store32(&pData[0], DimensionRegions);
3351 for (
int i = 0; i < iMaxDimensions; i++) {
3352 pData[4 + i * 8] = (uint8_t) pDimensionDefinitions[i].dimension;
3353 pData[5 + i * 8] = pDimensionDefinitions[i].bits;
3354 pData[6 + i * 8] = pDimensionDefinitions[i].dimension == dimension_none ? 0 : shift;
3355 pData[7 + i * 8] = (1 << (shift + pDimensionDefinitions[i].bits)) - (1 << shift);
3356 pData[8 + i * 8] = pDimensionDefinitions[i].zones;
3359 shift += pDimensionDefinitions[i].bits;
3363 const int iWavePoolOffset = versiongt2 ? 68 : 44;
3364 for (uint i = 0; i < iMaxDimensionRegions; i++) {
3365 int iWaveIndex = -1;
3366 if (i < DimensionRegions) {
3367 if (!pFile->pSamples || !pFile->pSamples->size())
throw gig::Exception(
"Could not update gig::Region, there are no samples");
3368 File::SampleList::iterator iter = pFile->pSamples->begin();
3369 File::SampleList::iterator end = pFile->pSamples->end();
3370 for (
int index = 0; iter != end; ++iter, ++index) {
3371 if (*iter == pDimensionRegions[i]->pSample) {
3377 store32(&pData[iWavePoolOffset + i * 4], iWaveIndex);
3381 void Region::LoadDimensionRegions(
RIFF::List* rgn) {
3384 int dimensionRegionNr = 0;
3388 pDimensionRegions[dimensionRegionNr] =
new DimensionRegion(
this, _3ewl);
3389 dimensionRegionNr++;
3393 if (dimensionRegionNr == 0)
throw gig::Exception(
"No dimension region found.");
3401 ((gig::Instrument*)GetParent())->UpdateRegionKeyTable();
3404 void Region::UpdateVelocityTable() {
3407 for (
int i = 0 ; i < Dimensions ; i++) {
3408 if (pDimensionDefinitions[i].dimension == gig::dimension_velocity) {
3413 if (veldim == -1)
return;
3416 for (
int i = 0 ; i < veldim ; i++) step <<= pDimensionDefinitions[i].bits;
3417 int skipveldim = (step << pDimensionDefinitions[veldim].bits) - step;
3421 for (
int i = 0 ; i < DimensionRegions ; i++) {
3422 const int end = i + step * pDimensionDefinitions[veldim].zones;
3425 if (pDimensionRegions[i]->DimensionUpperLimits[veldim] ||
3426 pDimensionRegions[i]->VelocityUpperLimit) {
3428 uint8_t* table = pDimensionRegions[i]->VelocityTable;
3430 table =
new uint8_t[128];
3431 pDimensionRegions[i]->VelocityTable = table;
3434 int velocityZone = 0;
3435 if (pDimensionRegions[i]->DimensionUpperLimits[veldim]) {
3436 for (
int k = i ; k < end ; k += step) {
3437 DimensionRegion *d = pDimensionRegions[k];
3438 for (; tableidx <= d->DimensionUpperLimits[veldim] ; tableidx++) table[tableidx] = velocityZone;
3442 for (
int k = i ; k < end ; k += step) {
3443 DimensionRegion *d = pDimensionRegions[k];
3444 for (; tableidx <= d->VelocityUpperLimit ; tableidx++) table[tableidx] = velocityZone;
3449 if (pDimensionRegions[i]->VelocityTable) {
3450 delete[] pDimensionRegions[i]->VelocityTable;
3451 pDimensionRegions[i]->VelocityTable = 0;
3458 for (j = 0 ; j < Dimensions ; j++) {
3459 if (j == veldim) i += skipveldim;
3462 if (dim[j] < pDimensionDefinitions[j].zones)
break;
3466 i += ((1 << pDimensionDefinitions[j].bits) -
3467 pDimensionDefinitions[j].zones) << shift;
3470 shift += pDimensionDefinitions[j].bits;
3472 if (j == Dimensions)
break;
3491 void Region::AddDimension(dimension_def_t* pDimDef) {
3493 if (pDimDef->zones < 2)
3494 throw gig::Exception(
"Could not add new dimension, amount of requested zones must always be at least two");
3495 if (pDimDef->bits < 1)
3496 throw gig::Exception(
"Could not add new dimension, amount of requested requested zone bits must always be at least one");
3497 if (pDimDef->dimension == dimension_samplechannel) {
3498 if (pDimDef->zones != 2)
3499 throw gig::Exception(
"Could not add new 'sample channel' dimensions, the requested amount of zones must always be 2 for this dimension type");
3500 if (pDimDef->bits != 1)
3501 throw gig::Exception(
"Could not add new 'sample channel' dimensions, the requested amount of zone bits must always be 1 for this dimension type");
3505 File* file = (File*) GetParent()->GetParent();
3506 const int iMaxDimensions = (file->pVersion && file->pVersion->major > 2) ? 8 : 5;
3507 if (Dimensions >= iMaxDimensions)
3508 throw gig::Exception(
"Could not add new dimension, max. amount of " + ToString(iMaxDimensions) +
" dimensions already reached");
3510 int iCurrentBits = 0;
3511 for (
int i = 0; i < Dimensions; i++)
3512 iCurrentBits += pDimensionDefinitions[i].bits;
3513 if (iCurrentBits >= iMaxDimensions)
3514 throw gig::Exception(
"Could not add new dimension, max. amount of " + ToString(iMaxDimensions) +
" dimension bits already reached");
3515 const int iNewBits = iCurrentBits + pDimDef->bits;
3516 if (iNewBits > iMaxDimensions)
3517 throw gig::Exception(
"Could not add new dimension, new dimension would exceed max. amount of " + ToString(iMaxDimensions) +
" dimension bits");
3519 for (
int i = 0; i < Dimensions; i++)
3520 if (pDimensionDefinitions[i].dimension == pDimDef->dimension)
3521 throw gig::Exception(
"Could not add new dimension, there is already a dimension of the same type");
3526 int pos = pDimDef->dimension == dimension_samplechannel ? 0 : Dimensions;
3528 for (
int i = 0 ; i < pos ; i++)
3529 bitpos += pDimensionDefinitions[i].bits;
3532 for (
int i = Dimensions ; i > pos ; i--) pDimensionDefinitions[i] = pDimensionDefinitions[i - 1];
3533 for (
int i = 0 ; i < (1 << iCurrentBits) ; i++) {
3534 for (
int j = Dimensions ; j > pos ; j--) {
3535 pDimensionRegions[i]->DimensionUpperLimits[j] =
3536 pDimensionRegions[i]->DimensionUpperLimits[j - 1];
3541 pDimensionDefinitions[pos] = *pDimDef;
3544 pDimensionDefinitions[pos].split_type =
3545 __resolveSplitType(pDimensionDefinitions[pos].dimension);
3546 pDimensionDefinitions[pos].zone_size =
3547 __resolveZoneSize(pDimensionDefinitions[pos]);
3554 for (
int i = (1 << iCurrentBits) - (1 << bitpos) ; i >= 0 ; i -= (1 << bitpos)) {
3555 for (
int k = 0 ; k < (1 << bitpos) ; k++) {
3556 pDimensionRegions[(i << pDimDef->bits) + k] = pDimensionRegions[i + k];
3558 for (
int j = 1 ; j < (1 << pDimDef->bits) ; j++) {
3559 for (
int k = 0 ; k < (1 << bitpos) ; k++) {
3561 if (moveTo) _3prg->
MoveSubChunk(pNewDimRgnListChunk, moveTo);
3564 pDimensionRegions[(i << pDimDef->bits) + (j << bitpos) + k] =
3565 new DimensionRegion(pNewDimRgnListChunk, *pDimensionRegions[i + k]);
3570 moveTo = pDimensionRegions[i]->pParentList;
3574 int mask = (1 << bitpos) - 1;
3575 for (
int z = 0 ; z < pDimDef->zones ; z++) {
3576 uint8_t upperLimit = uint8_t((z + 1) * 128.0 / pDimDef->zones - 1);
3577 for (
int i = 0 ; i < 1 << iCurrentBits ; i++) {
3578 pDimensionRegions[((i & ~mask) << pDimDef->bits) |
3580 (i & mask)]->DimensionUpperLimits[pos] = upperLimit;
3587 if (pDimDef->dimension == dimension_layer) Layers = pDimDef->zones;
3589 UpdateVelocityTable();
3603 void Region::DeleteDimension(dimension_def_t* pDimDef) {
3605 int iDimensionNr = -1;
3606 for (
int i = 0; i < Dimensions; i++) {
3607 if (&pDimensionDefinitions[i] == pDimDef) {
3612 if (iDimensionNr < 0)
throw gig::Exception(
"Invalid dimension_def_t pointer");
3616 for (
int i = 0; i < iDimensionNr; i++)
3617 iLowerBits += pDimensionDefinitions[i].bits;
3621 for (
int i = iDimensionNr + 1; i < Dimensions; i++)
3622 iUpperBits += pDimensionDefinitions[i].bits;
3628 for (
int iUpperBit = 0; iUpperBit < 1 << iUpperBits; iUpperBit++) {
3629 for (
int iObsoleteBit = 1; iObsoleteBit < 1 << pDimensionDefinitions[iDimensionNr].bits; iObsoleteBit++) {
3630 for (
int iLowerBit = 0; iLowerBit < 1 << iLowerBits; iLowerBit++) {
3631 int iToDelete = iUpperBit << (pDimensionDefinitions[iDimensionNr].bits + iLowerBits) |
3632 iObsoleteBit << iLowerBits |
3635 _3prg->
DeleteSubChunk(pDimensionRegions[iToDelete]->pParentList);
3636 delete pDimensionRegions[iToDelete];
3637 pDimensionRegions[iToDelete] = NULL;
3645 for (
int iFrom = 2, iTo = 1; iFrom < 256 && iTo < 256 - 1; iTo++) {
3646 if (!pDimensionRegions[iTo]) {
3647 if (iFrom <= iTo) iFrom = iTo + 1;
3648 while (!pDimensionRegions[iFrom] && iFrom < 256) iFrom++;
3649 if (iFrom < 256 && pDimensionRegions[iFrom]) {
3650 pDimensionRegions[iTo] = pDimensionRegions[iFrom];
3651 pDimensionRegions[iFrom] = NULL;
3657 for (
int j = 0 ; j < 256 && pDimensionRegions[j] ; j++) {
3658 DimensionRegion* d = pDimensionRegions[j];
3659 for (
int i = iDimensionNr + 1; i < Dimensions; i++) {
3660 d->DimensionUpperLimits[i - 1] = d->DimensionUpperLimits[i];
3662 d->DimensionUpperLimits[Dimensions - 1] = 127;
3666 for (
int i = iDimensionNr + 1; i < Dimensions; i++) {
3667 pDimensionDefinitions[i - 1] = pDimensionDefinitions[i];
3669 pDimensionDefinitions[Dimensions - 1].dimension = dimension_none;
3670 pDimensionDefinitions[Dimensions - 1].bits = 0;
3671 pDimensionDefinitions[Dimensions - 1].zones = 0;
3676 if (pDimDef->dimension == dimension_layer) Layers = 1;
3693 void Region::DeleteDimensionZone(dimension_t type,
int zone) {
3694 dimension_def_t* oldDef = GetDimensionDefinition(type);
3696 throw gig::Exception(
"Could not delete dimension zone, no such dimension of given type");
3697 if (oldDef->zones <= 2)
3698 throw gig::Exception(
"Could not delete dimension zone, because it would end up with only one zone.");
3699 if (zone < 0 || zone >= oldDef->zones)
3700 throw gig::Exception(
"Could not delete dimension zone, requested zone index out of bounds.");
3702 const int newZoneSize = oldDef->zones - 1;
3707 gig::Region* tempRgn = NULL;
3710 Instrument* instr =
static_cast<Instrument*
>(GetParent());
3711 RIFF::List* pCkInstrument = instr->pCkInstrument;
3713 if (!lrgn) lrgn = pCkInstrument->
AddSubList(LIST_TYPE_LRGN);
3715 tempRgn =
new Region(instr, rgn);
3722 dimension_def_t newDef;
3723 for (
int i = 0; i < Dimensions; ++i) {
3724 dimension_def_t def = pDimensionDefinitions[i];
3726 if (def.dimension == type) {
3727 def.zones = newZoneSize;
3728 if ((1 << (def.bits - 1)) == def.zones) def.bits--;
3731 tempRgn->AddDimension(&def);
3736 int tempReducedDimensionIndex = -1;
3737 for (
int d = 0; d < tempRgn->Dimensions; ++d) {
3738 if (tempRgn->pDimensionDefinitions[d].dimension == type) {
3739 tempReducedDimensionIndex = d;
3745 for (
int iDst = 0; iDst < 256; ++iDst) {
3746 DimensionRegion* dstDimRgn = tempRgn->pDimensionRegions[iDst];
3747 if (!dstDimRgn)
continue;
3748 std::map<dimension_t,int> dimCase;
3749 bool isValidZone =
true;
3750 for (
int d = 0, baseBits = 0; d < tempRgn->Dimensions; ++d) {
3751 const int dstBits = tempRgn->pDimensionDefinitions[d].bits;
3752 dimCase[tempRgn->pDimensionDefinitions[d].dimension] =
3753 (iDst >> baseBits) & ((1 << dstBits) - 1);
3754 baseBits += dstBits;
3756 if (dimCase[tempRgn->pDimensionDefinitions[d].dimension] >= tempRgn->pDimensionDefinitions[d].zones) {
3757 isValidZone =
false;
3761 if (!isValidZone)
continue;
3764 const bool isLastZone = (dimCase[type] == newZoneSize - 1);
3765 if (dimCase[type] >= zone) dimCase[type]++;
3766 DimensionRegion* srcDimRgn = GetDimensionRegionByBit(dimCase);
3767 dstDimRgn->CopyAssign(srcDimRgn);
3770 if (newDef.split_type == split_type_normal && isLastZone)
3771 dstDimRgn->DimensionUpperLimits[tempReducedDimensionIndex] = 127;
3778 DeleteDimension(oldDef);
3779 AddDimension(&newDef);
3780 for (
int iSrc = 0; iSrc < 256; ++iSrc) {
3781 DimensionRegion* srcDimRgn = tempRgn->pDimensionRegions[iSrc];
3782 if (!srcDimRgn)
continue;
3783 std::map<dimension_t,int> dimCase;
3784 for (
int d = 0, baseBits = 0; d < tempRgn->Dimensions; ++d) {
3785 const int srcBits = tempRgn->pDimensionDefinitions[d].bits;
3786 dimCase[tempRgn->pDimensionDefinitions[d].dimension] =
3787 (iSrc >> baseBits) & ((1 << srcBits) - 1);
3788 baseBits += srcBits;
3792 DimensionRegion* dstDimRgn = GetDimensionRegionByBit(dimCase);
3793 if (!dstDimRgn)
continue;
3794 dstDimRgn->CopyAssign(srcDimRgn);
3800 UpdateVelocityTable();
3817 void Region::SplitDimensionZone(dimension_t type,
int zone) {
3818 dimension_def_t* oldDef = GetDimensionDefinition(type);
3820 throw gig::Exception(
"Could not split dimension zone, no such dimension of given type");
3821 if (zone < 0 || zone >= oldDef->zones)
3822 throw gig::Exception(
"Could not split dimension zone, requested zone index out of bounds.");
3824 const int newZoneSize = oldDef->zones + 1;
3829 gig::Region* tempRgn = NULL;
3832 Instrument* instr =
static_cast<Instrument*
>(GetParent());
3833 RIFF::List* pCkInstrument = instr->pCkInstrument;
3835 if (!lrgn) lrgn = pCkInstrument->
AddSubList(LIST_TYPE_LRGN);
3837 tempRgn =
new Region(instr, rgn);
3844 dimension_def_t newDef;
3845 for (
int i = 0; i < Dimensions; ++i) {
3846 dimension_def_t def = pDimensionDefinitions[i];
3848 if (def.dimension == type) {
3849 def.zones = newZoneSize;
3850 if ((1 << oldDef->bits) < newZoneSize) def.bits++;
3853 tempRgn->AddDimension(&def);
3858 int tempIncreasedDimensionIndex = -1;
3859 for (
int d = 0; d < tempRgn->Dimensions; ++d) {
3860 if (tempRgn->pDimensionDefinitions[d].dimension == type) {
3861 tempIncreasedDimensionIndex = d;
3867 for (
int iSrc = 0; iSrc < 256; ++iSrc) {
3868 DimensionRegion* srcDimRgn = pDimensionRegions[iSrc];
3869 if (!srcDimRgn)
continue;
3870 std::map<dimension_t,int> dimCase;
3871 bool isValidZone =
true;
3872 for (
int d = 0, baseBits = 0; d < Dimensions; ++d) {
3873 const int srcBits = pDimensionDefinitions[d].bits;
3874 dimCase[pDimensionDefinitions[d].dimension] =
3875 (iSrc >> baseBits) & ((1 << srcBits) - 1);
3877 if (dimCase[pDimensionDefinitions[d].dimension] >= pDimensionDefinitions[d].zones) {
3878 isValidZone =
false;
3881 baseBits += srcBits;
3883 if (!isValidZone)
continue;
3886 if (dimCase[type] > zone) dimCase[type]++;
3887 DimensionRegion* dstDimRgn = tempRgn->GetDimensionRegionByBit(dimCase);
3888 dstDimRgn->CopyAssign(srcDimRgn);
3892 if (dimCase[type] == zone) {
3894 if (newDef.split_type == split_type_normal) {
3896 dstDimRgn->DimensionUpperLimits[tempIncreasedDimensionIndex];
3899 std::map<dimension_t,int> lowerCase = dimCase;
3901 DimensionRegion* dstDimRgnLow = tempRgn->GetDimensionRegionByBit(lowerCase);
3902 low = dstDimRgnLow->DimensionUpperLimits[tempIncreasedDimensionIndex];
3904 dstDimRgn->DimensionUpperLimits[tempIncreasedDimensionIndex] = low + (high - low) / 2;
3908 dstDimRgn = tempRgn->GetDimensionRegionByBit(dimCase);
3909 dstDimRgn->CopyAssign(srcDimRgn);
3917 DeleteDimension(oldDef);
3918 AddDimension(&newDef);
3919 for (
int iSrc = 0; iSrc < 256; ++iSrc) {
3920 DimensionRegion* srcDimRgn = tempRgn->pDimensionRegions[iSrc];
3921 if (!srcDimRgn)
continue;
3922 std::map<dimension_t,int> dimCase;
3923 for (
int d = 0, baseBits = 0; d < tempRgn->Dimensions; ++d) {
3924 const int srcBits = tempRgn->pDimensionDefinitions[d].bits;
3925 dimCase[tempRgn->pDimensionDefinitions[d].dimension] =
3926 (iSrc >> baseBits) & ((1 << srcBits) - 1);
3927 baseBits += srcBits;
3931 DimensionRegion* dstDimRgn = GetDimensionRegionByBit(dimCase);
3932 if (!dstDimRgn)
continue;
3933 dstDimRgn->CopyAssign(srcDimRgn);
3939 UpdateVelocityTable();
3956 void Region::SetDimensionType(dimension_t oldType, dimension_t newType) {
3957 if (oldType == newType)
return;
3958 dimension_def_t* def = GetDimensionDefinition(oldType);
3960 throw gig::Exception(
"No dimension with provided old dimension type exists on this region");
3961 if (newType == dimension_samplechannel && def->zones != 2)
3962 throw gig::Exception(
"Cannot change to dimension type 'sample channel', because existing dimension does not have 2 zones");
3963 if (GetDimensionDefinition(newType))
3964 throw gig::Exception(
"There is already a dimension with requested new dimension type on this region");
3965 def->dimension = newType;
3966 def->split_type = __resolveSplitType(newType);
3969 DimensionRegion* Region::GetDimensionRegionByBit(
const std::map<dimension_t,int>& DimCase) {
3970 uint8_t bits[8] = {};
3971 for (std::map<dimension_t,int>::const_iterator it = DimCase.begin();
3972 it != DimCase.end(); ++it)
3974 for (
int d = 0; d < Dimensions; ++d) {
3975 if (pDimensionDefinitions[d].dimension == it->first) {
3976 bits[d] = it->second;
3977 goto nextDimCaseSlice;
3984 return GetDimensionRegionByBit(bits);
3996 dimension_def_t* Region::GetDimensionDefinition(dimension_t type) {
3997 for (
int i = 0; i < Dimensions; ++i)
3998 if (pDimensionDefinitions[i].dimension == type)
3999 return &pDimensionDefinitions[i];
4004 for (
int i = 0; i < 256; i++) {
4005 if (pDimensionRegions[i])
delete pDimensionRegions[i];
4027 DimensionRegion* Region::GetDimensionRegionByValue(
const uint DimValues[8]) {
4033 for (uint i = 0; i < Dimensions; i++) {
4034 if (pDimensionDefinitions[i].dimension == dimension_velocity) {
4039 switch (pDimensionDefinitions[i].split_type) {
4040 case split_type_normal:
4041 if (pDimensionRegions[0]->DimensionUpperLimits[i]) {
4043 for (bits = 0 ; bits < pDimensionDefinitions[i].zones ; bits++) {
4044 if (DimValues[i] <= pDimensionRegions[bits << bitpos]->DimensionUpperLimits[i])
break;
4048 bits = uint8_t(DimValues[i] / pDimensionDefinitions[i].zone_size);
4051 case split_type_bit:
4052 const uint8_t limiter_mask = (0xff << pDimensionDefinitions[i].bits) ^ 0xff;
4053 bits = DimValues[i] & limiter_mask;
4056 dimregidx |= bits << bitpos;
4058 bitpos += pDimensionDefinitions[i].bits;
4060 DimensionRegion* dimreg = pDimensionRegions[dimregidx & 255];
4061 if (!dimreg)
return NULL;
4064 if (dimreg->VelocityTable)
4065 bits = dimreg->VelocityTable[DimValues[veldim] & 127];
4067 bits = uint8_t((DimValues[veldim] & 127) / pDimensionDefinitions[veldim].zone_size);
4069 const uint8_t limiter_mask = (1 << pDimensionDefinitions[veldim].bits) - 1;
4070 dimregidx |= (bits & limiter_mask) << velbitpos;
4071 dimreg = pDimensionRegions[dimregidx & 255];
4076 int Region::GetDimensionRegionIndexByValue(
const uint DimValues[8]) {
4082 for (uint i = 0; i < Dimensions; i++) {
4083 if (pDimensionDefinitions[i].dimension == dimension_velocity) {
4088 switch (pDimensionDefinitions[i].split_type) {
4089 case split_type_normal:
4090 if (pDimensionRegions[0]->DimensionUpperLimits[i]) {
4092 for (bits = 0 ; bits < pDimensionDefinitions[i].zones ; bits++) {
4093 if (DimValues[i] <= pDimensionRegions[bits << bitpos]->DimensionUpperLimits[i])
break;
4097 bits = uint8_t(DimValues[i] / pDimensionDefinitions[i].zone_size);
4100 case split_type_bit:
4101 const uint8_t limiter_mask = (0xff << pDimensionDefinitions[i].bits) ^ 0xff;
4102 bits = DimValues[i] & limiter_mask;
4105 dimregidx |= bits << bitpos;
4107 bitpos += pDimensionDefinitions[i].bits;
4110 DimensionRegion* dimreg = pDimensionRegions[dimregidx];
4111 if (!dimreg)
return -1;
4114 if (dimreg->VelocityTable)
4115 bits = dimreg->VelocityTable[DimValues[veldim] & 127];
4117 bits = uint8_t((DimValues[veldim] & 127) / pDimensionDefinitions[veldim].zone_size);
4119 const uint8_t limiter_mask = (1 << pDimensionDefinitions[veldim].bits) - 1;
4120 dimregidx |= (bits & limiter_mask) << velbitpos;
4136 DimensionRegion* Region::GetDimensionRegionByBit(
const uint8_t DimBits[8]) {
4137 return pDimensionRegions[((((((DimBits[7] << pDimensionDefinitions[6].bits | DimBits[6])
4138 << pDimensionDefinitions[5].bits | DimBits[5])
4139 << pDimensionDefinitions[4].bits | DimBits[4])
4140 << pDimensionDefinitions[3].bits | DimBits[3])
4141 << pDimensionDefinitions[2].bits | DimBits[2])
4142 << pDimensionDefinitions[1].bits | DimBits[1])
4143 << pDimensionDefinitions[0].bits | DimBits[0]];
4155 Sample* Region::GetSample() {
4156 if (pSample)
return static_cast<gig::Sample*
>(pSample);
4157 else return static_cast<gig::Sample*
>(pSample = GetSampleFromWavePool(WavePoolTableIndex));
4160 Sample* Region::GetSampleFromWavePool(
unsigned int WavePoolTableIndex, progress_t* pProgress) {
4161 if ((int32_t)WavePoolTableIndex == -1)
return NULL;
4162 File* file = (File*) GetParent()->GetParent();
4163 if (!file->pWavePoolTable)
return NULL;
4164 if (WavePoolTableIndex + 1 > file->WavePoolCount)
return NULL;
4166 if (file->pRIFF->IsNew() || (file->pRIFF->GetCurrentFileSize() >> 31)) {
4168 uint64_t soughtoffset =
4169 uint64_t(file->pWavePoolTable[WavePoolTableIndex]) |
4170 uint64_t(file->pWavePoolTableHi[WavePoolTableIndex]) << 32;
4171 Sample* sample = file->GetFirstSample(pProgress);
4173 if (sample->ullWavePoolOffset == soughtoffset)
4174 return static_cast<gig::Sample*
>(sample);
4175 sample = file->GetNextSample();
4179 file_offset_t soughtoffset = file->pWavePoolTable[WavePoolTableIndex];
4180 file_offset_t soughtfileno = file->pWavePoolTableHi[WavePoolTableIndex];
4181 Sample* sample = file->GetFirstSample(pProgress);
4183 if (sample->ullWavePoolOffset == soughtoffset &&
4184 sample->FileNo == soughtfileno)
return static_cast<gig::Sample*
>(sample);
4185 sample = file->GetNextSample();
4211 void Region::CopyAssign(
const Region* orig,
const std::map<Sample*,Sample*>* mSamples) {
4215 if (mSamples && mSamples->count((gig::Sample*)orig->pSample)) {
4216 pSample = mSamples->find((gig::Sample*)orig->pSample)->second;
4220 for (
int i = Dimensions - 1; i >= 0; --i) {
4221 DeleteDimension(&pDimensionDefinitions[i]);
4224 for (
int i = 0; i < orig->Dimensions; i++) {
4227 dimension_def_t def = orig->pDimensionDefinitions[i];
4230 for (
int i = 0; i < 256; i++) {
4231 if (pDimensionRegions[i] && orig->pDimensionRegions[i]) {
4232 pDimensionRegions[i]->CopyAssign(
4233 orig->pDimensionRegions[i],
4238 Layers = orig->Layers;
4245 MidiRuleCtrlTrigger::MidiRuleCtrlTrigger(
RIFF::Chunk* _3ewg) {
4251 for (
int i = 0 ; i < Triggers ; i++) {
4252 pTriggers[i].TriggerPoint = _3ewg->
ReadUint8();
4253 pTriggers[i].Descending = _3ewg->
ReadUint8();
4254 pTriggers[i].VelSensitivity = _3ewg->
ReadUint8();
4256 pTriggers[i].NoteOff = _3ewg->
ReadUint8();
4257 pTriggers[i].Velocity = _3ewg->
ReadUint8();
4258 pTriggers[i].OverridePedal = _3ewg->
ReadUint8();
4263 MidiRuleCtrlTrigger::MidiRuleCtrlTrigger() :
4264 ControllerNumber(0),
4268 void MidiRuleCtrlTrigger::UpdateChunks(uint8_t* pData)
const {
4271 pData[36] = Triggers;
4272 pData[40] = ControllerNumber;
4273 for (
int i = 0 ; i < Triggers ; i++) {
4274 pData[46 + i * 8] = pTriggers[i].TriggerPoint;
4275 pData[47 + i * 8] = pTriggers[i].Descending;
4276 pData[48 + i * 8] = pTriggers[i].VelSensitivity;
4277 pData[49 + i * 8] = pTriggers[i].Key;
4278 pData[50 + i * 8] = pTriggers[i].NoteOff;
4279 pData[51 + i * 8] = pTriggers[i].Velocity;
4280 pData[52 + i * 8] = pTriggers[i].OverridePedal;
4284 MidiRuleLegato::MidiRuleLegato(
RIFF::Chunk* _3ewg) {
4288 BypassUseController = _3ewg->
ReadUint8();
4303 MidiRuleLegato::MidiRuleLegato() :
4305 BypassUseController(false),
4307 BypassController(1),
4310 ReleaseTriggerKey(0),
4314 KeyRange.low = KeyRange.high = 0;
4317 void MidiRuleLegato::UpdateChunks(uint8_t* pData)
const {
4320 pData[36] = LegatoSamples;
4321 pData[40] = BypassUseController;
4322 pData[41] = BypassKey;
4323 pData[42] = BypassController;
4324 store16(&pData[43], ThresholdTime);
4325 store16(&pData[47], ReleaseTime);
4326 pData[51] = KeyRange.low;
4327 pData[52] = KeyRange.high;
4328 pData[64] = ReleaseTriggerKey;
4329 pData[65] = AltSustain1Key;
4330 pData[66] = AltSustain2Key;
4333 MidiRuleAlternator::MidiRuleAlternator(
RIFF::Chunk* _3ewg) {
4337 Polyphonic = flags & 8;
4338 Chained = flags & 4;
4339 Selector = (flags & 2) ? selector_controller :
4340 (flags & 1) ? selector_key_switch : selector_none;
4346 KeySwitchRange.low = _3ewg->
ReadUint8();
4347 KeySwitchRange.high = _3ewg->
ReadUint8();
4352 int n = std::min(
int(Articulations), 32);
4353 for (
int i = 0 ; i < n ; i++) {
4357 n = std::min(
int(Patterns), 32);
4358 for (
int i = 0 ; i < n ; i++) {
4361 _3ewg->
Read(&pPatterns[i][0], 1, 32);
4365 MidiRuleAlternator::MidiRuleAlternator() :
4368 Selector(selector_none),
4373 PlayRange.low = PlayRange.high = 0;
4374 KeySwitchRange.low = KeySwitchRange.high = 0;
4377 void MidiRuleAlternator::UpdateChunks(uint8_t* pData)
const {
4380 pData[36] = Articulations;
4381 pData[37] = (Polyphonic ? 8 : 0) | (Chained ? 4 : 0) |
4382 (Selector == selector_controller ? 2 :
4383 (Selector == selector_key_switch ? 1 : 0));
4384 pData[38] = Patterns;
4386 pData[43] = KeySwitchRange.low;
4387 pData[44] = KeySwitchRange.high;
4388 pData[45] = Controller;
4389 pData[46] = PlayRange.low;
4390 pData[47] = PlayRange.high;
4392 char* str =
reinterpret_cast<char*
>(pData);
4394 int n = std::min(
int(Articulations), 32);
4395 for (
int i = 0 ; i < n ; i++, pos += 32) {
4396 strncpy(&str[pos], pArticulations[i].c_str(), 32);
4400 n = std::min(
int(Patterns), 32);
4401 for (
int i = 0 ; i < n ; i++, pos += 49) {
4402 strncpy(&str[pos], pPatterns[i].Name.c_str(), 16);
4403 pData[pos + 16] = pPatterns[i].Size;
4404 memcpy(&pData[pos + 16], &(pPatterns[i][0]), 32);
4411 Script::Script(ScriptGroup* group,
RIFF::Chunk* ckScri) {
4417 Compression = (Compression_t) ckScri->
ReadUint32();
4418 Encoding = (Encoding_t) ckScri->
ReadUint32();
4419 Language = (Language_t) ckScri->
ReadUint32();
4420 Bypass = (Language_t) ckScri->
ReadUint32() & 1;
4423 Name.resize(nameSize,
' ');
4424 for (
int i = 0; i < nameSize; ++i)
4427 ckScri->
SetPos(
sizeof(int32_t) + headerSize);
4429 uint32_t scriptSize = uint32_t(ckScri->
GetSize() - ckScri->
GetPos());
4430 data.resize(scriptSize);
4431 for (
int i = 0; i < scriptSize; ++i)
4434 Compression = COMPRESSION_NONE;
4435 Encoding = ENCODING_ASCII;
4436 Language = LANGUAGE_NKSP;
4439 Name =
"Unnamed Script";
4449 String Script::GetScriptAsText() {
4451 s.resize(data.size(),
' ');
4452 memcpy(&s[0], &data[0], data.size());
4462 void Script::SetScriptAsText(
const String& text) {
4463 data.resize(text.size());
4464 memcpy(&data[0], &text[0], text.size());
4476 void Script::UpdateChunks(progress_t* pProgress) {
4479 __calculateCRC(&data[0], data.size(), crc);
4483 if (!pChunk) pChunk = pGroup->pList->AddSubChunk(CHUNK_ID_SCRI, chunkSize);
4484 else pChunk->Resize(chunkSize);
4486 uint8_t* pData = (uint8_t*) pChunk->LoadChunkData();
4488 store32(&pData[pos], uint32_t(6*
sizeof(int32_t) + Name.size()));
4489 pos +=
sizeof(int32_t);
4490 store32(&pData[pos], Compression);
4491 pos +=
sizeof(int32_t);
4492 store32(&pData[pos], Encoding);
4493 pos +=
sizeof(int32_t);
4494 store32(&pData[pos], Language);
4495 pos +=
sizeof(int32_t);
4496 store32(&pData[pos], Bypass ? 1 : 0);
4497 pos +=
sizeof(int32_t);
4498 store32(&pData[pos], crc);
4499 pos +=
sizeof(int32_t);
4500 store32(&pData[pos], (uint32_t) Name.size());
4501 pos +=
sizeof(int32_t);
4502 for (
int i = 0; i < Name.size(); ++i, ++pos)
4503 pData[pos] = Name[i];
4504 for (
int i = 0; i < data.size(); ++i, ++pos)
4505 pData[pos] = data[i];
4514 void Script::SetGroup(ScriptGroup* pGroup) {
4515 if (this->pGroup == pGroup)
return;
4517 pChunk->GetParent()->MoveSubChunk(pChunk, pGroup->pList);
4518 this->pGroup = pGroup;
4527 ScriptGroup* Script::GetGroup()
const {
4538 void Script::CopyAssign(
const Script* orig) {
4540 Compression = orig->Compression;
4541 Encoding = orig->Encoding;
4542 Language = orig->Language;
4543 Bypass = orig->Bypass;
4547 void Script::RemoveAllScriptReferences() {
4548 File* pFile = pGroup->pFile;
4549 for (
int i = 0; pFile->GetInstrument(i); ++i) {
4550 Instrument* instr = pFile->GetInstrument(i);
4551 instr->RemoveScript(
this);
4558 ScriptGroup::ScriptGroup(File* file,
RIFF::List* lstRTIS) {
4564 ::LoadString(ckName, Name);
4566 Name =
"Default Group";
4570 ScriptGroup::~ScriptGroup() {
4572 std::list<Script*>::iterator iter = pScripts->begin();
4573 std::list<Script*>::iterator end = pScripts->end();
4574 while (iter != end) {
4591 void ScriptGroup::UpdateChunks(progress_t* pProgress) {
4594 pList = pFile->pRIFF->GetSubList(LIST_TYPE_3LS)->AddSubList(LIST_TYPE_RTIS);
4597 ::SaveString(CHUNK_ID_LSNM, NULL, pList, Name, String(
"Unnamed Group"),
true, 64);
4599 for (std::list<Script*>::iterator it = pScripts->begin();
4600 it != pScripts->end(); ++it)
4602 (*it)->UpdateChunks(pProgress);
4614 Script* ScriptGroup::GetScript(uint index) {
4615 if (!pScripts) LoadScripts();
4616 std::list<Script*>::iterator it = pScripts->begin();
4617 for (uint i = 0; it != pScripts->end(); ++i, ++it)
4618 if (i == index)
return *it;
4633 Script* ScriptGroup::AddScript() {
4634 if (!pScripts) LoadScripts();
4635 Script* pScript =
new Script(
this, NULL);
4636 pScripts->push_back(pScript);
4650 void ScriptGroup::DeleteScript(Script* pScript) {
4651 if (!pScripts) LoadScripts();
4652 std::list<Script*>::iterator iter =
4653 find(pScripts->begin(), pScripts->end(), pScript);
4654 if (iter == pScripts->end())
4655 throw gig::Exception(
"Could not delete script, could not find given script");
4656 pScripts->erase(iter);
4657 pScript->RemoveAllScriptReferences();
4658 if (pScript->pChunk)
4659 pScript->pChunk->GetParent()->DeleteSubChunk(pScript->pChunk);
4663 void ScriptGroup::LoadScripts() {
4664 if (pScripts)
return;
4665 pScripts =
new std::list<Script*>;
4668 for (
RIFF::Chunk* ck = pList->GetFirstSubChunk(); ck;
4669 ck = pList->GetNextSubChunk())
4671 if (ck->GetChunkID() == CHUNK_ID_SCRI) {
4672 pScripts->push_back(
new Script(
this, ck));
4681 static const DLS::Info::string_length_t fixedStringLengths[] = {
4682 { CHUNK_ID_INAM, 64 },
4683 { CHUNK_ID_ISFT, 12 },
4686 pInfo->SetFixedStringLengths(fixedStringLengths);
4689 for (
int i = 0; i < 128; i++) RegionKeyTable[i] = NULL;
4694 PianoReleaseMode =
false;
4695 DimensionKeyRange.low = 0;
4696 DimensionKeyRange.high = 0;
4697 pMidiRules =
new MidiRule*[3];
4698 pMidiRules[0] = NULL;
4710 uint8_t dimkeystart = _3ewg->
ReadUint8();
4711 PianoReleaseMode = dimkeystart & 0x01;
4712 DimensionKeyRange.low = dimkeystart >> 1;
4713 DimensionKeyRange.high = _3ewg->
ReadUint8();
4724 pMidiRules[i++] =
new MidiRuleCtrlTrigger(_3ewg);
4725 }
else if (id1 == 0) {
4726 pMidiRules[i++] =
new MidiRuleLegato(_3ewg);
4727 }
else if (id1 == 3) {
4728 pMidiRules[i++] =
new MidiRuleAlternator(_3ewg);
4730 pMidiRules[i++] =
new MidiRuleUnknown;
4733 else if (id1 != 0 || id2 != 0) {
4734 pMidiRules[i++] =
new MidiRuleUnknown;
4738 pMidiRules[i] = NULL;
4743 if (pFile->GetAutoLoad()) {
4744 if (!pRegions) pRegions =
new RegionList;
4750 __notify_progress(pProgress, (
float) pRegions->size() / (float) Regions);
4751 pRegions->push_back(
new Region(
this, rgn));
4756 UpdateRegionKeyTable();
4769 ckSCSL->
SetPos(headerSize);
4770 int unknownSpace = slotSize - 2*
sizeof(uint32_t);
4771 for (
int i = 0; i < slotCount; ++i) {
4772 _ScriptPooolEntry e;
4775 if (unknownSpace) ckSCSL->
SetPos(unknownSpace, RIFF::stream_curpos);
4776 scriptPoolFileOffsets.push_back(e);
4782 __notify_progress(pProgress, 1.0f);
4785 void Instrument::UpdateRegionKeyTable() {
4786 for (
int i = 0; i < 128; i++) RegionKeyTable[i] = NULL;
4787 RegionList::iterator iter = pRegions->begin();
4788 RegionList::iterator end = pRegions->end();
4789 for (; iter != end; ++iter) {
4790 gig::Region* pRegion =
static_cast<gig::Region*
>(*iter);
4791 const int low = std::max(
int(pRegion->KeyRange.low), 0);
4792 const int high = std::min(
int(pRegion->KeyRange.high), 127);
4793 for (
int iKey = low; iKey <= high; iKey++) {
4794 RegionKeyTable[iKey] = pRegion;
4800 for (
int i = 0 ; pMidiRules[i] ; i++) {
4801 delete pMidiRules[i];
4803 delete[] pMidiRules;
4804 if (pScriptRefs)
delete pScriptRefs;
4823 RegionList::iterator iter = pRegions->begin();
4824 RegionList::iterator end = pRegions->end();
4825 for (; iter != end; ++iter)
4826 (*iter)->UpdateChunks(pProgress);
4831 if (!lart) lart = pCkInstrument->
AddSubList(LIST_TYPE_LART);
4835 File* pFile = (File*) GetParent();
4838 int size = (pFile->pVersion && pFile->pVersion->major > 2) ? 16416 : 12;
4844 store16(&pData[0], EffectSend);
4845 store32(&pData[2], Attenuation);
4846 store16(&pData[6], FineTune);
4847 store16(&pData[8], PitchbendRange);
4848 const uint8_t dimkeystart = (PianoReleaseMode ? 0x01 : 0x00) |
4849 DimensionKeyRange.low << 1;
4850 pData[10] = dimkeystart;
4851 pData[11] = DimensionKeyRange.high;
4853 if (pMidiRules[0] == 0 && _3ewg->
GetSize() >= 34) {
4857 for (
int i = 0 ; pMidiRules[i] ; i++) {
4858 pMidiRules[i]->UpdateChunks(pData);
4863 if (ScriptSlotCount()) {
4869 if (!lst3LS) lst3LS = pCkInstrument->
AddSubList(LIST_TYPE_3LS);
4870 const int slotCount = (int) pScriptRefs->size();
4871 const int headerSize = 3 *
sizeof(uint32_t);
4872 const int slotSize = 2 *
sizeof(uint32_t);
4873 const int totalChunkSize = headerSize + slotCount * slotSize;
4875 if (!ckSCSL) ckSCSL = lst3LS->
AddSubChunk(CHUNK_ID_SCSL, totalChunkSize);
4876 else ckSCSL->
Resize(totalChunkSize);
4879 store32(&pData[pos], headerSize);
4880 pos +=
sizeof(uint32_t);
4881 store32(&pData[pos], slotCount);
4882 pos +=
sizeof(uint32_t);
4883 store32(&pData[pos], slotSize);
4884 pos +=
sizeof(uint32_t);
4885 for (
int i = 0; i < slotCount; ++i) {
4888 int bogusFileOffset = 0;
4889 store32(&pData[pos], bogusFileOffset);
4890 pos +=
sizeof(uint32_t);
4891 store32(&pData[pos], (*pScriptRefs)[i].bypass ? 1 : 0);
4892 pos +=
sizeof(uint32_t);
4901 void Instrument::UpdateScriptFileOffsets() {
4903 if (pScriptRefs && pScriptRefs->size() > 0) {
4906 const int slotCount = (int) pScriptRefs->size();
4907 const int headerSize = 3 *
sizeof(uint32_t);
4908 ckSCSL->
SetPos(headerSize);
4909 for (
int i = 0; i < slotCount; ++i) {
4910 uint32_t fileOffset = uint32_t(
4911 (*pScriptRefs)[i].script->pChunk->GetFilePos() -
4912 (*pScriptRefs)[i].script->pChunk->GetPos() -
4917 ckSCSL->
SetPos(
sizeof(uint32_t), RIFF::stream_curpos);
4929 Region* Instrument::GetRegion(
unsigned int Key) {
4930 if (!pRegions || pRegions->empty() || Key > 127)
return NULL;
4931 return RegionKeyTable[Key];
4948 if (!pRegions)
return NULL;
4949 RegionsIterator = pRegions->begin();
4950 return static_cast<gig::Region*
>( (RegionsIterator != pRegions->end()) ? *RegionsIterator : NULL );
4962 if (!pRegions)
return NULL;
4964 return static_cast<gig::Region*
>( (RegionsIterator != pRegions->end()) ? *RegionsIterator : NULL );
4967 Region* Instrument::AddRegion() {
4970 if (!lrgn) lrgn = pCkInstrument->
AddSubList(LIST_TYPE_LRGN);
4972 Region* pNewRegion =
new Region(
this, rgn);
4973 pRegions->push_back(pNewRegion);
4974 Regions = (uint32_t) pRegions->size();
4976 UpdateRegionKeyTable();
4981 void Instrument::DeleteRegion(Region* pRegion) {
4982 if (!pRegions)
return;
4983 DLS::Instrument::DeleteRegion((
DLS::Region*) pRegion);
4985 UpdateRegionKeyTable();
5015 void Instrument::MoveTo(Instrument* dst) {
5016 if (dst && GetParent() != dst->GetParent())
5018 "gig::Instrument::MoveTo() can only be used for moving within " 5019 "the same gig file." 5022 File* pFile = (File*) GetParent();
5026 File::InstrumentList& list = *pFile->pInstruments;
5028 File::InstrumentList::iterator itFrom =
5029 std::find(list.begin(), list.end(),
static_cast<DLS::Instrument*
>(
this));
5031 File::InstrumentList::iterator itTo =
5032 std::find(list.begin(), list.end(),
static_cast<DLS::Instrument*
>(dst));
5034 list.splice(itTo, list, itFrom);
5040 this->pCkInstrument,
5041 (
RIFF::Chunk*) ((dst) ? dst->pCkInstrument : NULL)
5055 MidiRule* Instrument::GetMidiRule(
int i) {
5056 return pMidiRules[i];
5064 MidiRuleCtrlTrigger* Instrument::AddMidiRuleCtrlTrigger() {
5065 delete pMidiRules[0];
5066 MidiRuleCtrlTrigger* r =
new MidiRuleCtrlTrigger;
5077 MidiRuleLegato* Instrument::AddMidiRuleLegato() {
5078 delete pMidiRules[0];
5079 MidiRuleLegato* r =
new MidiRuleLegato;
5090 MidiRuleAlternator* Instrument::AddMidiRuleAlternator() {
5091 delete pMidiRules[0];
5092 MidiRuleAlternator* r =
new MidiRuleAlternator;
5103 void Instrument::DeleteMidiRule(
int i) {
5104 delete pMidiRules[i];
5108 void Instrument::LoadScripts() {
5109 if (pScriptRefs)
return;
5110 pScriptRefs =
new std::vector<_ScriptPooolRef>;
5111 if (scriptPoolFileOffsets.empty())
return;
5112 File* pFile = (File*) GetParent();
5113 for (uint k = 0; k < scriptPoolFileOffsets.size(); ++k) {
5114 uint32_t soughtOffset = scriptPoolFileOffsets[k].fileOffset;
5115 for (uint i = 0; pFile->GetScriptGroup(i); ++i) {
5116 ScriptGroup* group = pFile->GetScriptGroup(i);
5117 for (uint s = 0; group->GetScript(s); ++s) {
5118 Script* script = group->GetScript(s);
5119 if (script->pChunk) {
5120 uint32_t offset = uint32_t(
5121 script->pChunk->GetFilePos() -
5122 script->pChunk->GetPos() -
5123 CHUNK_HEADER_SIZE(script->pChunk->GetFile()->GetFileOffsetSize())
5125 if (offset == soughtOffset)
5127 _ScriptPooolRef ref;
5128 ref.script = script;
5129 ref.bypass = scriptPoolFileOffsets[k].bypass;
5130 pScriptRefs->push_back(ref);
5138 scriptPoolFileOffsets.clear();
5153 Script* Instrument::GetScriptOfSlot(uint index) {
5155 if (index >= pScriptRefs->size())
return NULL;
5156 return pScriptRefs->at(index).script;
5194 void Instrument::AddScriptSlot(Script* pScript,
bool bypass) {
5196 _ScriptPooolRef ref = { pScript, bypass };
5197 pScriptRefs->push_back(ref);
5214 void Instrument::SwapScriptSlots(uint index1, uint index2) {
5216 if (index1 >= pScriptRefs->size() || index2 >= pScriptRefs->size())
5218 _ScriptPooolRef tmp = (*pScriptRefs)[index1];
5219 (*pScriptRefs)[index1] = (*pScriptRefs)[index2];
5220 (*pScriptRefs)[index2] = tmp;
5229 void Instrument::RemoveScriptSlot(uint index) {
5231 if (index >= pScriptRefs->size())
return;
5232 pScriptRefs->erase( pScriptRefs->begin() + index );
5247 void Instrument::RemoveScript(Script* pScript) {
5249 for (ssize_t i = pScriptRefs->size() - 1; i >= 0; --i) {
5250 if ((*pScriptRefs)[i].script == pScript) {
5251 pScriptRefs->erase( pScriptRefs->begin() + i );
5270 uint Instrument::ScriptSlotCount()
const {
5271 return uint(pScriptRefs ? pScriptRefs->size() : scriptPoolFileOffsets.size());
5290 bool Instrument::IsScriptSlotBypassed(uint index) {
5291 if (index >= ScriptSlotCount())
return false;
5292 return pScriptRefs ? pScriptRefs->at(index).bypass
5293 : scriptPoolFileOffsets.at(index).bypass;
5310 void Instrument::SetScriptSlotBypassed(uint index,
bool bBypass) {
5311 if (index >= ScriptSlotCount())
return;
5313 pScriptRefs->at(index).bypass = bBypass;
5315 scriptPoolFileOffsets.at(index).bypass = bBypass;
5342 DLS::Instrument::CopyAssignCore(orig);
5345 Attenuation = orig->Attenuation;
5346 EffectSend = orig->EffectSend;
5347 FineTune = orig->FineTune;
5348 PitchbendRange = orig->PitchbendRange;
5349 PianoReleaseMode = orig->PianoReleaseMode;
5350 DimensionKeyRange = orig->DimensionKeyRange;
5351 scriptPoolFileOffsets = orig->scriptPoolFileOffsets;
5352 pScriptRefs = orig->pScriptRefs;
5355 for (
int i = 0 ; pMidiRules[i] ; i++) {
5356 delete pMidiRules[i];
5359 pMidiRules[0] = NULL;
5365 RegionList::const_iterator it = orig->pRegions->begin();
5366 for (
int i = 0; i < orig->Regions; ++i, ++it) {
5367 Region* dstRgn = AddRegion();
5370 static_cast<gig::Region*>(*it),
5376 UpdateRegionKeyTable();
5391 pNameChunk = ck3gnm;
5392 ::LoadString(pNameChunk, Name);
5397 if (pNameChunk) pNameChunk->GetParent()->DeleteSubChunk(pNameChunk);
5410 void Group::UpdateChunks(progress_t* pProgress) {
5414 _3gri = pFile->pRIFF->
AddSubList(LIST_TYPE_3GRI);
5415 pFile->pRIFF->
MoveSubChunk(_3gri, pFile->pRIFF->GetSubChunk(CHUNK_ID_PTBL));
5418 if (!_3gnl) _3gnl = _3gri->
AddSubList(LIST_TYPE_3GNL);
5420 if (!pNameChunk && pFile->pVersion && pFile->pVersion->major > 2) {
5423 if (strcmp(static_cast<char*>(ck->LoadChunkData()),
"") == 0) {
5431 ::SaveString(CHUNK_ID_3GNM, pNameChunk, _3gnl, Name, String(
"Unnamed Group"),
true, 64);
5445 Sample* Group::GetFirstSample() {
5447 for (Sample* pSample = pFile->GetFirstSample(); pSample; pSample = pFile->GetNextSample()) {
5448 if (pSample->GetGroup() ==
this)
return pSample;
5463 Sample* Group::GetNextSample() {
5465 for (Sample* pSample = pFile->GetNextSample(); pSample; pSample = pFile->GetNextSample()) {
5466 if (pSample->GetGroup() ==
this)
return pSample;
5474 void Group::AddSample(Sample* pSample) {
5475 pSample->pGroup =
this;
5484 void Group::MoveAll() {
5486 Group* pOtherGroup = NULL;
5487 for (pOtherGroup = pFile->GetFirstGroup(); pOtherGroup; pOtherGroup = pFile->GetNextGroup()) {
5488 if (pOtherGroup !=
this)
break;
5490 if (!pOtherGroup)
throw Exception(
5491 "Could not move samples to another group, since there is no " 5492 "other Group. This is a bug, report it!" 5495 for (Sample* pSample = GetFirstSample(); pSample; pSample = GetNextSample()) {
5496 pOtherGroup->AddSample(pSample);
5507 0, 2, 19980628 & 0xffff, 19980628 >> 16
5512 0, 3, 20030331 & 0xffff, 20030331 >> 16
5517 0, 4, 20071012 & 0xffff, 20071012 >> 16
5520 static const DLS::Info::string_length_t _FileFixedStringLengths[] = {
5521 { CHUNK_ID_IARL, 256 },
5522 { CHUNK_ID_IART, 128 },
5523 { CHUNK_ID_ICMS, 128 },
5524 { CHUNK_ID_ICMT, 1024 },
5525 { CHUNK_ID_ICOP, 128 },
5526 { CHUNK_ID_ICRD, 128 },
5527 { CHUNK_ID_IENG, 128 },
5528 { CHUNK_ID_IGNR, 128 },
5529 { CHUNK_ID_IKEY, 128 },
5530 { CHUNK_ID_IMED, 128 },
5531 { CHUNK_ID_INAM, 128 },
5532 { CHUNK_ID_IPRD, 128 },
5533 { CHUNK_ID_ISBJ, 128 },
5534 { CHUNK_ID_ISFT, 128 },
5535 { CHUNK_ID_ISRC, 128 },
5536 { CHUNK_ID_ISRF, 128 },
5537 { CHUNK_ID_ITCH, 128 },
5543 *pVersion = VERSION_3;
5545 pScriptGroups = NULL;
5546 pInfo->SetFixedStringLengths(_FileFixedStringLengths);
5547 pInfo->ArchivalLocation = String(256,
' ');
5551 pRIFF->AddSubChunk(CHUNK_ID_VERS, 8);
5552 pRIFF->AddSubChunk(CHUNK_ID_COLH, 4);
5553 pRIFF->AddSubChunk(CHUNK_ID_DLID, 16);
5561 pScriptGroups = NULL;
5562 pInfo->SetFixedStringLengths(_FileFixedStringLengths);
5567 std::list<Group*>::iterator iter = pGroups->begin();
5568 std::list<Group*>::iterator end = pGroups->end();
5569 while (iter != end) {
5575 if (pScriptGroups) {
5576 std::list<ScriptGroup*>::iterator iter = pScriptGroups->begin();
5577 std::list<ScriptGroup*>::iterator end = pScriptGroups->end();
5578 while (iter != end) {
5582 delete pScriptGroups;
5587 if (!pSamples) LoadSamples(pProgress);
5588 if (!pSamples)
return NULL;
5589 SamplesIterator = pSamples->begin();
5590 return static_cast<gig::Sample*
>( (SamplesIterator != pSamples->end()) ? *SamplesIterator : NULL );
5594 if (!pSamples)
return NULL;
5596 return static_cast<gig::Sample*
>( (SamplesIterator != pSamples->end()) ? *SamplesIterator : NULL );
5604 Sample* File::GetSample(uint index) {
5605 if (!pSamples) LoadSamples();
5606 if (!pSamples)
return NULL;
5607 DLS::File::SampleList::iterator it = pSamples->begin();
5608 for (
int i = 0; i < index; ++i) {
5610 if (it == pSamples->end())
return NULL;
5612 if (it == pSamples->end())
return NULL;
5613 return static_cast<gig::Sample*
>( *it );
5624 size_t File::CountSamples() {
5625 if (!pSamples) LoadSamples();
5626 if (!pSamples)
return 0;
5627 return pSamples->size();
5638 if (!pSamples) LoadSamples();
5643 Sample* pSample =
new Sample(
this, wave, 0 );
5649 pSamples->push_back(pSample);
5663 if (!pSamples || !pSamples->size())
throw gig::Exception(
"Could not delete sample as there are no samples");
5664 SampleList::iterator iter = find(pSamples->begin(), pSamples->end(), (
DLS::Sample*) pSample);
5665 if (iter == pSamples->end())
throw gig::Exception(
"Could not delete sample, could not find given sample");
5666 if (SamplesIterator != pSamples->end() && *SamplesIterator == pSample) ++SamplesIterator;
5667 pSamples->erase(iter);
5670 SampleList::iterator tmp = SamplesIterator;
5674 for (Region* region = instrument->GetFirstRegion() ; region ;
5675 region = instrument->GetNextRegion()) {
5677 if (region->GetSample() == pSample) region->SetSample(NULL);
5679 for (
int i = 0 ; i < region->DimensionRegions ; i++) {
5680 gig::DimensionRegion *d = region->pDimensionRegions[i];
5681 if (d->pSample == pSample) d->pSample = NULL;
5685 SamplesIterator = tmp;
5688 void File::LoadSamples() {
5692 void File::LoadSamples(progress_t* pProgress) {
5695 if (!pGroups) LoadGroups();
5697 if (!pSamples) pSamples =
new SampleList;
5702 int iSampleIndex = 0;
5703 int iTotalSamples = WavePoolCount;
5709 for (
int i = 0 ; i < WavePoolCount ; i++) {
5710 if (pWavePoolTableHi[i] > lastFileNo) lastFileNo = pWavePoolTableHi[i];
5713 String name(pRIFF->GetFileName());
5714 int nameLen = (int) name.length();
5716 if (nameLen > 4 && name.substr(nameLen - 4) ==
".gig") nameLen -= 4;
5718 for (
int fileNo = 0 ; ; ) {
5726 const float subprogress = (float) iSampleIndex / (
float) iTotalSamples;
5727 __notify_progress(pProgress, subprogress);
5730 pSamples->push_back(
new Sample(
this, wave, waveFileOffset - wvplFileOffset, fileNo, iSampleIndex));
5737 if (fileNo == lastFileNo)
break;
5741 sprintf(suffix,
".gx%02d", fileNo);
5742 name.replace(nameLen, 5, suffix);
5744 ExtensionFiles.push_back(file);
5748 __notify_progress(pProgress, 1.0);
5752 if (!pInstruments) LoadInstruments();
5753 if (!pInstruments)
return NULL;
5754 InstrumentsIterator = pInstruments->begin();
5755 return static_cast<gig::Instrument*
>( (InstrumentsIterator != pInstruments->end()) ? *InstrumentsIterator : NULL );
5759 if (!pInstruments)
return NULL;
5760 InstrumentsIterator++;
5761 return static_cast<gig::Instrument*
>( (InstrumentsIterator != pInstruments->end()) ? *InstrumentsIterator : NULL );
5772 size_t File::CountInstruments() {
5773 if (!pInstruments) LoadInstruments();
5774 if (!pInstruments)
return 0;
5775 return pInstruments->size();
5785 Instrument* File::GetInstrument(uint index, progress_t* pProgress) {
5786 if (!pInstruments) {
5790 progress_t subprogress;
5791 __divide_progress(pProgress, &subprogress, 3.0f, 0.0f);
5792 __notify_progress(&subprogress, 0.0f);
5795 __notify_progress(&subprogress, 1.0f);
5798 if (pProgress && pProgress->callback) {
5799 subprogress.__range_min = subprogress.__range_max;
5800 subprogress.__range_max = pProgress->__range_max;
5802 __notify_progress(&subprogress, 0.0f);
5803 LoadInstruments(&subprogress);
5804 __notify_progress(&subprogress, 1.0f);
5806 if (!pInstruments)
return NULL;
5807 InstrumentsIterator = pInstruments->begin();
5808 for (uint i = 0; InstrumentsIterator != pInstruments->end(); i++) {
5809 if (i == index)
return static_cast<gig::Instrument*
>( *InstrumentsIterator );
5810 InstrumentsIterator++;
5823 if (!pInstruments) LoadInstruments();
5832 Instrument* pInstrument =
new Instrument(
this, lstInstr);
5833 pInstrument->GenerateDLSID();
5838 pInstrument->pInfo->Software =
"Endless Wave";
5840 pInstruments->push_back(pInstrument);
5859 Instrument* File::AddDuplicateInstrument(
const Instrument* orig) {
5861 instr->CopyAssign(orig);
5876 void File::AddContentOf(File* pFile) {
5877 static int iCallCount = -1;
5879 std::map<Group*,Group*> mGroups;
5880 std::map<Sample*,Sample*> mSamples;
5883 for (
int i = 0; pFile->GetGroup(i); ++i) {
5884 Group* g = AddGroup();
5886 "COPY" + ToString(iCallCount) +
"_" + pFile->GetGroup(i)->Name;
5887 mGroups[pFile->GetGroup(i)] = g;
5891 for (
int i = 0; pFile->GetSample(i); ++i) {
5893 s->CopyAssignMeta(pFile->GetSample(i));
5894 mGroups[pFile->GetSample(i)->GetGroup()]->AddSample(s);
5895 mSamples[pFile->GetSample(i)] = s;
5899 for (
int iGroup = 0; pFile->GetScriptGroup(iGroup); ++iGroup) {
5900 ScriptGroup* sg = pFile->GetScriptGroup(iGroup);
5901 ScriptGroup* dg = AddScriptGroup();
5902 dg->Name =
"COPY" + ToString(iCallCount) +
"_" + sg->Name;
5903 for (
int iScript = 0; sg->GetScript(iScript); ++iScript) {
5904 Script* ss = sg->GetScript(iScript);
5905 Script* ds = dg->AddScript();
5923 for (
int i = 0; pFile->GetInstrument(i); ++i) {
5925 instr->CopyAssign(pFile->GetInstrument(i), &mSamples);
5935 for (
int i = 0; pFile->GetSample(i); ++i) {
5936 mSamples[pFile->GetSample(i)]->CopyAssignWave(pFile->GetSample(i));
5949 if (!pInstruments)
throw gig::Exception(
"Could not delete instrument as there are no instruments");
5950 InstrumentList::iterator iter = find(pInstruments->begin(), pInstruments->end(), (
DLS::Instrument*) pInstrument);
5951 if (iter == pInstruments->end())
throw gig::Exception(
"Could not delete instrument, could not find given instrument");
5952 pInstruments->erase(iter);
5956 void File::LoadInstruments() {
5957 LoadInstruments(NULL);
5960 void File::LoadInstruments(progress_t* pProgress) {
5961 if (!pInstruments) pInstruments =
new InstrumentList;
5963 if (lstInstruments) {
5964 int iInstrumentIndex = 0;
5969 const float localProgress = (float) iInstrumentIndex / (
float)
Instruments;
5970 __notify_progress(pProgress, localProgress);
5973 progress_t subprogress;
5974 __divide_progress(pProgress, &subprogress,
Instruments, iInstrumentIndex);
5976 pInstruments->push_back(
new Instrument(
this, lstInstr, &subprogress));
5982 __notify_progress(pProgress, 1.0);
5989 void File::SetSampleChecksum(Sample* pSample, uint32_t crc) {
5994 int iWaveIndex = GetWaveTableIndexOf(pSample);
5995 if (iWaveIndex < 0)
throw gig::Exception(
"Could not update crc, could not find sample");
5998 _3crc->
SetPos(iWaveIndex * 8);
6004 uint32_t File::GetSampleChecksum(Sample* pSample) {
6006 int iWaveIndex = GetWaveTableIndexOf(pSample);
6007 if (iWaveIndex < 0)
throw gig::Exception(
"Could not retrieve reference crc of sample, could not resolve sample's wave table index");
6009 return GetSampleChecksumByIndex(iWaveIndex);
6012 uint32_t File::GetSampleChecksumByIndex(
int index) {
6013 if (index < 0)
throw gig::Exception(
"Could not retrieve reference crc of sample, invalid wave pool index of sample");
6016 if (!_3crc)
throw gig::Exception(
"Could not retrieve reference crc of sample, no checksums stored for this file yet");
6018 if (!pData)
throw gig::Exception(
"Could not retrieve reference crc of sample, no checksums stored for this file yet");
6021 size_t pos = index * 8;
6023 throw gig::Exception(
"Could not retrieve reference crc of sample, could not seek to required position in crc chunk");
6025 uint32_t one = load32(&pData[pos]);
6027 throw gig::Exception(
"Could not retrieve reference crc of sample, because reference checksum table is damaged");
6029 return load32(&pData[pos+4]);
6032 int File::GetWaveTableIndexOf(gig::Sample* pSample) {
6034 File::SampleList::iterator iter = pSamples->begin();
6035 File::SampleList::iterator end = pSamples->end();
6036 for (
int index = 0; iter != end; ++iter, ++index)
6037 if (*iter == pSample)
6048 bool File::VerifySampleChecksumTable() {
6050 if (!_3crc)
return false;
6054 if (_3crc->
GetNewSize() != pSamples->size() * 8)
return false;
6059 if (!pData)
return false;
6061 for (file_offset_t i = 0; i < n; ++i) {
6062 uint32_t one = pData[i*2];
6063 if (one != 1)
return false;
6085 bool File::RebuildSampleChecksumTable() {
6089 bool bRequiresSave =
false;
6094 _3crc = pRIFF->
AddSubChunk(CHUNK_ID_3CRC, pSamples->size() * 8);
6098 bRequiresSave =
true;
6099 }
else if (_3crc->
GetNewSize() != pSamples->size() * 8) {
6100 _3crc->
Resize(pSamples->size() * 8);
6101 bRequiresSave =
true;
6104 if (bRequiresSave) {
6107 File::SampleList::iterator iter = pSamples->begin();
6108 File::SampleList::iterator end = pSamples->end();
6109 for (; iter != end; ++iter) {
6110 gig::Sample* pSample = (gig::Sample*) *iter;
6111 int index = GetWaveTableIndexOf(pSample);
6112 if (index < 0)
throw gig::Exception(
"Could not rebuild crc table for samples, wave table index of a sample could not be resolved");
6114 pData[index*2+1] = pSample->CalculateWaveDataChecksum();
6119 pRIFF->
SetMode(RIFF::stream_mode_read_write);
6121 File::SampleList::iterator iter = pSamples->begin();
6122 File::SampleList::iterator end = pSamples->end();
6123 for (; iter != end; ++iter) {
6124 gig::Sample* pSample = (gig::Sample*) *iter;
6125 int index = GetWaveTableIndexOf(pSample);
6126 if (index < 0)
throw gig::Exception(
"Could not rebuild crc table for samples, wave table index of a sample could not be resolved");
6127 pSample->crc = pSample->CalculateWaveDataChecksum();
6128 SetSampleChecksum(pSample, pSample->crc);
6133 return bRequiresSave;
6136 Group* File::GetFirstGroup() {
6137 if (!pGroups) LoadGroups();
6139 GroupsIterator = pGroups->begin();
6140 return *GroupsIterator;
6143 Group* File::GetNextGroup() {
6144 if (!pGroups)
return NULL;
6146 return (GroupsIterator == pGroups->end()) ? NULL : *GroupsIterator;
6155 Group* File::GetGroup(uint index) {
6156 if (!pGroups) LoadGroups();
6157 GroupsIterator = pGroups->begin();
6158 for (uint i = 0; GroupsIterator != pGroups->end(); i++) {
6159 if (i == index)
return *GroupsIterator;
6175 Group* File::GetGroup(String name) {
6176 if (!pGroups) LoadGroups();
6177 GroupsIterator = pGroups->begin();
6178 for (uint i = 0; GroupsIterator != pGroups->end(); ++GroupsIterator, ++i)
6179 if ((*GroupsIterator)->Name == name)
return *GroupsIterator;
6183 Group* File::AddGroup() {
6184 if (!pGroups) LoadGroups();
6187 Group* pGroup =
new Group(
this, NULL);
6188 pGroups->push_back(pGroup);
6201 void File::DeleteGroup(Group* pGroup) {
6202 if (!pGroups) LoadGroups();
6203 std::list<Group*>::iterator iter = find(pGroups->begin(), pGroups->end(), pGroup);
6204 if (iter == pGroups->end())
throw gig::Exception(
"Could not delete group, could not find given group");
6205 if (pGroups->size() == 1)
throw gig::Exception(
"Cannot delete group, there must be at least one default group!");
6207 for (Sample* pSample = pGroup->GetFirstSample(); pSample; pSample = pGroup->GetNextSample()) {
6211 pGroups->erase(iter);
6225 void File::DeleteGroupOnly(Group* pGroup) {
6226 if (!pGroups) LoadGroups();
6227 std::list<Group*>::iterator iter = find(pGroups->begin(), pGroups->end(), pGroup);
6228 if (iter == pGroups->end())
throw gig::Exception(
"Could not delete group, could not find given group");
6229 if (pGroups->size() == 1)
throw gig::Exception(
"Cannot delete group, there must be at least one default group!");
6232 pGroups->erase(iter);
6236 void File::LoadGroups() {
6237 if (!pGroups) pGroups =
new std::list<Group*>;
6247 strcmp(static_cast<char*>(ck->
LoadChunkData()),
"") == 0)
break;
6249 pGroups->push_back(
new Group(
this, ck));
6256 if (!pGroups->size()) {
6257 Group* pGroup =
new Group(
this, NULL);
6258 pGroup->Name =
"Default Group";
6259 pGroups->push_back(pGroup);
6270 ScriptGroup* File::GetScriptGroup(uint index) {
6271 if (!pScriptGroups) LoadScriptGroups();
6272 std::list<ScriptGroup*>::iterator it = pScriptGroups->begin();
6273 for (uint i = 0; it != pScriptGroups->end(); ++i, ++it)
6274 if (i == index)
return *it;
6286 ScriptGroup* File::GetScriptGroup(
const String& name) {
6287 if (!pScriptGroups) LoadScriptGroups();
6288 std::list<ScriptGroup*>::iterator it = pScriptGroups->begin();
6289 for (uint i = 0; it != pScriptGroups->end(); ++i, ++it)
6290 if ((*it)->Name == name)
return *it;
6302 ScriptGroup* File::AddScriptGroup() {
6303 if (!pScriptGroups) LoadScriptGroups();
6304 ScriptGroup* pScriptGroup =
new ScriptGroup(
this, NULL);
6305 pScriptGroups->push_back(pScriptGroup);
6306 return pScriptGroup;
6321 void File::DeleteScriptGroup(ScriptGroup* pScriptGroup) {
6322 if (!pScriptGroups) LoadScriptGroups();
6323 std::list<ScriptGroup*>::iterator iter =
6324 find(pScriptGroups->begin(), pScriptGroups->end(), pScriptGroup);
6325 if (iter == pScriptGroups->end())
6326 throw gig::Exception(
"Could not delete script group, could not find given script group");
6327 pScriptGroups->erase(iter);
6328 for (
int i = 0; pScriptGroup->GetScript(i); ++i)
6329 pScriptGroup->DeleteScript(pScriptGroup->GetScript(i));
6330 if (pScriptGroup->pList)
6331 pScriptGroup->pList->GetParent()->DeleteSubChunk(pScriptGroup->pList);
6332 delete pScriptGroup;
6335 void File::LoadScriptGroups() {
6336 if (pScriptGroups)
return;
6337 pScriptGroups =
new std::list<ScriptGroup*>;
6343 if (lst->GetListType() == LIST_TYPE_RTIS) {
6344 pScriptGroups->push_back(
new ScriptGroup(
this, lst));
6362 bool newFile = pRIFF->
GetSubList(LIST_TYPE_INFO) == NULL;
6379 if (pScriptGroups) {
6381 for (std::list<ScriptGroup*>::iterator it = pScriptGroups->begin();
6382 it != pScriptGroups->end(); ++it)
6384 (*it)->UpdateChunks(pProgress);
6403 if (first != info) {
6418 if (!_3gnl) _3gnl = _3gri->
AddSubList(LIST_TYPE_3GNL);
6424 for (
int i = 0 ; i < 128 ; i++) {
6425 if (i >= pGroups->size()) ::SaveString(CHUNK_ID_3GNM, _3gnm, _3gnl,
"",
"",
true, 64);
6430 std::list<Group*>::iterator iter = pGroups->begin();
6431 std::list<Group*>::iterator end = pGroups->end();
6432 for (; iter != end; ++iter) {
6433 (*iter)->UpdateChunks(pProgress);
6453 int sublen = int(pSamples->size() / 8 + 49);
6458 if (einf->
GetSize() != einfSize) {
6462 }
else if (newFile) {
6463 einf = pRIFF->
AddSubChunk(CHUNK_ID_EINF, einfSize);
6468 std::map<gig::Sample*,int> sampleMap;
6471 sampleMap[pSample] = sampleIdx++;
6474 int totnbusedsamples = 0;
6475 int totnbusedchannels = 0;
6476 int totnbregions = 0;
6477 int totnbdimregions = 0;
6479 int instrumentIdx = 0;
6481 memset(&pData[48], 0, sublen - 48);
6485 int nbusedsamples = 0;
6486 int nbusedchannels = 0;
6487 int nbdimregions = 0;
6490 memset(&pData[(instrumentIdx + 1) * sublen + 48], 0, sublen - 48);
6492 for (Region* region = instrument->GetFirstRegion() ; region ;
6493 region = instrument->GetNextRegion()) {
6494 for (
int i = 0 ; i < region->DimensionRegions ; i++) {
6495 gig::DimensionRegion *d = region->pDimensionRegions[i];
6497 int sampleIdx = sampleMap[d->pSample];
6498 int byte = 48 + sampleIdx / 8;
6499 int bit = 1 << (sampleIdx & 7);
6500 if ((pData[(instrumentIdx + 1) * sublen + byte] & bit) == 0) {
6501 pData[(instrumentIdx + 1) * sublen + byte] |= bit;
6503 nbusedchannels += d->pSample->Channels;
6505 if ((pData[byte] & bit) == 0) {
6508 totnbusedchannels += d->pSample->Channels;
6512 if (d->SampleLoops) nbloops++;
6514 nbdimregions += region->DimensionRegions;
6518 store32(&pData[(instrumentIdx + 1) * sublen + 4], nbusedchannels);
6519 store32(&pData[(instrumentIdx + 1) * sublen + 8], nbusedsamples);
6520 store32(&pData[(instrumentIdx + 1) * sublen + 12], 1);
6521 store32(&pData[(instrumentIdx + 1) * sublen + 16], instrument->Regions);
6522 store32(&pData[(instrumentIdx + 1) * sublen + 20], nbdimregions);
6523 store32(&pData[(instrumentIdx + 1) * sublen + 24], nbloops);
6525 store32(&pData[(instrumentIdx + 1) * sublen + 36], instrumentIdx);
6526 store32(&pData[(instrumentIdx + 1) * sublen + 40], (uint32_t) pSamples->size());
6529 totnbregions += instrument->Regions;
6530 totnbdimregions += nbdimregions;
6531 totnbloops += nbloops;
6536 store32(&pData[4], totnbusedchannels);
6537 store32(&pData[8], totnbusedsamples);
6539 store32(&pData[16], totnbregions);
6540 store32(&pData[20], totnbdimregions);
6541 store32(&pData[24], totnbloops);
6544 store32(&pData[40], (uint32_t) pSamples->size());
6564 _3crc->
Resize(pSamples->size() * 8);
6566 _3crc = pRIFF->
AddSubChunk(CHUNK_ID_3CRC, pSamples->size() * 8);
6573 File::SampleList::iterator iter = pSamples->begin();
6574 File::SampleList::iterator end = pSamples->end();
6575 for (
int index = 0; iter != end; ++iter, ++index) {
6576 gig::Sample* pSample = (gig::Sample*) *iter;
6578 pData[index*2+1] = pSample->crc;
6590 instrument->UpdateScriptFileOffsets();
6609 void File::SetAutoLoad(
bool b) {
6617 bool File::GetAutoLoad() {
6626 Exception::Exception() :
DLS::Exception() {
6629 Exception::Exception(String format, ...) :
DLS::Exception() {
6631 va_start(arg, format);
6632 Message = assemble(format, arg);
6636 Exception::Exception(String format, va_list arg) :
DLS::Exception() {
6637 Message = assemble(format, arg);
6640 void Exception::PrintMessage() {
6641 std::cout <<
"gig::Exception: " << Message << std::endl;
file_offset_t WriteUint32(uint32_t *pData, file_offset_t WordCount=1)
Writes WordCount number of 32 Bit unsigned integer words from the buffer pointed by pData to the chun...
bool IsNew() const
Returns true if this file has been created new from scratch and has not been stored to disk yet...
Destination container for serialization, and source container for deserialization.
uint32_t Regions
Reflects the number of Region defintions this Instrument has.
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...
stream_whence_t
File stream position dependent to these relations.
Chunk * GetFirstSubChunk()
Returns the first subchunk within the list (which may be an ordinary chunk as well as a list chunk)...
uint32_t LoopType
Defines how the waveform samples will be looped (appropriate loop types for the gig format are define...
void __ensureMandatoryChunksExist()
Checks if all (for DLS) mandatory chunks exist, if not they will be created.
virtual void CopyAssign(const Region *orig)
Make a (semi) deep copy of the Region object given by orig and assign it to this object.
file_offset_t GetSize() const
Chunk size in bytes (without header, thus the chunk data body)
file_offset_t SetPos(file_offset_t SampleCount, RIFF::stream_whence_t Whence=RIFF::stream_start)
Sets the position within the sample (in sample points, not in bytes).
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...
Instrument * GetFirstInstrument()
Returns a pointer to the first Instrument object of the file, NULL otherwise.
virtual void UpdateChunks(progress_t *pProgress)
Apply sample and its settings to the respective RIFF chunks.
void ReadString(String &s, int size)
Reads a null-padded string of size characters and copies it into the string s.
file_offset_t GetSize() const
Returns sample size.
uint16_t Channels
Number of channels represented in the waveform data, e.g. 1 for mono, 2 for stereo (defaults to 1=mon...
file_offset_t SamplesTotal
Reflects total number of sample points (only if known sample data format is used, 0 otherwise)...
List * GetSubList(uint32_t ListType)
Returns sublist chunk with list type ListType within this chunk list.
void DeleteSubChunk(Chunk *pSubChunk)
Removes a sub chunk.
Defines Sample Loop Points.
List * GetFirstSubList()
Returns the first sublist within the list (that is a subchunk with chunk ID "LIST").
virtual ~Region()
Destructor.
Sample * GetFirstSample()
Returns a pointer to the first Sample object of the file, NULL otherwise.
uint FrameSize
Reflects the size (in bytes) of one single sample point (only if known sample data format is used...
List * GetParent() const
Returns pointer to the chunk's parent list chunk.
virtual ~Instrument()
Destructor.
file_offset_t Write(void *pBuffer, file_offset_t SampleCount)
Write sample wave data.
file_offset_t Read(void *pData, file_offset_t WordCount, file_offset_t WordSize)
Reads WordCount number of data words with given WordSize and copies it into a buffer pointed by pData...
void ReleaseSampleData()
Free sample data from RAM.
String libraryName()
Returns the name of this C++ library.
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)...
void Resize(file_offset_t NewSize)
Resize sample.
Sample * GetNextSample()
Returns a pointer to the next Sample object of the file, NULL otherwise.
Region * GetNextRegion()
Returns the next Region of the instrument.
virtual void Save(const String &Path, progress_t *pProgress=NULL)
Save changes to another file.
Sample * AddSample()
Add a new sample.
virtual void UpdateChunks(progress_t *pProgress)
Apply Instrument with all its Regions to the respective RIFF chunks.
void DeleteSample(Sample *pSample)
Delete a sample.
uint64_t file_offset_t
Type used by libgig for handling file positioning during file I/O tasks.
file_offset_t ReadUint32(uint32_t *pData, file_offset_t WordCount=1)
Reads WordCount number of 32 Bit unsigned integer words and copies it into the buffer pointed by pDat...
virtual void UpdateChunks(progress_t *pProgress)
Apply all the DLS file's current instruments, samples and settings to the respective RIFF chunks...
Chunk * GetSubChunk(uint32_t ChunkID)
Returns subchunk with chunk ID ChunkID within this chunk list.
Chunk * GetNextSubChunk()
Returns the next subchunk within the list (which may be an ordinary chunk as well as a list chunk)...
virtual void SetKeyRange(uint16_t Low, uint16_t High)
Modifies the key range of this Region and makes sure the respective chunks are in correct order...
uint16_t BitDepth
Size of each sample per channel (only if known sample data format is used, 0 otherwise).
virtual ~Sample()
Destructor.
Sample(File *pFile, RIFF::List *waveList, file_offset_t WavePoolOffset)
Constructor.
int GetFileOffsetSize() const
Returns the current size (in bytes) of file offsets stored in the headers of all chunks of this file...
uint32_t LoopLength
Length of the looping area (in sample points).
uint32_t GetChunkID() const
Chunk ID in unsigned integer representation.
file_offset_t RemainingBytes() const
Returns the number of bytes left to read in the chunk body.
file_offset_t Write(void *pData, file_offset_t WordCount, file_offset_t WordSize)
Writes WordCount number of data words with given WordSize from the buffer pointed by pData...
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...
void DeleteInstrument(Instrument *pInstrument)
Delete an instrument.
version_t * pVersion
Points to a version_t structure if the file provided a version number else is set to NULL...
uint32_t LoopStart
The start value specifies the offset (in sample points) in the waveform data of the first sample poin...
Instrument(File *pFile, RIFF::List *insList)
Constructor.
void * LoadChunkData()
Load chunk body into RAM.
virtual void UpdateChunks(progress_t *pProgress)
Apply Region settings to the respective RIFF chunks.
virtual void UpdateFileOffsets()
Updates all file offsets stored all over the file.
void Resize(file_offset_t NewSize)
Resize chunk.
List * AddSubList(uint32_t uiListType)
Creates a new list sub chunk.
virtual void CopyAssign(const Instrument *orig)
Make a (semi) deep copy of the Instrument object given by orig and assign it to this object...
virtual void UpdateChunks(progress_t *pProgress)
Apply all sample player options to the respective RIFF chunk.
file_offset_t GetNewSize() const
New chunk size if it was modified with Resize(), otherwise value returned will be equal to GetSize()...
Encapsulates sample waves used for playback.
void MoveSubChunk(Chunk *pSrc, Chunk *pDst)
Moves a sub chunk witin this list.
uint32_t SamplesPerSecond
Sampling rate at which each channel should be played (defaults to 44100 if Sample was created with In...
File * GetFile() const
Returns pointer to the chunk's File object.
size_t CountSubChunks()
Returns number of subchunks within the list (including list chunks).
String GetFileName()
File name of this DLS file.
bool SetMode(stream_mode_t NewMode)
Change file access mode.
Instrument * AddInstrument()
Add a new instrument definition.
file_offset_t Read(void *pBuffer, file_offset_t SampleCount)
Reads SampleCount number of sample points from the current position into the buffer pointed by pBuffe...
void CopyAssignCore(const Sample *orig)
Make a deep copy of the Sample object given by orig (without the actual sample waveform data however)...
file_offset_t GetFilePos() const
Current, actual offset of chunk data body start in file.
file_offset_t GetCurrentFileSize() const
Returns the current size of this file (in bytes) as it is currently yet stored on disk...
uint32_t Instruments
Reflects the number of available Instrument objects.
Provides all neccessary information for the synthesis of a DLS Instrument.
Quadtuple version number ("major.minor.release.build").
Instrument * GetNextInstrument()
Returns a pointer to the next Instrument object of the file, NULL otherwise.
file_offset_t GetPos() const
Position within the chunk data body (starting with 0).
DLS specific classes and definitions.
String libraryVersion()
Returns version of this C++ library.
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...
file_offset_t ReadUint8(uint8_t *pData, file_offset_t WordCount=1)
Reads WordCount number of 8 Bit unsigned integer words and copies it into the buffer pointed by pData...
Region * GetFirstRegion()
Returns the first Region of the instrument.
List * GetNextSubList()
Returns the next sublist (that is a subchunk with chunk ID "LIST") within the list.
Defines Region information of an Instrument.
Chunk * AddSubChunk(uint32_t uiChunkID, file_offset_t ullBodySize)
Creates a new sub chunk.
void * LoadSampleData()
Load sample data into RAM.