38 #define INITIAL_SAMPLE_BUFFER_SIZE 512000 // 512 kB 41 #define GIG_EXP_DECODE(x) (pow(1.000000008813822, x)) 42 #define GIG_EXP_ENCODE(x) (log(x) / log(1.000000008813822)) 43 #define GIG_PITCH_TRACK_EXTRACT(x) (!(x & 0x01)) 44 #define GIG_PITCH_TRACK_ENCODE(x) ((x) ? 0x00 : 0x01) 45 #define GIG_VCF_RESONANCE_CTRL_EXTRACT(x) ((x >> 4) & 0x03) 46 #define GIG_VCF_RESONANCE_CTRL_ENCODE(x) ((x & 0x03) << 4) 47 #define GIG_EG_CTR_ATTACK_INFLUENCE_EXTRACT(x) ((x >> 1) & 0x03) 48 #define GIG_EG_CTR_DECAY_INFLUENCE_EXTRACT(x) ((x >> 3) & 0x03) 49 #define GIG_EG_CTR_RELEASE_INFLUENCE_EXTRACT(x) ((x >> 5) & 0x03) 50 #define GIG_EG_CTR_ATTACK_INFLUENCE_ENCODE(x) ((x & 0x03) << 1) 51 #define GIG_EG_CTR_DECAY_INFLUENCE_ENCODE(x) ((x & 0x03) << 3) 52 #define GIG_EG_CTR_RELEASE_INFLUENCE_ENCODE(x) ((x & 0x03) << 5) 61 inline int get12lo(
const unsigned char* pSrc)
63 const int x = pSrc[0] | (pSrc[1] & 0x0f) << 8;
64 return x & 0x800 ? x - 0x1000 : x;
67 inline int get12hi(
const unsigned char* pSrc)
69 const int x = pSrc[1] >> 4 | pSrc[2] << 4;
70 return x & 0x800 ? x - 0x1000 : x;
73 inline int16_t get16(
const unsigned char* pSrc)
75 return int16_t(pSrc[0] | pSrc[1] << 8);
78 inline int get24(
const unsigned char* pSrc)
80 const int x = pSrc[0] | pSrc[1] << 8 | pSrc[2] << 16;
81 return x & 0x800000 ? x - 0x1000000 : x;
84 inline void store24(
unsigned char* pDst,
int x)
91 void Decompress16(
int compressionmode,
const unsigned char* params,
92 int srcStep,
int dstStep,
93 const unsigned char* pSrc, int16_t* pDst,
94 unsigned long currentframeoffset,
95 unsigned long copysamples)
97 switch (compressionmode) {
99 pSrc += currentframeoffset * srcStep;
100 while (copysamples) {
109 int y = get16(params);
110 int dy = get16(params + 2);
111 while (currentframeoffset) {
115 currentframeoffset--;
117 while (copysamples) {
129 void Decompress24(
int compressionmode,
const unsigned char* params,
130 int dstStep,
const unsigned char* pSrc, uint8_t* pDst,
131 unsigned long currentframeoffset,
132 unsigned long copysamples,
int truncatedBits)
134 int y, dy, ddy, dddy;
136 #define GET_PARAMS(params) \ 138 dy = y - get24((params) + 3); \ 139 ddy = get24((params) + 6); \ 140 dddy = get24((params) + 9) 142 #define SKIP_ONE(x) \ 148 #define COPY_ONE(x) \ 150 store24(pDst, y << truncatedBits); \ 153 switch (compressionmode) {
155 pSrc += currentframeoffset * 3;
156 while (copysamples) {
157 store24(pDst, get24(pSrc) << truncatedBits);
166 while (currentframeoffset) {
169 currentframeoffset--;
171 while (copysamples) {
180 while (currentframeoffset > 1) {
184 currentframeoffset -= 2;
186 if (currentframeoffset) {
188 currentframeoffset--;
195 while (copysamples > 1) {
208 while (currentframeoffset) {
210 currentframeoffset--;
212 while (copysamples) {
220 const int bytesPerFrame[] = { 4096, 2052, 768, 524, 396, 268 };
221 const int bytesPerFrameNoHdr[] = { 4096, 2048, 768, 512, 384, 256 };
222 const int headerSize[] = { 0, 4, 0, 12, 12, 12 };
223 const int bitsPerSample[] = { 16, 8, 24, 16, 12, 8 };
231 static uint32_t* __initCRCTable() {
232 static uint32_t res[256];
234 for (
int i = 0 ; i < 256 ; i++) {
236 for (
int j = 0 ; j < 8 ; j++) {
237 c = (c & 1) ? 0xedb88320 ^ (c >> 1) : c >> 1;
244 static const uint32_t* __CRCTable = __initCRCTable();
251 inline static void __resetCRC(uint32_t& crc) {
274 static void __calculateCRC(
unsigned char* buf,
int bufSize, uint32_t& crc) {
275 for (
int i = 0 ; i < bufSize ; i++) {
276 crc = __CRCTable[(crc ^ buf[i]) & 0xff] ^ (crc >> 8);
285 inline static uint32_t __encodeCRC(
const uint32_t& crc) {
286 return crc ^ 0xffffffff;
307 static int __resolveZoneSize(dimension_def_t& dimension_definition) {
309 ? int(128.0 / dimension_definition.zones) : 0;
407 if (version == 3 &&
BitDepth == 24) {
412 ScanCompressedSample();
477 const int iReadAtOnce = 32*1024;
478 char* buf =
new char[iReadAtOnce * orig->
FrameSize];
480 unsigned long restorePos = pOrig->
GetPos();
483 for (
unsigned long n = pOrig->
Read(buf, iReadAtOnce); n;
484 n = pOrig->
Read(buf, iReadAtOnce))
488 pOrig->
SetPos(restorePos);
524 store32(&pData[28],
Loops);
528 store32(&pData[36],
LoopID);
539 uint16_t iSampleGroup = 0;
541 if (pFile->pGroups) {
542 std::list<Group*>::iterator iter = pFile->pGroups->begin();
543 std::list<Group*>::iterator end = pFile->pGroups->end();
544 for (
int i = 0; iter != end; i++, iter++) {
553 store16(&pData[0], iSampleGroup);
565 void Sample::ScanCompressedSample() {
568 std::list<unsigned long> frameOffsets;
576 for (
int i = 0 ; ; i++) {
583 if (mode_l > 5 || mode_r > 5)
throw gig::Exception(
"Unknown compression mode");
584 const unsigned long frameSize = bytesPerFrame[mode_l] + bytesPerFrame[mode_r];
589 (bitsPerSample[mode_l] + bitsPerSample[mode_r]);
598 for (
int i = 0 ; ; i++) {
603 const unsigned long frameSize = bytesPerFrame[mode];
619 FrameTable =
new unsigned long[frameOffsets.size()];
620 std::list<unsigned long>::iterator end = frameOffsets.end();
621 std::list<unsigned long>::iterator iter = frameOffsets.begin();
622 for (
int i = 0; iter != end; i++, iter++) {
724 unsigned long allocationsize = (SampleCount + NullSamplesCount) * this->
FrameSize;
840 unsigned long frame = this->
SamplePos / 2048;
846 unsigned long orderedBytes = SampleCount * this->
FrameSize;
847 unsigned long result =
pCkData->
SetPos(orderedBytes, Whence);
848 return (result == orderedBytes) ? SampleCount
897 unsigned long samplestoread = SampleCount, totalreadsamples = 0, readsamples, samplestoloopend;
898 uint8_t* pDst = (uint8_t*) pBuffer;
907 if (
GetPos() <= loopEnd) {
915 if (!pPlaybackState->
reverse) {
917 samplestoloopend = loopEnd -
GetPos();
918 readsamples =
Read(&pDst[totalreadsamples * this->
FrameSize], Min(samplestoread, samplestoloopend), pExternalDecompressionBuffer);
919 samplestoread -= readsamples;
920 totalreadsamples += readsamples;
921 if (readsamples == samplestoloopend) {
922 pPlaybackState->
reverse =
true;
925 }
while (samplestoread && readsamples);
935 unsigned long swapareastart = totalreadsamples;
937 unsigned long samplestoreadinloop = Min(samplestoread, loopoffset);
938 unsigned long reverseplaybackend =
GetPos() - samplestoreadinloop;
940 SetPos(reverseplaybackend);
944 readsamples =
Read(&pDst[totalreadsamples * this->
FrameSize], samplestoreadinloop, pExternalDecompressionBuffer);
945 samplestoreadinloop -= readsamples;
946 samplestoread -= readsamples;
947 totalreadsamples += readsamples;
948 }
while (samplestoreadinloop && readsamples);
950 SetPos(reverseplaybackend);
952 if (reverseplaybackend == loop.
LoopStart) {
954 pPlaybackState->
reverse =
false;
958 if (totalreadsamples > swapareastart)
959 SwapMemoryArea(&pDst[swapareastart * this->
FrameSize], (totalreadsamples - swapareastart) * this->FrameSize, this->FrameSize);
961 }
while (samplestoread && readsamples);
967 if (!pPlaybackState->
reverse)
do {
968 samplestoloopend = loopEnd -
GetPos();
969 readsamples =
Read(&pDst[totalreadsamples * this->
FrameSize], Min(samplestoread, samplestoloopend), pExternalDecompressionBuffer);
970 samplestoread -= readsamples;
971 totalreadsamples += readsamples;
972 if (readsamples == samplestoloopend) {
973 pPlaybackState->
reverse =
true;
976 }
while (samplestoread && readsamples);
978 if (!samplestoread)
break;
986 unsigned long swapareastart = totalreadsamples;
990 unsigned long reverseplaybackend = loop.
LoopStart + Abs((loopoffset - samplestoreadinloop) % loop.
LoopLength);
992 SetPos(reverseplaybackend);
998 samplestoloopend = loopEnd -
GetPos();
999 readsamples =
Read(&pDst[totalreadsamples * this->
FrameSize], Min(samplestoreadinloop, samplestoloopend), pExternalDecompressionBuffer);
1000 samplestoreadinloop -= readsamples;
1001 samplestoread -= readsamples;
1002 totalreadsamples += readsamples;
1003 if (readsamples == samplestoloopend) {
1007 }
while (samplestoreadinloop && readsamples);
1009 SetPos(reverseplaybackend);
1012 SwapMemoryArea(&pDst[swapareastart * this->
FrameSize], (totalreadsamples - swapareastart) * this->FrameSize, this->FrameSize);
1020 samplestoloopend = loopEnd -
GetPos();
1021 readsamples =
Read(&pDst[totalreadsamples * this->
FrameSize], Min(samplestoread, samplestoloopend), pExternalDecompressionBuffer);
1022 samplestoread -= readsamples;
1023 totalreadsamples += readsamples;
1024 if (readsamples == samplestoloopend) {
1028 }
while (samplestoread && readsamples);
1036 if (samplestoread)
do {
1037 readsamples =
Read(&pDst[totalreadsamples * this->
FrameSize], samplestoread, pExternalDecompressionBuffer);
1038 samplestoread -= readsamples;
1039 totalreadsamples += readsamples;
1040 }
while (readsamples && samplestoread);
1045 return totalreadsamples;
1071 if (SampleCount == 0)
return 0;
1085 unsigned long assumedsize =
GuessSize(SampleCount),
1087 remainingsamples = SampleCount,
1088 copysamples, skipsamples,
1095 if (pDecompressionBuffer->
Size < assumedsize) {
1096 std::cerr <<
"gig::Read(): WARNING - decompression buffer size too small!" << std::endl;
1098 remainingsamples = SampleCount;
1102 unsigned char* pSrc = (
unsigned char*) pDecompressionBuffer->
pStart;
1103 int16_t* pDst = static_cast<int16_t*>(pBuffer);
1104 uint8_t* pDst24 = static_cast<uint8_t*>(pBuffer);
1105 remainingbytes =
pCkData->
Read(pSrc, assumedsize, 1);
1107 while (remainingsamples && remainingbytes) {
1109 unsigned long framebytes, rightChannelOffset = 0, nextFrameOffset;
1111 int mode_l = *pSrc++, mode_r = 0;
1115 framebytes = bytesPerFrame[mode_l] + bytesPerFrame[mode_r] + 2;
1116 rightChannelOffset = bytesPerFrameNoHdr[mode_l];
1117 nextFrameOffset = rightChannelOffset + bytesPerFrameNoHdr[mode_r];
1118 if (remainingbytes < framebytes) {
1120 if (mode_l == 4 && (framesamples & 1)) {
1121 rightChannelOffset = ((framesamples + 1) * bitsPerSample[mode_l]) >> 3;
1124 rightChannelOffset = (framesamples * bitsPerSample[mode_l]) >> 3;
1129 framebytes = bytesPerFrame[mode_l] + 1;
1130 nextFrameOffset = bytesPerFrameNoHdr[mode_l];
1131 if (remainingbytes < framebytes) {
1137 if (currentframeoffset + remainingsamples >= framesamples) {
1138 if (currentframeoffset <= framesamples) {
1139 copysamples = framesamples - currentframeoffset;
1140 skipsamples = currentframeoffset;
1144 skipsamples = framesamples;
1151 copysamples = remainingsamples;
1152 skipsamples = currentframeoffset;
1154 this->
FrameOffset = currentframeoffset + copysamples;
1156 remainingsamples -= copysamples;
1158 if (remainingbytes > framebytes) {
1159 remainingbytes -= framebytes;
1160 if (remainingsamples == 0 &&
1161 currentframeoffset + copysamples == framesamples) {
1169 else remainingbytes = 0;
1171 currentframeoffset -= skipsamples;
1173 if (copysamples == 0) {
1178 const unsigned char*
const param_l = pSrc;
1180 if (mode_l != 2) pSrc += 12;
1183 const unsigned char*
const param_r = pSrc;
1184 if (mode_r != 2) pSrc += 12;
1186 Decompress24(mode_l, param_l, 6, pSrc, pDst24,
1188 Decompress24(mode_r, param_r, 6, pSrc + rightChannelOffset, pDst24 + 3,
1190 pDst24 += copysamples * 6;
1193 Decompress24(mode_l, param_l, 3, pSrc, pDst24,
1195 pDst24 += copysamples * 3;
1199 if (mode_l) pSrc += 4;
1203 const unsigned char*
const param_r = pSrc;
1204 if (mode_r) pSrc += 4;
1206 step = (2 - mode_l) + (2 - mode_r);
1207 Decompress16(mode_l, param_l, step, 2, pSrc, pDst, skipsamples, copysamples);
1208 Decompress16(mode_r, param_r, step, 2, pSrc + (2 - mode_l), pDst + 1,
1209 skipsamples, copysamples);
1210 pDst += copysamples << 1;
1214 Decompress16(mode_l, param_l, step, 1, pSrc, pDst, skipsamples, copysamples);
1215 pDst += copysamples;
1218 pSrc += nextFrameOffset;
1222 if (remainingsamples && remainingbytes < WorstCaseFrameSize && pCkData->GetState() ==
RIFF::stream_ready) {
1223 assumedsize =
GuessSize(remainingsamples);
1227 pSrc = (
unsigned char*) pDecompressionBuffer->
pStart;
1231 this->
SamplePos += (SampleCount - remainingsamples);
1233 return (SampleCount - remainingsamples);
1267 if (
GetSize() < SampleCount)
throw Exception(
"Could not write sample data, current sample size to small");
1275 __calculateCRC((
unsigned char *)pBuffer, SampleCount *
FrameSize,
crc);
1304 const double worstCaseHeaderOverhead =
1305 (256.0 + 12.0 + 2.0 ) / 256.0;
1306 result.
Size = (
unsigned long) (
double(MaxReadSize) * 3.0 * 2.0 * worstCaseHeaderOverhead);
1320 if (DecompressionBuffer.
Size && DecompressionBuffer.
pStart) {
1321 delete[] (int8_t*) DecompressionBuffer.
pStart;
1322 DecompressionBuffer.
pStart = NULL;
1323 DecompressionBuffer.
Size = 0;
1356 uint DimensionRegion::Instances = 0;
1357 DimensionRegion::VelocityTableMap* DimensionRegion::pVelocityTables = NULL;
1368 if (!pVelocityTables) pVelocityTables =
new VelocityTableMap;
1389 uint8_t eg1ctrloptions = _3ewa->
ReadUint8();
1395 uint8_t eg2ctrloptions = _3ewa->
ReadUint8();
1421 uint8_t velocityresponse = _3ewa->
ReadUint8();
1422 if (velocityresponse < 5) {
1425 }
else if (velocityresponse < 10) {
1428 }
else if (velocityresponse < 15) {
1435 uint8_t releasevelocityresponse = _3ewa->
ReadUint8();
1436 if (releasevelocityresponse < 5) {
1439 }
else if (releasevelocityresponse < 10) {
1442 }
else if (releasevelocityresponse < 15) {
1454 uint8_t pitchTrackDimensionBypass = _3ewa->
ReadInt8();
1460 Pan = (pan < 64) ? pan : -((
int)pan - 63);
1472 bool extResonanceCtrl = lfo2ctrl & 0x40;
1480 EG3Depth = (eg3depth <= 1200) ? eg3depth
1481 : (-1) * (int16_t) ((eg3depth ^ 0xfff) + 1);
1484 uint8_t regoptions = _3ewa->
ReadUint8();
1499 uint8_t vcfvelscale = _3ewa->
ReadUint8();
1503 uint8_t vcfresonance = _3ewa->
ReadUint8();
1506 uint8_t vcfbreakpoint = _3ewa->
ReadUint8();
1509 uint8_t vcfvelocity = _3ewa->
ReadUint8();
1514 if (lfo3ctrl & 0x40)
1609 pVelocityReleaseTable = GetReleaseVelocityTable(
1636 for (
int k = 0 ; k < 128 ; k++)
1684 pRegion = pOriginalRegion;
1692 if (mSamples && mSamples->count(orig->
pSample)) {
1699 for (
int k = 0 ; k < 128 ; k++)
1749 const uint32_t chunksize = _3ewa->
GetNewSize();
1750 store32(&pData[0], chunksize);
1753 store32(&pData[4], lfo3freq);
1756 store32(&pData[8], eg3attack);
1775 store32(&pData[28], eg1attack);
1778 store32(&pData[32], eg1decay1);
1785 store32(&pData[40], eg1release);
1787 const uint8_t eg1ctl = (uint8_t) EncodeLeverageController(
EG1Controller);
1790 const uint8_t eg1ctrloptions =
1795 pData[45] = eg1ctrloptions;
1797 const uint8_t eg2ctl = (uint8_t) EncodeLeverageController(
EG2Controller);
1800 const uint8_t eg2ctrloptions =
1805 pData[47] = eg2ctrloptions;
1808 store32(&pData[48], lfo1freq);
1811 store32(&pData[52], eg2attack);
1814 store32(&pData[56], eg2decay1);
1821 store32(&pData[64], eg2release);
1828 store32(&pData[72], lfo2freq);
1835 store32(&pData[80], eg1decay2);
1842 store32(&pData[88], eg2decay2);
1855 velocityresponse += 5;
1858 velocityresponse += 10;
1862 throw Exception(
"Could not update DimensionRegion's chunk, unknown VelocityResponseCurve selected");
1864 pData[96] = velocityresponse;
1874 releasevelocityresponse += 5;
1877 releasevelocityresponse += 10;
1881 throw Exception(
"Could not update DimensionRegion's chunk, unknown ReleaseVelocityResponseCurve selected");
1883 pData[97] = releasevelocityresponse;
1900 pitchTrackDimensionBypass |= 0x10;
1903 pitchTrackDimensionBypass |= 0x20;
1909 throw Exception(
"Could not update DimensionRegion's chunk, unknown DimensionBypass selected");
1911 pData[108] = pitchTrackDimensionBypass;
1914 const uint8_t pan = (
Pan >= 0) ?
Pan : ((-
Pan) + 63);
1917 const uint8_t selfmask = (
SelfMask) ? 0x01 : 0x00;
1918 pData[110] = selfmask;
1927 pData[112] = lfo3ctrl;
1931 pData[113] = attenctl;
1938 pData[114] = lfo2ctrl;
1947 pData[115] = lfo1ctrl;
1951 : uint16_t(((-
EG3Depth) - 1) ^ 0xfff);
1952 store16(&pData[116], eg3depth);
1957 pData[120] = channeloffset;
1960 uint8_t regoptions = 0;
1963 pData[121] = regoptions;
1976 const uint8_t eg1hold = (
EG1Hold) ? 0x80 : 0x00;
1977 pData[131] = eg1hold;
1979 const uint8_t vcfcutoff = (
VCFEnabled ? 0x80 : 0x00) |
1981 pData[132] = vcfcutoff;
1987 pData[134] = vcfvelscale;
1993 pData[136] = vcfresonance;
1997 pData[137] = vcfbreakpoint;
2001 pData[138] = vcfvelocity;
2004 pData[139] = vcftype;
2006 if (chunksize >= 148) {
2011 double* DimensionRegion::GetReleaseVelocityTable(
curve_type_t releaseVelocityResponseCurve, uint8_t releaseVelocityResponseDepth) {
2013 uint8_t depth = releaseVelocityResponseDepth;
2022 return GetVelocityTable(curveType, depth, 0);
2025 double* DimensionRegion::GetCutoffVelocityTable(
curve_type_t vcfVelocityCurve,
2026 uint8_t vcfVelocityDynamicRange,
2027 uint8_t vcfVelocityScale,
2031 uint8_t depth = vcfVelocityDynamicRange;
2040 return GetVelocityTable(curveType, depth,
2042 ? vcfVelocityScale : 0);
2046 double* DimensionRegion::GetVelocityTable(
curve_type_t curveType, uint8_t depth, uint8_t scaling)
2049 uint32_t tableKey = (curveType<<16) | (depth<<8) | scaling;
2050 if (pVelocityTables->count(tableKey)) {
2051 table = (*pVelocityTables)[tableKey];
2054 table = CreateVelocityTable(curveType, depth, scaling);
2055 (*pVelocityTables)[tableKey] = table;
2070 leverage_ctrl_t DimensionRegion::DecodeLeverageController(_lev_ctrl_t EncodedController) {
2072 switch (EncodedController) {
2074 case _lev_ctrl_none:
2078 case _lev_ctrl_velocity:
2082 case _lev_ctrl_channelaftertouch:
2088 case _lev_ctrl_modwheel:
2092 case _lev_ctrl_breath:
2096 case _lev_ctrl_foot:
2100 case _lev_ctrl_effect1:
2104 case _lev_ctrl_effect2:
2108 case _lev_ctrl_genpurpose1:
2112 case _lev_ctrl_genpurpose2:
2116 case _lev_ctrl_genpurpose3:
2120 case _lev_ctrl_genpurpose4:
2124 case _lev_ctrl_portamentotime:
2128 case _lev_ctrl_sustainpedal:
2132 case _lev_ctrl_portamento:
2136 case _lev_ctrl_sostenutopedal:
2140 case _lev_ctrl_softpedal:
2144 case _lev_ctrl_genpurpose5:
2148 case _lev_ctrl_genpurpose6:
2152 case _lev_ctrl_genpurpose7:
2156 case _lev_ctrl_genpurpose8:
2160 case _lev_ctrl_effect1depth:
2164 case _lev_ctrl_effect2depth:
2168 case _lev_ctrl_effect3depth:
2172 case _lev_ctrl_effect4depth:
2176 case _lev_ctrl_effect5depth:
2184 case _lev_ctrl_CC3_EXT:
2188 case _lev_ctrl_CC6_EXT:
2192 case _lev_ctrl_CC7_EXT:
2196 case _lev_ctrl_CC8_EXT:
2200 case _lev_ctrl_CC9_EXT:
2204 case _lev_ctrl_CC10_EXT:
2208 case _lev_ctrl_CC11_EXT:
2212 case _lev_ctrl_CC14_EXT:
2216 case _lev_ctrl_CC15_EXT:
2220 case _lev_ctrl_CC20_EXT:
2224 case _lev_ctrl_CC21_EXT:
2228 case _lev_ctrl_CC22_EXT:
2232 case _lev_ctrl_CC23_EXT:
2236 case _lev_ctrl_CC24_EXT:
2240 case _lev_ctrl_CC25_EXT:
2244 case _lev_ctrl_CC26_EXT:
2248 case _lev_ctrl_CC27_EXT:
2252 case _lev_ctrl_CC28_EXT:
2256 case _lev_ctrl_CC29_EXT:
2260 case _lev_ctrl_CC30_EXT:
2264 case _lev_ctrl_CC31_EXT:
2268 case _lev_ctrl_CC68_EXT:
2272 case _lev_ctrl_CC69_EXT:
2276 case _lev_ctrl_CC70_EXT:
2280 case _lev_ctrl_CC71_EXT:
2284 case _lev_ctrl_CC72_EXT:
2288 case _lev_ctrl_CC73_EXT:
2292 case _lev_ctrl_CC74_EXT:
2296 case _lev_ctrl_CC75_EXT:
2300 case _lev_ctrl_CC76_EXT:
2304 case _lev_ctrl_CC77_EXT:
2308 case _lev_ctrl_CC78_EXT:
2312 case _lev_ctrl_CC79_EXT:
2316 case _lev_ctrl_CC84_EXT:
2320 case _lev_ctrl_CC85_EXT:
2324 case _lev_ctrl_CC86_EXT:
2328 case _lev_ctrl_CC87_EXT:
2332 case _lev_ctrl_CC89_EXT:
2336 case _lev_ctrl_CC90_EXT:
2340 case _lev_ctrl_CC96_EXT:
2344 case _lev_ctrl_CC97_EXT:
2348 case _lev_ctrl_CC102_EXT:
2352 case _lev_ctrl_CC103_EXT:
2356 case _lev_ctrl_CC104_EXT:
2360 case _lev_ctrl_CC105_EXT:
2364 case _lev_ctrl_CC106_EXT:
2368 case _lev_ctrl_CC107_EXT:
2372 case _lev_ctrl_CC108_EXT:
2376 case _lev_ctrl_CC109_EXT:
2380 case _lev_ctrl_CC110_EXT:
2384 case _lev_ctrl_CC111_EXT:
2388 case _lev_ctrl_CC112_EXT:
2392 case _lev_ctrl_CC113_EXT:
2396 case _lev_ctrl_CC114_EXT:
2400 case _lev_ctrl_CC115_EXT:
2404 case _lev_ctrl_CC116_EXT:
2408 case _lev_ctrl_CC117_EXT:
2412 case _lev_ctrl_CC118_EXT:
2416 case _lev_ctrl_CC119_EXT:
2425 return decodedcontroller;
2431 DimensionRegion::_lev_ctrl_t DimensionRegion::EncodeLeverageController(leverage_ctrl_t DecodedController) {
2432 _lev_ctrl_t encodedcontroller;
2433 switch (DecodedController.type) {
2436 encodedcontroller = _lev_ctrl_none;
2439 encodedcontroller = _lev_ctrl_velocity;
2442 encodedcontroller = _lev_ctrl_channelaftertouch;
2447 switch (DecodedController.controller_number) {
2449 encodedcontroller = _lev_ctrl_modwheel;
2452 encodedcontroller = _lev_ctrl_breath;
2455 encodedcontroller = _lev_ctrl_foot;
2458 encodedcontroller = _lev_ctrl_effect1;
2461 encodedcontroller = _lev_ctrl_effect2;
2464 encodedcontroller = _lev_ctrl_genpurpose1;
2467 encodedcontroller = _lev_ctrl_genpurpose2;
2470 encodedcontroller = _lev_ctrl_genpurpose3;
2473 encodedcontroller = _lev_ctrl_genpurpose4;
2476 encodedcontroller = _lev_ctrl_portamentotime;
2479 encodedcontroller = _lev_ctrl_sustainpedal;
2482 encodedcontroller = _lev_ctrl_portamento;
2485 encodedcontroller = _lev_ctrl_sostenutopedal;
2488 encodedcontroller = _lev_ctrl_softpedal;
2491 encodedcontroller = _lev_ctrl_genpurpose5;
2494 encodedcontroller = _lev_ctrl_genpurpose6;
2497 encodedcontroller = _lev_ctrl_genpurpose7;
2500 encodedcontroller = _lev_ctrl_genpurpose8;
2503 encodedcontroller = _lev_ctrl_effect1depth;
2506 encodedcontroller = _lev_ctrl_effect2depth;
2509 encodedcontroller = _lev_ctrl_effect3depth;
2512 encodedcontroller = _lev_ctrl_effect4depth;
2515 encodedcontroller = _lev_ctrl_effect5depth;
2522 encodedcontroller = _lev_ctrl_CC3_EXT;
2525 encodedcontroller = _lev_ctrl_CC6_EXT;
2528 encodedcontroller = _lev_ctrl_CC7_EXT;
2531 encodedcontroller = _lev_ctrl_CC8_EXT;
2534 encodedcontroller = _lev_ctrl_CC9_EXT;
2537 encodedcontroller = _lev_ctrl_CC10_EXT;
2540 encodedcontroller = _lev_ctrl_CC11_EXT;
2543 encodedcontroller = _lev_ctrl_CC14_EXT;
2546 encodedcontroller = _lev_ctrl_CC15_EXT;
2549 encodedcontroller = _lev_ctrl_CC20_EXT;
2552 encodedcontroller = _lev_ctrl_CC21_EXT;
2555 encodedcontroller = _lev_ctrl_CC22_EXT;
2558 encodedcontroller = _lev_ctrl_CC23_EXT;
2561 encodedcontroller = _lev_ctrl_CC24_EXT;
2564 encodedcontroller = _lev_ctrl_CC25_EXT;
2567 encodedcontroller = _lev_ctrl_CC26_EXT;
2570 encodedcontroller = _lev_ctrl_CC27_EXT;
2573 encodedcontroller = _lev_ctrl_CC28_EXT;
2576 encodedcontroller = _lev_ctrl_CC29_EXT;
2579 encodedcontroller = _lev_ctrl_CC30_EXT;
2582 encodedcontroller = _lev_ctrl_CC31_EXT;
2585 encodedcontroller = _lev_ctrl_CC68_EXT;
2588 encodedcontroller = _lev_ctrl_CC69_EXT;
2591 encodedcontroller = _lev_ctrl_CC70_EXT;
2594 encodedcontroller = _lev_ctrl_CC71_EXT;
2597 encodedcontroller = _lev_ctrl_CC72_EXT;
2600 encodedcontroller = _lev_ctrl_CC73_EXT;
2603 encodedcontroller = _lev_ctrl_CC74_EXT;
2606 encodedcontroller = _lev_ctrl_CC75_EXT;
2609 encodedcontroller = _lev_ctrl_CC76_EXT;
2612 encodedcontroller = _lev_ctrl_CC77_EXT;
2615 encodedcontroller = _lev_ctrl_CC78_EXT;
2618 encodedcontroller = _lev_ctrl_CC79_EXT;
2621 encodedcontroller = _lev_ctrl_CC84_EXT;
2624 encodedcontroller = _lev_ctrl_CC85_EXT;
2627 encodedcontroller = _lev_ctrl_CC86_EXT;
2630 encodedcontroller = _lev_ctrl_CC87_EXT;
2633 encodedcontroller = _lev_ctrl_CC89_EXT;
2636 encodedcontroller = _lev_ctrl_CC90_EXT;
2639 encodedcontroller = _lev_ctrl_CC96_EXT;
2642 encodedcontroller = _lev_ctrl_CC97_EXT;
2645 encodedcontroller = _lev_ctrl_CC102_EXT;
2648 encodedcontroller = _lev_ctrl_CC103_EXT;
2651 encodedcontroller = _lev_ctrl_CC104_EXT;
2654 encodedcontroller = _lev_ctrl_CC105_EXT;
2657 encodedcontroller = _lev_ctrl_CC106_EXT;
2660 encodedcontroller = _lev_ctrl_CC107_EXT;
2663 encodedcontroller = _lev_ctrl_CC108_EXT;
2666 encodedcontroller = _lev_ctrl_CC109_EXT;
2669 encodedcontroller = _lev_ctrl_CC110_EXT;
2672 encodedcontroller = _lev_ctrl_CC111_EXT;
2675 encodedcontroller = _lev_ctrl_CC112_EXT;
2678 encodedcontroller = _lev_ctrl_CC113_EXT;
2681 encodedcontroller = _lev_ctrl_CC114_EXT;
2684 encodedcontroller = _lev_ctrl_CC115_EXT;
2687 encodedcontroller = _lev_ctrl_CC116_EXT;
2690 encodedcontroller = _lev_ctrl_CC117_EXT;
2693 encodedcontroller = _lev_ctrl_CC118_EXT;
2696 encodedcontroller = _lev_ctrl_CC119_EXT;
2700 throw gig::Exception(
"leverage controller number is not supported by the gig format");
2706 return encodedcontroller;
2713 VelocityTableMap::iterator iter;
2714 for (iter = pVelocityTables->begin(); iter != pVelocityTables->end(); iter++) {
2715 double* pTable = iter->second;
2716 if (pTable)
delete[] pTable;
2718 pVelocityTables->clear();
2719 delete pVelocityTables;
2720 pVelocityTables = NULL;
2737 return pVelocityAttenuationTable[MIDIKeyVelocity];
2741 return pVelocityReleaseTable[MIDIKeyVelocity];
2745 return pVelocityCutoffTable[MIDIKeyVelocity];
2753 pVelocityAttenuationTable =
2765 pVelocityAttenuationTable =
2777 pVelocityAttenuationTable =
2838 double* DimensionRegion::CreateVelocityTable(
curve_type_t curveType, uint8_t depth, uint8_t scaling) {
2843 const int lin0[] = { 1, 1, 127, 127 };
2844 const int lin1[] = { 1, 21, 127, 127 };
2845 const int lin2[] = { 1, 45, 127, 127 };
2846 const int lin3[] = { 1, 74, 127, 127 };
2847 const int lin4[] = { 1, 127, 127, 127 };
2850 const int non0[] = { 1, 4, 24, 5, 57, 17, 92, 57, 122, 127, 127, 127 };
2851 const int non1[] = { 1, 4, 46, 9, 93, 56, 118, 106, 123, 127,
2853 const int non2[] = { 1, 4, 46, 9, 57, 20, 102, 107, 107, 127,
2855 const int non3[] = { 1, 15, 10, 19, 67, 73, 80, 80, 90, 98, 98, 127,
2857 const int non4[] = { 1, 25, 33, 57, 82, 81, 92, 127, 127, 127 };
2860 const int spe0[] = { 1, 2, 76, 10, 90, 15, 95, 20, 99, 28, 103, 44,
2861 113, 127, 127, 127 };
2862 const int spe1[] = { 1, 2, 27, 5, 67, 18, 89, 29, 95, 35, 107, 67,
2863 118, 127, 127, 127 };
2864 const int spe2[] = { 1, 1, 33, 1, 53, 5, 61, 13, 69, 32, 79, 74,
2865 85, 90, 91, 127, 127, 127 };
2866 const int spe3[] = { 1, 32, 28, 35, 66, 48, 89, 59, 95, 65, 99, 73,
2867 117, 127, 127, 127 };
2868 const int spe4[] = { 1, 4, 23, 5, 49, 13, 57, 17, 92, 57, 122, 127,
2872 const int spe5[] = { 1, 2, 30, 5, 60, 19, 77, 70, 83, 85, 88, 106,
2873 91, 127, 127, 127 };
2875 const int*
const curves[] = { non0, non1, non2, non3, non4,
2876 lin0, lin1, lin2, lin3, lin4,
2877 spe0, spe1, spe2, spe3, spe4, spe5 };
2879 double*
const table =
new double[128];
2881 const int* curve = curves[curveType * 5 + depth];
2882 const int s = scaling == 0 ? 20 : scaling;
2885 for (
int x = 1 ; x < 128 ; x++) {
2887 if (x > curve[2]) curve += 2;
2888 double y = curve[1] + (x - curve[0]) *
2889 (
double(curve[3] - curve[1]) / (curve[2] - curve[0]));
2894 if (s < 20 && y >= 0.5)
2895 y = y / ((2 - 40.0 / s) * y + 40.0 / s - 1);
2912 for (
int i = 0; i < 256; i++) {
2928 for (
int i = 0; i < dimensionBits; i++) {
2969 uint32_t wavepoolindex = _3lnk->
ReadUint32();
2976 for (
int i = 0 ; i < 8 ; i++) {
3020 const int iMaxDimensions = version3 ? 8 : 5;
3021 const int iMaxDimensionRegions = version3 ? 256 : 32;
3026 const int _3lnkChunkSize = version3 ? 1092 : 172;
3038 for (
int i = 0; i < iMaxDimensions; i++) {
3050 const int iWavePoolOffset = version3 ? 68 : 44;
3051 for (uint i = 0; i < iMaxDimensionRegions; i++) {
3052 int iWaveIndex = -1;
3055 File::SampleList::iterator iter = pFile->
pSamples->begin();
3056 File::SampleList::iterator end = pFile->
pSamples->end();
3057 for (
int index = 0; iter != end; ++iter, ++index) {
3064 store32(&pData[iWavePoolOffset + i * 4], iWaveIndex);
3071 int dimensionRegionNr = 0;
3076 dimensionRegionNr++;
3080 if (dimensionRegionNr == 0)
throw gig::Exception(
"No dimension region found.");
3100 if (veldim == -1)
return;
3116 table =
new uint8_t[128];
3120 int velocityZone = 0;
3122 for (
int k = i ; k < end ; k += step) {
3124 for (; tableidx <= d->
DimensionUpperLimits[veldim] ; tableidx++) table[tableidx] = velocityZone;
3128 for (
int k = i ; k < end ; k += step) {
3130 for (; tableidx <= d->
VelocityUpperLimit ; tableidx++) table[tableidx] = velocityZone;
3144 if (j == veldim) i += skipveldim;
3178 if (pDimDef->
zones < 2)
3179 throw gig::Exception(
"Could not add new dimension, amount of requested zones must always be at least two");
3180 if (pDimDef->
bits < 1)
3181 throw gig::Exception(
"Could not add new dimension, amount of requested requested zone bits must always be at least one");
3183 if (pDimDef->
zones != 2)
3184 throw gig::Exception(
"Could not add new 'sample channel' dimensions, the requested amount of zones must always be 2 for this dimension type");
3185 if (pDimDef->
bits != 1)
3186 throw gig::Exception(
"Could not add new 'sample channel' dimensions, the requested amount of zone bits must always be 1 for this dimension type");
3193 throw gig::Exception(
"Could not add new dimension, max. amount of " + ToString(iMaxDimensions) +
" dimensions already reached");
3195 int iCurrentBits = 0;
3198 if (iCurrentBits >= iMaxDimensions)
3199 throw gig::Exception(
"Could not add new dimension, max. amount of " + ToString(iMaxDimensions) +
" dimension bits already reached");
3200 const int iNewBits = iCurrentBits + pDimDef->
bits;
3201 if (iNewBits > iMaxDimensions)
3202 throw gig::Exception(
"Could not add new dimension, new dimension would exceed max. amount of " + ToString(iMaxDimensions) +
" dimension bits");
3206 throw gig::Exception(
"Could not add new dimension, there is already a dimension of the same type");
3213 for (
int i = 0 ; i < pos ; i++)
3218 for (
int i = 0 ; i < (1 << iCurrentBits) ; i++) {
3239 for (
int i = (1 << iCurrentBits) - (1 << bitpos) ; i >= 0 ; i -= (1 << bitpos)) {
3240 for (
int k = 0 ; k < (1 << bitpos) ; k++) {
3243 for (
int j = 1 ; j < (1 << pDimDef->
bits) ; j++) {
3244 for (
int k = 0 ; k < (1 << bitpos) ; k++) {
3246 if (moveTo) _3prg->
MoveSubChunk(pNewDimRgnListChunk, moveTo);
3259 int mask = (1 << bitpos) - 1;
3260 for (
int z = 0 ; z < pDimDef->
zones ; z++) {
3261 uint8_t upperLimit = uint8_t((z + 1) * 128.0 / pDimDef->
zones - 1);
3262 for (
int i = 0 ; i < 1 << iCurrentBits ; i++) {
3290 int iDimensionNr = -1;
3297 if (iDimensionNr < 0)
throw gig::Exception(
"Invalid dimension_def_t pointer");
3301 for (
int i = 0; i < iDimensionNr; i++)
3306 for (
int i = iDimensionNr + 1; i <
Dimensions; i++)
3313 for (
int iUpperBit = 0; iUpperBit < 1 << iUpperBits; iUpperBit++) {
3315 for (
int iLowerBit = 0; iLowerBit < 1 << iLowerBits; iLowerBit++) {
3317 iObsoleteBit << iLowerBits |
3330 for (
int iFrom = 2, iTo = 1; iFrom < 256 && iTo < 256 - 1; iTo++) {
3332 if (iFrom <= iTo) iFrom = iTo + 1;
3344 for (
int i = iDimensionNr + 1; i <
Dimensions; i++) {
3351 for (
int i = iDimensionNr + 1; i <
Dimensions; i++) {
3381 throw gig::Exception(
"Could not delete dimension zone, no such dimension of given type");
3382 if (oldDef->
zones <= 2)
3383 throw gig::Exception(
"Could not delete dimension zone, because it would end up with only one zone.");
3384 if (zone < 0 || zone >= oldDef->
zones)
3385 throw gig::Exception(
"Could not delete dimension zone, requested zone index out of bounds.");
3387 const int newZoneSize = oldDef->
zones - 1;
3400 tempRgn =
new Region(instr, rgn);
3412 def.
zones = newZoneSize;
3421 int tempReducedDimensionIndex = -1;
3422 for (
int d = 0; d < tempRgn->
Dimensions; ++d) {
3424 tempReducedDimensionIndex = d;
3430 for (
int iDst = 0; iDst < 256; ++iDst) {
3432 if (!dstDimRgn)
continue;
3433 std::map<dimension_t,int> dimCase;
3434 bool isValidZone =
true;
3435 for (
int d = 0, baseBits = 0; d < tempRgn->
Dimensions; ++d) {
3438 (iDst >> baseBits) & ((1 << dstBits) - 1);
3439 baseBits += dstBits;
3442 isValidZone =
false;
3446 if (!isValidZone)
continue;
3449 const bool isLastZone = (dimCase[type] == newZoneSize - 1);
3450 if (dimCase[type] >= zone) dimCase[type]++;
3465 for (
int iSrc = 0; iSrc < 256; ++iSrc) {
3467 if (!srcDimRgn)
continue;
3468 std::map<dimension_t,int> dimCase;
3469 for (
int d = 0, baseBits = 0; d < tempRgn->
Dimensions; ++d) {
3472 (iSrc >> baseBits) & ((1 << srcBits) - 1);
3473 baseBits += srcBits;
3478 if (!dstDimRgn)
continue;
3505 throw gig::Exception(
"Could not split dimension zone, no such dimension of given type");
3506 if (zone < 0 || zone >= oldDef->
zones)
3507 throw gig::Exception(
"Could not split dimension zone, requested zone index out of bounds.");
3509 const int newZoneSize = oldDef->
zones + 1;
3522 tempRgn =
new Region(instr, rgn);
3534 def.
zones = newZoneSize;
3535 if ((1 << oldDef->
bits) < newZoneSize) def.
bits++;
3543 int tempIncreasedDimensionIndex = -1;
3544 for (
int d = 0; d < tempRgn->
Dimensions; ++d) {
3546 tempIncreasedDimensionIndex = d;
3552 for (
int iSrc = 0; iSrc < 256; ++iSrc) {
3554 if (!srcDimRgn)
continue;
3555 std::map<dimension_t,int> dimCase;
3556 bool isValidZone =
true;
3557 for (
int d = 0, baseBits = 0; d <
Dimensions; ++d) {
3560 (iSrc >> baseBits) & ((1 << srcBits) - 1);
3563 isValidZone =
false;
3566 baseBits += srcBits;
3568 if (!isValidZone)
continue;
3571 if (dimCase[type] > zone) dimCase[type]++;
3577 if (dimCase[type] == zone) {
3584 std::map<dimension_t,int> lowerCase = dimCase;
3604 for (
int iSrc = 0; iSrc < 256; ++iSrc) {
3606 if (!srcDimRgn)
continue;
3607 std::map<dimension_t,int> dimCase;
3608 for (
int d = 0, baseBits = 0; d < tempRgn->
Dimensions; ++d) {
3611 (iSrc >> baseBits) & ((1 << srcBits) - 1);
3612 baseBits += srcBits;
3617 if (!dstDimRgn)
continue;
3642 if (oldType == newType)
return;
3645 throw gig::Exception(
"No dimension with provided old dimension type exists on this region");
3647 throw gig::Exception(
"Cannot change to dimension type 'sample channel', because existing dimension does not have 2 zones");
3649 throw gig::Exception(
"There is already a dimension with requested new dimension type on this region");
3651 def->
split_type = __resolveSplitType(newType);
3655 uint8_t bits[8] = {};
3656 for (std::map<dimension_t,int>::const_iterator it = DimCase.begin();
3657 it != DimCase.end(); ++it)
3661 bits[d] = it->second;
3662 goto nextDimCaseSlice;
3689 for (
int i = 0; i < 256; i++) {
3729 if (DimValues[i] <=
pDimensionRegions[bits << bitpos]->DimensionUpperLimits[i])
break;
3738 bits = DimValues[i] & limiter_mask;
3741 dimregidx |= bits << bitpos;
3746 if (!dimreg)
return NULL;
3755 dimregidx |= (bits & limiter_mask) << velbitpos;
3778 if (DimValues[i] <=
pDimensionRegions[bits << bitpos]->DimensionUpperLimits[i])
break;
3787 bits = DimValues[i] & limiter_mask;
3790 dimregidx |= bits << bitpos;
3796 if (!dimreg)
return -1;
3805 dimregidx |= (bits & limiter_mask) << velbitpos;
3854 sample->
FileNo == soughtfileno)
return static_cast<gig::Sample*>(sample);
3899 for (
int i = 0; i < 256; i++) {
3920 for (
int i = 0 ; i <
Triggers ; i++) {
3933 ControllerNumber(0),
3942 for (
int i = 0 ; i <
Triggers ; i++) {
3974 BypassUseController(false),
3976 BypassController(1),
3979 ReleaseTriggerKey(0),
4022 for (
int i = 0 ; i < n ; i++) {
4027 for (
int i = 0 ; i < n ; i++) {
4037 Selector(selector_none),
4061 char* str = reinterpret_cast<char*>(pData);
4064 for (
int i = 0 ; i < n ; i++, pos += 32) {
4070 for (
int i = 0 ; i < n ; i++, pos += 49) {
4071 strncpy(&str[pos],
pPatterns[i].Name.c_str(), 16);
4073 memcpy(&pData[pos + 16], &(
pPatterns[i][0]), 32);
4092 Name.resize(nameSize,
' ');
4093 for (
int i = 0; i < nameSize; ++i)
4096 ckScri->
SetPos(
sizeof(int32_t) + headerSize);
4099 data.resize(scriptSize);
4100 for (
int i = 0; i < scriptSize; ++i)
4108 Name =
"Unnamed Script";
4120 s.resize(data.size(),
' ');
4121 memcpy(&s[0], &data[0], data.size());
4132 data.resize(text.size());
4133 memcpy(&data[0], &text[0], text.size());
4148 __calculateCRC(&data[0], data.size(), crc);
4151 const int chunkSize = 7*
sizeof(int32_t) +
Name.size() + data.size();
4153 else pChunk->
Resize(chunkSize);
4157 store32(&pData[pos], 6*
sizeof(int32_t) +
Name.size());
4158 pos +=
sizeof(int32_t);
4160 pos +=
sizeof(int32_t);
4162 pos +=
sizeof(int32_t);
4164 pos +=
sizeof(int32_t);
4165 store32(&pData[pos],
Bypass ? 1 : 0);
4166 pos +=
sizeof(int32_t);
4167 store32(&pData[pos], crc);
4168 pos +=
sizeof(int32_t);
4169 store32(&pData[pos],
Name.size());
4170 pos +=
sizeof(int32_t);
4171 for (
int i = 0; i <
Name.size(); ++i, ++pos)
4172 pData[pos] =
Name[i];
4173 for (
int i = 0; i < data.size(); ++i, ++pos)
4174 pData[pos] = data[i];
4184 if (this->pGroup = pGroup)
return;
4187 this->pGroup = pGroup;
4201 File* pFile = pGroup->pFile;
4219 Name =
"Default Group";
4225 std::list<Script*>::iterator iter = pScripts->begin();
4226 std::list<Script*>::iterator end = pScripts->end();
4227 while (iter != end) {
4252 for (std::list<Script*>::iterator it = pScripts->begin();
4253 it != pScripts->end(); ++it)
4255 (*it)->UpdateChunks(pProgress);
4269 std::list<Script*>::iterator it = pScripts->begin();
4270 for (uint i = 0; it != pScripts->end(); ++i, ++it)
4271 if (i == index)
return *it;
4289 pScripts->push_back(pScript);
4305 std::list<Script*>::iterator iter =
4306 find(pScripts->begin(), pScripts->end(), pScript);
4307 if (iter == pScripts->end())
4308 throw gig::Exception(
"Could not delete script, could not find given script");
4309 pScripts->erase(iter);
4311 if (pScript->pChunk)
4317 if (pScripts)
return;
4318 pScripts =
new std::list<Script*>;
4325 pScripts->push_back(
new Script(
this, ck));
4351 pMidiRules[0] = NULL;
4363 uint8_t dimkeystart = _3ewg->
ReadUint8();
4378 }
else if (id1 == 0) {
4380 }
else if (id1 == 3) {
4386 else if (id1 != 0 || id2 != 0) {
4391 pMidiRules[i] = NULL;
4403 __notify_progress(pProgress, (
float)
pRegions->size() / (float)
Regions);
4422 ckSCSL->
SetPos(headerSize);
4423 int unknownSpace = slotSize - 2*
sizeof(uint32_t);
4424 for (
int i = 0; i < slotCount; ++i) {
4425 _ScriptPooolEntry e;
4429 scriptPoolFileOffsets.push_back(e);
4435 __notify_progress(pProgress, 1.0f);
4440 RegionList::iterator iter =
pRegions->begin();
4441 RegionList::iterator end =
pRegions->end();
4442 for (; iter != end; ++iter) {
4443 gig::Region* pRegion = static_cast<gig::Region*>(*iter);
4444 for (
int iKey = pRegion->
KeyRange.
low; iKey <= pRegion->KeyRange.high; iKey++) {
4451 for (
int i = 0 ; pMidiRules[i] ; i++) {
4452 delete pMidiRules[i];
4454 delete[] pMidiRules;
4455 if (pScriptRefs)
delete pScriptRefs;
4474 RegionList::iterator iter =
pRegions->begin();
4475 RegionList::iterator end =
pRegions->end();
4476 for (; iter != end; ++iter)
4477 (*iter)->UpdateChunks(pProgress);
4501 pData[10] = dimkeystart;
4504 if (pMidiRules[0] == 0 && _3ewg->
GetSize() >= 34) {
4508 for (
int i = 0 ; pMidiRules[i] ; i++) {
4521 const int slotCount = pScriptRefs->size();
4522 const int headerSize = 3 *
sizeof(uint32_t);
4523 const int slotSize = 2 *
sizeof(uint32_t);
4524 const int totalChunkSize = headerSize + slotCount * slotSize;
4527 else ckSCSL->
Resize(totalChunkSize);
4530 store32(&pData[pos], headerSize);
4531 pos +=
sizeof(uint32_t);
4532 store32(&pData[pos], slotCount);
4533 pos +=
sizeof(uint32_t);
4534 store32(&pData[pos], slotSize);
4535 pos +=
sizeof(uint32_t);
4536 for (
int i = 0; i < slotCount; ++i) {
4539 int bogusFileOffset = 0;
4540 store32(&pData[pos], bogusFileOffset);
4541 pos +=
sizeof(uint32_t);
4542 store32(&pData[pos], (*pScriptRefs)[i].bypass ? 1 : 0);
4543 pos +=
sizeof(uint32_t);
4554 if (pScriptRefs && pScriptRefs->size() > 0) {
4557 const int slotCount = pScriptRefs->size();
4558 const int headerSize = 3 *
sizeof(uint32_t);
4559 ckSCSL->
SetPos(headerSize);
4560 for (
int i = 0; i < slotCount; ++i) {
4561 uint32_t fileOffset =
4562 (*pScriptRefs)[i].script->pChunk->GetFilePos() -
4563 (*pScriptRefs)[i].script->pChunk->GetPos() -
4668 "gig::Instrument::MoveTo() can only be used for moving within " 4669 "the same gig file." 4678 DLS::File::InstrumentList::iterator itFrom =
4679 std::find(list.begin(), list.end(), static_cast<DLS::Instrument*>(
this));
4681 DLS::File::InstrumentList::iterator itTo =
4682 std::find(list.begin(), list.end(), static_cast<DLS::Instrument*>(dst));
4684 list.splice(itTo, list, itFrom);
4706 return pMidiRules[i];
4715 delete pMidiRules[0];
4728 delete pMidiRules[0];
4741 delete pMidiRules[0];
4754 delete pMidiRules[i];
4759 if (pScriptRefs)
return;
4760 pScriptRefs =
new std::vector<_ScriptPooolRef>;
4761 if (scriptPoolFileOffsets.empty())
return;
4763 for (uint k = 0; k < scriptPoolFileOffsets.size(); ++k) {
4764 uint32_t soughtOffset = scriptPoolFileOffsets[k].fileOffset;
4767 for (uint s = 0; group->
GetScript(s); ++s) {
4769 if (script->pChunk) {
4770 uint32_t offset = script->pChunk->
GetFilePos() -
4771 script->pChunk->
GetPos() -
4773 if (offset == soughtOffset)
4775 _ScriptPooolRef ref;
4776 ref.script = script;
4777 ref.bypass = scriptPoolFileOffsets[k].bypass;
4778 pScriptRefs->push_back(ref);
4786 scriptPoolFileOffsets.clear();
4803 if (index >= pScriptRefs->size())
return NULL;
4804 return pScriptRefs->at(index).script;
4844 _ScriptPooolRef ref = { pScript, bypass };
4845 pScriptRefs->push_back(ref);
4864 if (index1 >= pScriptRefs->size() || index2 >= pScriptRefs->size())
4866 _ScriptPooolRef tmp = (*pScriptRefs)[index1];
4867 (*pScriptRefs)[index1] = (*pScriptRefs)[index2];
4868 (*pScriptRefs)[index2] = tmp;
4879 if (index >= pScriptRefs->size())
return;
4880 pScriptRefs->erase( pScriptRefs->begin() + index );
4897 for (
int i = pScriptRefs->size() - 1; i >= 0; --i) {
4898 if ((*pScriptRefs)[i].script == pScript) {
4899 pScriptRefs->erase( pScriptRefs->begin() + i );
4919 return pScriptRefs ? pScriptRefs->size() : scriptPoolFileOffsets.size();
4940 return pScriptRefs ? pScriptRefs->at(index).bypass
4941 : scriptPoolFileOffsets.at(index).bypass;
4961 pScriptRefs->at(index).bypass = bBypass;
4963 scriptPoolFileOffsets.at(index).bypass = bBypass;
4999 scriptPoolFileOffsets = orig->scriptPoolFileOffsets;
5000 pScriptRefs = orig->pScriptRefs;
5003 for (
int i = 0 ; pMidiRules[i] ; i++) {
5004 delete pMidiRules[i];
5007 pMidiRules[0] = NULL;
5013 RegionList::const_iterator it = orig->
pRegions->begin();
5014 for (
int i = 0; i < orig->
Regions; ++i, ++it) {
5018 static_cast<gig::Region*>(*it),
5039 pNameChunk = ck3gnm;
5071 if (strcmp(static_cast<char*>(ck->LoadChunkData()),
"") == 0) {
5096 if (pSample->GetGroup() ==
this)
return pSample;
5114 if (pSample->GetGroup() ==
this)
return pSample;
5134 Group* pOtherGroup = NULL;
5136 if (pOtherGroup !=
this)
break;
5139 "Could not move samples to another group, since there is no " 5140 "other Group. This is a bug, report it!" 5155 0, 2, 19980628 & 0xffff, 19980628 >> 16
5160 0, 3, 20030331 & 0xffff, 20030331 >> 16
5188 pScriptGroups = NULL;
5204 pScriptGroups = NULL;
5210 std::list<Group*>::iterator iter = pGroups->begin();
5211 std::list<Group*>::iterator end = pGroups->end();
5212 while (iter != end) {
5218 if (pScriptGroups) {
5219 std::list<ScriptGroup*>::iterator iter = pScriptGroups->begin();
5220 std::list<ScriptGroup*>::iterator end = pScriptGroups->end();
5221 while (iter != end) {
5225 delete pScriptGroups;
5250 DLS::File::SampleList::iterator it =
pSamples->begin();
5251 for (
int i = 0; i < index; ++i) {
5253 if (it ==
pSamples->end())
return NULL;
5255 if (it ==
pSamples->end())
return NULL;
5256 return static_cast<gig::Sample*>( *it );
5294 if (iter ==
pSamples->end())
throw gig::Exception(
"Could not delete sample, could not find given sample");
5303 for (
Region* region = instrument->GetFirstRegion() ; region ;
5304 region = instrument->GetNextRegion()) {
5306 if (region->GetSample() == pSample) region->SetSample(NULL);
5308 for (
int i = 0 ; i < region->DimensionRegions ; i++) {
5331 int iSampleIndex = 0;
5340 int nameLen = name.length();
5342 if (nameLen > 4 && name.substr(nameLen - 4) ==
".gig") nameLen -= 4;
5344 for (
int fileNo = 0 ; ; ) {
5347 unsigned long wvplFileOffset = wvpl->
GetFilePos();
5352 const float subprogress = (float) iSampleIndex / (
float) iTotalSamples;
5353 __notify_progress(pProgress, subprogress);
5355 unsigned long waveFileOffset = wave->
GetFilePos();
5356 pSamples->push_back(
new Sample(
this, wave, waveFileOffset - wvplFileOffset, fileNo));
5363 if (fileNo == lastFileNo)
break;
5367 sprintf(suffix,
".gx%02d", fileNo);
5368 name.replace(nameLen, 5, suffix);
5374 __notify_progress(pProgress, 1.0);
5403 __divide_progress(pProgress, &subprogress, 3.0f, 0.0f);
5404 __notify_progress(&subprogress, 0.0f);
5407 __notify_progress(&subprogress, 1.0f);
5410 if (pProgress && pProgress->
callback) {
5414 __notify_progress(&subprogress, 0.0f);
5416 __notify_progress(&subprogress, 1.0f);
5489 static int iCallCount = -1;
5491 std::map<Group*,Group*> mGroups;
5492 std::map<Sample*,Sample*> mSamples;
5495 for (
int i = 0; pFile->
GetGroup(i); ++i) {
5498 "COPY" + ToString(iCallCount) +
"_" + pFile->
GetGroup(i)->
Name;
5503 for (
int i = 0; pFile->
GetSample(i); ++i) {
5535 for (
int i = 0; pFile->
GetSample(i); ++i) {
5563 if (lstInstruments) {
5564 int iInstrumentIndex = 0;
5569 const float localProgress = (float) iInstrumentIndex / (
float)
Instruments;
5570 __notify_progress(pProgress, localProgress);
5574 __divide_progress(pProgress, &subprogress,
Instruments, iInstrumentIndex);
5582 __notify_progress(pProgress, 1.0);
5594 int iWaveIndex = -1;
5595 File::SampleList::iterator iter =
pSamples->begin();
5596 File::SampleList::iterator end =
pSamples->end();
5597 for (
int index = 0; iter != end; ++iter, ++index) {
5598 if (*iter == pSample) {
5603 if (iWaveIndex < 0)
throw gig::Exception(
"Could not update crc, could not find sample");
5606 _3crc->
SetPos(iWaveIndex * 8);
5615 GroupsIterator = pGroups->begin();
5616 return *GroupsIterator;
5620 if (!pGroups)
return NULL;
5622 return (GroupsIterator == pGroups->end()) ? NULL : *GroupsIterator;
5633 GroupsIterator = pGroups->begin();
5634 for (uint i = 0; GroupsIterator != pGroups->end(); i++) {
5635 if (i == index)
return *GroupsIterator;
5653 GroupsIterator = pGroups->begin();
5654 for (uint i = 0; GroupsIterator != pGroups->end(); ++GroupsIterator, ++i)
5655 if ((*GroupsIterator)->Name == name)
return *GroupsIterator;
5664 pGroups->push_back(pGroup);
5679 std::list<Group*>::iterator iter = find(pGroups->begin(), pGroups->end(), pGroup);
5680 if (iter == pGroups->end())
throw gig::Exception(
"Could not delete group, could not find given group");
5681 if (pGroups->size() == 1)
throw gig::Exception(
"Cannot delete group, there must be at least one default group!");
5687 pGroups->erase(iter);
5703 std::list<Group*>::iterator iter = find(pGroups->begin(), pGroups->end(), pGroup);
5704 if (iter == pGroups->end())
throw gig::Exception(
"Could not delete group, could not find given group");
5705 if (pGroups->size() == 1)
throw gig::Exception(
"Cannot delete group, there must be at least one default group!");
5708 pGroups->erase(iter);
5713 if (!pGroups) pGroups =
new std::list<Group*>;
5723 strcmp(static_cast<char*>(ck->
LoadChunkData()),
"") == 0)
break;
5725 pGroups->push_back(
new Group(
this, ck));
5732 if (!pGroups->size()) {
5734 pGroup->
Name =
"Default Group";
5735 pGroups->push_back(pGroup);
5748 std::list<ScriptGroup*>::iterator it = pScriptGroups->begin();
5749 for (uint i = 0; it != pScriptGroups->end(); ++i, ++it)
5750 if (i == index)
return *it;
5764 std::list<ScriptGroup*>::iterator it = pScriptGroups->begin();
5765 for (uint i = 0; it != pScriptGroups->end(); ++i, ++it)
5766 if ((*it)->Name == name)
return *it;
5781 pScriptGroups->push_back(pScriptGroup);
5782 return pScriptGroup;
5799 std::list<ScriptGroup*>::iterator iter =
5800 find(pScriptGroups->begin(), pScriptGroups->end(), pScriptGroup);
5801 if (iter == pScriptGroups->end())
5802 throw gig::Exception(
"Could not delete script group, could not find given script group");
5803 pScriptGroups->erase(iter);
5804 for (
int i = 0; pScriptGroup->
GetScript(i); ++i)
5806 if (pScriptGroup->pList)
5808 delete pScriptGroup;
5812 if (pScriptGroups)
return;
5813 pScriptGroups =
new std::list<ScriptGroup*>;
5820 pScriptGroups->push_back(
new ScriptGroup(
this, lst));
5848 if (pScriptGroups) {
5850 if (pScriptGroups->empty()) {
5857 for (std::list<ScriptGroup*>::iterator it = pScriptGroups->begin();
5858 it != pScriptGroups->end(); ++it)
5860 (*it)->UpdateChunks(pProgress);
5873 if (first != info) {
5894 for (
int i = 0 ; i < 128 ; i++) {
5895 if (i >= pGroups->size()) ::SaveString(
CHUNK_ID_3GNM, _3gnm, _3gnl,
"",
"",
true, 64);
5900 std::list<Group*>::iterator iter = pGroups->begin();
5901 std::list<Group*>::iterator end = pGroups->end();
5902 for (; iter != end; ++iter) {
5903 (*iter)->UpdateChunks(pProgress);
5923 int sublen =
pSamples->size() / 8 + 49;
5928 if (einf->
GetSize() != einfSize) {
5932 }
else if (newFile) {
5938 std::map<gig::Sample*,int> sampleMap;
5941 sampleMap[pSample] = sampleIdx++;
5944 int totnbusedsamples = 0;
5945 int totnbusedchannels = 0;
5946 int totnbregions = 0;
5947 int totnbdimregions = 0;
5949 int instrumentIdx = 0;
5951 memset(&pData[48], 0, sublen - 48);
5955 int nbusedsamples = 0;
5956 int nbusedchannels = 0;
5957 int nbdimregions = 0;
5960 memset(&pData[(instrumentIdx + 1) * sublen + 48], 0, sublen - 48);
5962 for (
Region* region = instrument->GetFirstRegion() ; region ;
5963 region = instrument->GetNextRegion()) {
5964 for (
int i = 0 ; i < region->DimensionRegions ; i++) {
5967 int sampleIdx = sampleMap[d->
pSample];
5968 int byte = 48 + sampleIdx / 8;
5969 int bit = 1 << (sampleIdx & 7);
5970 if ((pData[(instrumentIdx + 1) * sublen + byte] & bit) == 0) {
5971 pData[(instrumentIdx + 1) * sublen +
byte] |= bit;
5975 if ((pData[
byte] & bit) == 0) {
5984 nbdimregions += region->DimensionRegions;
5988 store32(&pData[(instrumentIdx + 1) * sublen + 4], nbusedchannels);
5989 store32(&pData[(instrumentIdx + 1) * sublen + 8], nbusedsamples);
5990 store32(&pData[(instrumentIdx + 1) * sublen + 12], 1);
5991 store32(&pData[(instrumentIdx + 1) * sublen + 16], instrument->Regions);
5992 store32(&pData[(instrumentIdx + 1) * sublen + 20], nbdimregions);
5993 store32(&pData[(instrumentIdx + 1) * sublen + 24], nbloops);
5995 store32(&pData[(instrumentIdx + 1) * sublen + 36], instrumentIdx);
5996 store32(&pData[(instrumentIdx + 1) * sublen + 40],
pSamples->size());
5999 totnbregions += instrument->Regions;
6000 totnbdimregions += nbdimregions;
6001 totnbloops += nbloops;
6006 store32(&pData[4], totnbusedchannels);
6007 store32(&pData[8], totnbusedsamples);
6009 store32(&pData[16], totnbregions);
6010 store32(&pData[20], totnbdimregions);
6011 store32(&pData[24], totnbloops);
6014 store32(&pData[40],
pSamples->size());
6027 }
else if (newFile) {
6042 instrument->UpdateScriptFileOffsets();
6082 std::cout <<
"gig::Exception: " <<
Message << std::endl;
range_t KeySwitchRange
Key range for key switch selector.
bool LFO2FlipPhase
Inverts phase of the filter cutoff LFO wave.
void UpdateRegionKeyTable()
void SetScriptAsText(const String &text)
Replaces the current script with the new script source code text given by text.
void AddContentOf(File *pFile)
Add content of another existing file.
void MoveAll()
Move all members of this group to another group (preferably the 1st one except this).
bool IsNew() const
Returns true if this file has been created new from scratch and has not been stored to disk yet.
unsigned long WriteUint32(uint32_t *pData, unsigned long WordCount=1)
Writes WordCount number of 32 Bit unsigned integer words from the buffer pointed by pData to the chun...
dim_bypass_ctrl_t DimensionBypass
If defined, the MIDI controller can switch on/off the dimension in realtime.
Encapsulates articulation informations of a dimension region.
range_t DimensionKeyRange
0-127 (where 0 means C1 and 127 means G9)
sample_loop_t * pSampleLoops
Points to the beginning of a sample loop array, or is NULL if there are no loops defined.
#define GIG_EG_CTR_RELEASE_INFLUENCE_EXTRACT(x)
uint8_t VCFVelocityScale
(0-127) Amount velocity controls VCF cutoff frequency (only if no other VCF cutoff controller is defi...
void SetDimensionType(dimension_t oldType, dimension_t newType)
Change type of an existing dimension.
unsigned long FrameOffset
Current offset (sample points) in current sample frame (for decompression only).
bool reverse
If playback direction is currently backwards (in case there is a pingpong or reverse loop defined).
uint8_t AltSustain2Key
Key triggering a second set of alternate sustain samples.
uint32_t Regions
Reflects the number of Region defintions this Instrument has.
Region * GetRegion(unsigned int Key)
Returns the appropriate Region for a triggered note.
void AddSample(Sample *pSample)
Move Sample given by pSample from another Group to this Group.
String GetScriptAsText()
Returns the current script (i.e.
MidiRuleAlternator * AddMidiRuleAlternator()
Adds the alternator MIDI rule to the instrument.
Sample * AddSample()
Add a new sample.
bool VCFEnabled
If filter should be used.
void AddDimension(dimension_def_t *pDimDef)
Einstein would have dreamed of it - create a new dimension.
stream_whence_t
File stream position dependent to these relations.
uint32_t FineTune
Specifies the fraction of a semitone up from the specified MIDI unity note field. A value of 0x800000...
unsigned long Read(void *pData, unsigned long WordCount, unsigned long WordSize)
Reads WordCount number of data words with given WordSize and copies it into a buffer pointed by pData...
uint8_t BypassKey
Key to be used to bypass the sustain note.
uint16_t LFO1ControlDepth
Controller depth influencing sample amplitude LFO pitch (0 - 1200 cents).
Chunk * GetFirstSubChunk()
Returns the first subchunk within the list.
Group of Gigasampler samples.
uint32_t LoopType
Defines how the waveform samples will be looped (appropriate loop types for the gig format are define...
uint8_t VCFVelocityDynamicRange
0x04 = lowest, 0x00 = highest .
String Name
Stores the name of this Group.
DimensionRegion * GetDimensionRegionByBit(const uint8_t DimBits[8])
Returns the appropriate DimensionRegion for the given dimension bit numbers (zone index).
Special dimension for triggering samples on releasing a key.
uint16_t PitchbendRange
Number of semitones pitchbend controller can pitch (default is 2).
double EG1Release
Release time of the sample amplitude EG (0.000 - 60.000s).
unsigned long ReadAndLoop(void *pBuffer, unsigned long SampleCount, playback_state_t *pPlaybackState, DimensionRegion *pDimRgn, buffer_t *pExternalDecompressionBuffer=NULL)
Reads SampleCount number of sample points from the position stored in pPlaybackState into the buffer ...
#define GIG_EG_CTR_ATTACK_INFLUENCE_EXTRACT(x)
uint8_t Triggers
Number of triggers.
#define GIG_EG_CTR_RELEASE_INFLUENCE_ENCODE(x)
uint32_t GetChunkID()
Chunk ID in unsigned integer representation.
vcf_type_t VCFType
Defines the general filter characteristic (lowpass, highpass, bandpass, etc.).
Script * AddScript()
Add new instrument script.
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.
void __ensureMandatoryChunksExist()
Checks if all (for DLS) mandatory chunks exist, if not they will be created.
uint32_t LoopSize
Caution: Use the respective fields in the DimensionRegion instead of this one! (Intended purpose: Len...
Instrument * AddInstrument()
Add a new instrument definition.
virtual void LoadScriptGroups()
Script * GetScript(uint index)
Get instrument script.
loop_type_t LoopType
Caution: Use the respective field in the DimensionRegion instead of this one! (Intended purpose: The ...
lfo1_ctrl_t LFO1Controller
MIDI Controller which controls sample amplitude LFO.
#define GIG_VCF_RESONANCE_CTRL_EXTRACT(x)
Only internally controlled.
Sample * GetFirstSample()
Returns a pointer to the first Sample object of the file, NULL otherwise.
uint8_t low
Low value of range.
void UpdateChunks(progress_t *pProgress)
Apply this script group to the respective RIFF chunks.
uint16_t SampleStartOffset
Number of samples the sample start should be moved (0 - 2000).
MIDI rule for triggering notes by control change events.
virtual void CopyAssign(const Region *orig)
Make a (semi) deep copy of the Region object given by orig and assign it to this object.
NKSP stands for "Is Not KSP" (default). Refer to the NKSP Reference Manual for details about this scr...
void(* callback)(progress_t *)
Callback function pointer which has to be assigned to a function for progress notification.
uint8_t Key
Key to trigger.
unsigned long GetSize() const
Returns sample size.
unsigned long WorstCaseFrameSize
For compressed samples only: size (in bytes) of the largest possible sample frame.
void AddScriptSlot(Script *pScript, bool bypass=false)
Add new instrument script slot (gig format extension).
bool EG1Hold
If true, Decay1 stage should be postponed until the sample reached the sample loop start.
range_t PlayRange
Key range of the playable keys in the instrument.
uint16_t ThresholdTime
Maximum time (ms) between two notes that should be played legato.
dimension values are already the sought bit number
uint8_t VelocityResponseCurveScaling
0 - 127 (usually you don't have to interpret this parameter, use GetVelocityAttenuation() instead).
bool Descending
If the change in CC value should be downwards.
Group * GetGroup() const
Returns pointer to the Group this Sample belongs to.
double GetVelocityCutoff(uint8_t MIDIKeyVelocity)
unsigned long Size
Size of the actual data in the buffer in bytes.
Instrument * GetFirstInstrument()
Returns a pointer to the first Instrument object of the file, NULL otherwise.
unsigned long SetPos(unsigned long 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 ReadString(String &s, int size)
Reads a null-padded string of size characters and copies it into the string s.
Region * RegionKeyTable[128]
fast lookup for the corresponding Region of a MIDI key
uint8_t ReleaseTriggerKey
Key triggering release samples.
Sample(File *pFile, RIFF::List *waveList, unsigned long WavePoolOffset, unsigned long fileNo=0)
Constructor.
uint32_t * pWavePoolTable
For MIDI tools like legato and repetition mode.
bool VCFKeyboardTracking
If true: VCF cutoff frequence will be dependend to the note key position relative to the defined brea...
uint32_t WavePoolTableIndex
uint8_t Velocity
Velocity of the note to trigger. 255 means that velocity should depend on the speed of the controller...
void CopyAssignWave(const Sample *orig)
Should be called after CopyAssignMeta() and File::Save() sequence.
uint32_t crc
CRC-32 checksum of the raw sample data.
Defines a controller that has a certain contrained influence on a particular synthesis parameter (use...
uint16_t Channels
Number of channels represented in the waveform data, e.g. 1 for mono, 2 for stereo (defaults to 1=mon...
uint8_t Controller
CC number for controller selector.
void SetVCFVelocityScale(uint8_t scaling)
Updates the respective member variable and the lookup table / cache that depends on this value.
RIFF::List * pCkInstrument
Defines Region information of a Gigasampler/GigaStudio instrument.
#define GIG_EXP_ENCODE(x)
void UpdateVelocityTable()
unsigned long SamplesPerFrame
For compressed samples only: number of samples in a full sample frame.
uint32_t LoopPlayCount
Number of times the loop should be played (a value of 0 = infinite).
uint8_t ReleaseTriggerDecay
0 - 8
lfo3_ctrl_t LFO3Controller
MIDI Controller which controls the sample pitch LFO.
static unsigned int Instances
Number of instances of class Sample.
bool Chained
If all patterns should be chained together.
uint32_t MIDIUnityNote
Specifies the musical note at which the sample will be played at it's original sample rate.
uint8_t ControllerNumber
MIDI controller number.
#define GIG_PITCH_TRACK_EXTRACT(x)
List * GetSubList(uint32_t ListType)
Returns sublist chunk with list type ListType within this chunk list.
void DeleteSubChunk(Chunk *pSubChunk)
Removes a sub chunk.
uint8_t ChannelOffset
Audio output where the audio signal of the dimension region should be routed to (0 - 9).
void Resize(int iNewSize)
Resize sample.
Defines Sample Loop Points.
Region * GetParent() const
uint8_t VCFResonance
Firm internal filter resonance weight.
Standard 8 bit US ASCII character encoding (default).
bool VCFResonanceDynamic
If true: Increases the resonance Q according to changes of controllers that actually control the VCF ...
Language_t Language
Programming language and dialect the script is written in.
void DeleteMidiRule(int i)
Deletes a MIDI rule from the instrument.
unsigned int Dimensions
Number of defined dimensions, do not alter!
Only controlled by external modulation wheel.
#define GIG_VCF_RESONANCE_CTRL_ENCODE(x)
vcf_cutoff_ctrl_t VCFCutoffController
Specifies which external controller has influence on the filter cutoff frequency.
#define CHUNK_HEADER_SIZE
virtual void SetGain(int32_t gain)
MidiRuleCtrlTrigger * AddMidiRuleCtrlTrigger()
Adds the "controller trigger" MIDI rule to the instrument.
unsigned long RemainingBytes()
Returns the number of bytes left to read in the chunk body.
void LoadString(RIFF::Chunk *ck, std::string &s, int strLength)
double EG1Decay1
Decay time of the sample amplitude EG (0.000 - 60.000s).
List * GetFirstSubList()
Returns the first sublist within the list (that is a subchunk with chunk ID "LIST").
DimensionRegion * GetDimensionRegionByValue(const uint DimValues[8])
Use this method in your audio engine to get the appropriate dimension region with it's articulation d...
void UpdateScriptFileOffsets()
lfo2_ctrl_t LFO2Controller
MIDI Controlle which controls the filter cutoff LFO.
Compression_t Compression
Whether the script was/should be compressed, and if so, which compression algorithm shall be used.
void LoadDimensionRegions(RIFF::List *rgn)
Different samples triggered each time a note is played, any key advances the counter.
bool Dithered
For 24-bit compressed samples only: if dithering was used during compression with bit reduction.
Region * GetFirstRegion()
Returns the first Region of the instrument.
String libraryVersion()
Returns version of this C++ library.
uint8_t VelocityUpperLimit
Defines the upper velocity value limit of a velocity split (only if an user defined limit was set,...
uint8_t ReleaseVelocityResponseDepth
Dynamic range of release velocity affecting envelope time (0 - 4).
void RemoveAllScriptReferences()
std::list< Sample * > SampleList
Will be thrown whenever a gig specific error occurs while trying to access a Gigasampler File.
buffer_t LoadSampleDataWithNullSamplesExtension(uint NullSamplesCount)
Loads (and uncompresses if needed) the whole sample wave into RAM.
void UpdateChunks(progress_t *pProgress)
Apply this script to the respective RIFF chunks.
InstrumentList::iterator InstrumentsIterator
Instrument(File *pFile, RIFF::List *insList, progress_t *pProgress=NULL)
void GenerateDLSID()
Generates a new DLSID for the resource.
uint8_t in_end
End position of fade in.
void SetVCFCutoffController(vcf_cutoff_ctrl_t controller)
Updates the respective member variable and the lookup table / cache that depends on this value.
unsigned long WorstCaseMaxSamples(buffer_t *pDecompressionBuffer)
static const DLS::version_t VERSION_2
Reflects Gigasampler file format version 2.0 (1998-06-28).
Sample * pSample
Points to the Sample which is assigned to the dimension region.
uint FrameSize
Reflects the size (in bytes) of one single sample point (only if known sample data format is used,...
buffer_t LoadSampleData()
Loads (and uncompresses if needed) the whole sample wave into RAM.
uint16_t ReleaseTime
Release time.
uint32_t LoopStart
Caution: Use the respective field in the DimensionRegion instead of this one! (Intended purpose: The ...
Group * GetNextGroup()
Returns a pointer to the next Group object of the file, NULL otherwise.
unsigned long ReadUint32(uint32_t *pData, unsigned long WordCount=1)
Reads WordCount number of 32 Bit unsigned integer words and copies it into the buffer pointed by pDat...
void SetVCFVelocityCurve(curve_type_t curve)
Updates the respective member variable and the lookup table / cache that depends on this value.
double EG2Decay1
Decay time of the filter cutoff EG (0.000 - 60.000s).
uint8_t EG1ControllerAttackInfluence
Amount EG1 Controller has influence on the EG1 Attack time (0 - 3, where 0 means off).
unsigned long GetPos()
Position within the chunk data body.
#define INITIAL_SAMPLE_BUFFER_SIZE
Initial size of the sample buffer which is used for decompression of compressed sample wave streams -...
unsigned long position
Current position within the sample.
String pArticulations[32]
Names of the articulations.
void SetAutoLoad(bool b)
Enable / disable automatic loading.
MidiRule * GetMidiRule(int i)
Returns a MIDI rule of the instrument.
smpte_format_t SMPTEFormat
Specifies the Society of Motion Pictures and Television E time format used in the following SMPTEOffs...
uint16_t low
Low value of range.
double SampleAttenuation
Sample volume (calculated from DLS::Sampler::Gain)
bool b64BitWavePoolOffsets
double EG1Decay2
Only if EG1InfiniteSustain == false: 2nd decay stage time of the sample amplitude EG (0....
void SetFixedStringLengths(const string_length_t *lengths)
Forces specific Info fields to be of a fixed length when being saved to a file.
void RemoveScript(Script *pScript)
Remove reference to given Script (gig format extension).
uint8_t BypassController
Controller to be used to bypass the sustain note.
attenuation_ctrl_t AttenuationController
MIDI Controller which has influence on the volume level of the sample (or entire sample group).
static buffer_t InternalDecompressionBuffer
Buffer used for decompression as well as for truncation of 24 Bit -> 16 Bit samples.
static void DestroyDecompressionBuffer(buffer_t &DecompressionBuffer)
Free decompression buffer, previously created with CreateDecompressionBuffer().
Pointer address and size of a buffer.
virtual void LoadSamples()
uint8_t in_start
Start position of fade in.
uint8_t Patterns
Number of alternator patterns.
unsigned long Read(void *pBuffer, unsigned long SampleCount, buffer_t *pExternalDecompressionBuffer=NULL)
Reads SampleCount number of sample points from the current position into the buffer pointed by pBuffe...
dimension_t dimension
Specifies which source (usually a MIDI controller) is associated with the dimension.
bool Bypass
Global bypass: if enabled, this script shall not be executed by the sampler for any instrument.
range_t KeyRange
Key range for legato notes.
unsigned long SamplesInLastFrame
For compressed samples only: length of the last sample frame.
bool EG2ControllerInvert
Invert values coming from defined EG2 controller.
uint8_t Articulations
Number of articulations in the instrument.
Group * GetFirstGroup()
Returns a pointer to the first Group object of the file, NULL otherwise.
Group * GetGroup(uint index)
Returns the group with the given index.
uint8_t VelSensitivity
How sensitive the velocity should be to the speed of the controller change.
String Name
Arbitrary name of the script, which may be displayed i.e. in an instrument editor.
uint32_t DimensionRegions
Total number of DimensionRegions this Region contains, do not alter!
Instrument * AddDuplicateInstrument(const Instrument *orig)
Add a duplicate of an existing instrument.
uint ScriptSlotCount() const
Instrument's amount of script slots.
bool MSDecode
Gigastudio flag: defines if Mid Side Recordings should be decoded.
Key Velocity (this is the only dimension in gig2 where the ranges can exactly be defined).
bool EG1InfiniteSustain
If true, instead of going into Decay2 phase, Decay1 level will be hold until note will be released.
bool Compressed
If the sample wave is compressed (probably just interesting for instrument and sample editors,...
void ReleaseSampleData()
Frees the cached sample from RAM if loaded with LoadSampleData() previously.
uint32_t SampleLoops
Reflects the number of sample loops.
More poles than normal lowpass.
virtual void Save(const String &Path, progress_t *pProgress=NULL)
Save changes to another file.
uint16_t LFO2InternalDepth
Firm pitch of the filter cutoff LFO (0 - 1200 cents).
void Resize(int iNewSize)
Resize sample.
void DeleteDimensionZone(dimension_t type, int zone)
Delete one split zone of a dimension (decrement zone amount).
uint16_t LFO1InternalDepth
Firm pitch of the sample amplitude LFO (0 - 1200 cents).
The difference between none and none2 is unknown.
virtual void LoadInstruments()
float zone_size
Intended for internal usage: reflects the size of each zone (128/zones) for normal split types only,...
virtual void UpdateFileOffsets()
Updates all file offsets stored all over the file.
bool PitchTrack
If true: sample will be pitched according to the key position (this will be disabled for drums for ex...
double GetVelocityRelease(uint8_t MIDIKeyVelocity)
unsigned long Write(void *pBuffer, unsigned long SampleCount)
Write sample wave data.
unsigned long ReadInt32(int32_t *pData, unsigned long WordCount=1)
Reads WordCount number of 32 Bit signed integer words and copies it into the buffer pointed by pData.
bool BypassUseController
If a controller should be used to bypass the sustain note.
float __range_min
Only for internal usage, do not modify!
unsigned int Layers
Amount of defined layers (1 - 32). A value of 1 actually means no layering, a value > 1 means there i...
void * pStart
Points to the beginning of the buffer.
bool EG2InfiniteSustain
If true, instead of going into Decay2 phase, Decay1 level will be hold until note will be released.
unsigned long SamplePos
For compressed samples only: stores the current position (in sample points).
Group * pGroup
pointer to the Group this sample belongs to (always not-NULL)
Chunk * GetSubChunk(uint32_t ChunkID)
Returns subchunk with chunk ID ChunkID within this chunk list.
Script(ScriptGroup *group, RIFF::Chunk *ckScri)
struct gig::MidiRuleAlternator::pattern_t pPatterns[32]
A pattern is a sequence of articulation numbers.
Chunk * GetNextSubChunk()
Returns the next subchunk within the list.
MidiRuleLegato * AddMidiRuleLegato()
Adds the legato MIDI rule to the instrument.
std::list< Instrument * > InstrumentList
uint8_t EG2ControllerAttackInfluence
Amount EG2 Controller has influence on the EG2 Attack time (0 - 3, where 0 means off).
Exception(String Message)
bool SelfMask
If true: high velocity notes will stop low velocity notes at the same note, with that you can save vo...
int16_t LFO3ControlDepth
Controller depth of the sample pitch LFO (-1200 - +1200 cents).
#define GET_PARAMS(params)
void RemoveScriptSlot(uint index)
Remove script slot.
double EG3Attack
Attack time of the sample pitch EG (0.000 - 10.000s).
void DeleteDimension(dimension_def_t *pDimDef)
Delete an existing dimension.
void UpdateChunks(uint8_t *pData) const
void UpdateChunks(uint8_t *pData) const
Instrument * GetNextInstrument()
Returns a pointer to the next Instrument object of the file, NULL otherwise.
unsigned long SamplesTotal
Reflects total number of sample points (only if known sample data format is used, 0 otherwise),...
uint8_t LegatoSamples
Number of legato samples per key in each direction (always 12)
uint8_t out_end
End postition of fade out.
void DeleteGroupOnly(Group *pGroup)
Delete a group.
double EG2Attack
Attack time of the filter cutoff EG (0.000 - 60.000s).
uint16_t BitDepth
Size of each sample per channel (only if known sample data format is used, 0 otherwise).
bool InvertAttenuationController
Inverts the values coming from the defined Attenuation Controller.
double LFO1Frequency
Frequency of the sample amplitude LFO (0.10 - 10.00 Hz).
uint32_t GetListType()
Returns unsigned integer representation of the list's ID.
DimensionRegion(Region *pParent, RIFF::List *_3ewl)
uint32_t LoopID
Specifies the unique ID that corresponds to one of the defined cue points in the cue point list (only...
bool LFO1FlipPhase
Inverts phase of the sample amplitude LFO wave.
uint8_t AltSustain1Key
Key triggering alternate sustain samples.
void DeleteSample(Sample *pSample)
Delete a sample.
unsigned long GetFilePos()
Current, actual offset in file.
Region(Instrument *pInstrument, RIFF::List *rgnList)
static buffer_t CreateDecompressionBuffer(unsigned long MaxReadSize)
Allocates a decompression buffer for streaming (compressed) samples with Sample::Read().
bool LFO3Sync
If set to true only one LFO should be used for all voices.
bool IsScriptSlotBypassed(uint index)
Whether script execution shall be skipped.
double LFO3Frequency
Frequency of the sample pitch LFO (0.10 - 10.00 Hz).
static const DLS::version_t VERSION_3
Reflects Gigasampler file format version 3.0 (2003-03-31).
uint32_t LoopLength
Length of the looping area (in sample points).
void DeleteRegion(Region *pRegion)
#define GIG_EG_CTR_ATTACK_INFLUENCE_ENCODE(x)
ScriptGroup * AddScriptGroup()
Add new instrument script group.
#define GIG_EG_CTR_DECAY_INFLUENCE_ENCODE(x)
DimensionRegion * pDimensionRegions[256]
Pointer array to the 32 (gig2) or 256 (gig3) possible dimension regions (reflects NULL for dimension ...
uint32_t Product
Specifies the MIDI model ID defined by the manufacturer corresponding to the Manufacturer field....
bool LFO1Sync
If set to true only one LFO should be used for all voices.
unsigned long ReadInt16(int16_t *pData, unsigned long WordCount=1)
Reads WordCount number of 16 Bit signed integer words and copies it into the buffer pointed by pData.
split_type_t
Intended for internal usage: will be used to convert a dimension value into the corresponding dimensi...
Alternating loop (forward/backward, also known as Ping Pong)
ScriptGroup * GetScriptGroup(uint index)
Get instrument script group (by index).
unsigned long loop_cycles_left
How many times the loop has still to be passed, this value will be decremented with each loop cycle.
void SetSampleChecksum(Sample *pSample, uint32_t crc)
Updates the 3crc chunk with the checksum of a sample.
Sample * GetNextSample()
Returns the next Sample of the Group.
uint8_t EG2ControllerReleaseInfluence
Amount EG2 Controller has influence on the EG2 Release time (0 - 3, where 0 means off).
unsigned long Write(void *pData, unsigned long WordCount, unsigned long WordSize)
Writes WordCount number of data words with given WordSize from the buffer pointed by pData.
Used for indicating the progress of a certain task.
SampleList::iterator SamplesIterator
List * GetParent()
Returns pointer to the chunk's parent list chunk.
uint16_t EG2PreAttack
Preattack value of the filter cutoff EG (0 - 1000 permille).
Chunk * AddSubChunk(uint32_t uiChunkID, uint uiBodySize)
Creates a new sub chunk.
uint32_t Loops
Caution: Use the respective field in the DimensionRegion instead of this one! (Intended purpose: Numb...
bool LFO2Sync
If set to true only one LFO should be used for all voices.
uint32_t SMPTEOffset
The SMPTE Offset value specifies the time offset to be used for the synchronization / calibration to ...
unsigned long FileNo
File number (> 0 when sample is stored in an extension file, 0 when it's in the gig)
void SplitDimensionZone(dimension_t type, int zone)
Divide split zone of a dimension in two (increment zone amount).
Sample * GetFirstSample(progress_t *pProgress=NULL)
Returns a pointer to the first Sample object of the file, NULL otherwise.
bool EG1ControllerInvert
Invert values coming from defined EG1 controller.
Ordinary MIDI control change controller, see field 'controller_number'.
virtual void UpdateChunks(progress_t *pProgress)
Apply Instrument with all its Regions to the respective RIFF chunks.
version_t * pVersion
Points to a version_t structure if the file provided a version number else is set to NULL.
void DeleteInstrument(Instrument *pInstrument)
Delete an instrument.
uint16_t LFO2ControlDepth
Controller depth influencing filter cutoff LFO pitch (0 - 1200).
uint32_t LoopStart
The start value specifies the offset (in sample points) in the waveform data of the first sample poin...
virtual void UpdateChunks(progress_t *pProgress)
Update chunks with current group settings.
RegionList::iterator RegionsIterator
String Name
Name of this script group. For example to be displayed in an instrument editor.
int GetDimensionRegionIndexByValue(const uint DimValues[8])
int16_t EG3Depth
Depth of the sample pitch EG (-1200 - +1200).
bool GetAutoLoad()
Returns whether automatic loading is enabled.
void UpdateChunks(uint8_t *pData) const
uint8_t VCFKeyboardTrackingBreakpoint
See VCFKeyboardTracking (0 - 127).
eg2_ctrl_t EG2Controller
MIDI Controller which has influence on filter cutoff EG parameters (attack, decay,...
For layering of up to 8 instruments (and eventually crossfading of 2 or 4 layers).
void * LoadChunkData()
Load chunk body into RAM.
bool VCFCutoffControllerInvert
Inverts values coming from the defined cutoff controller.
Different samples triggered each time a note is played, random order.
virtual void CopyAssign(const Region *orig)
Make a (semi) deep copy of the Region object given by orig and assign it to this object.
void SwapScriptSlots(uint index1, uint index2)
Flip two script slots with each other (gig format extension).
double EG2Release
Release time of the filter cutoff EG (0.000 - 60.000s).
uint8_t EG1ControllerReleaseInfluence
Amount EG1 Controller has influence on the EG1 Release time (0 - 3, where 0 means off).
uint8_t EG2ControllerDecayInfluence
Amount EG2 Controller has influence on the EG2 Decay time (0 - 3, where 0 means off).
bool Polyphonic
If alternator should step forward only when all notes are off.
Abstract base class for all MIDI rules.
ScriptGroup * GetGroup() const
Returns the script group this script currently belongs to.
void SetVelocityResponseCurveScaling(uint8_t scaling)
Updates the respective member variable and the lookup table / cache that depends on this value.
virtual void UpdateChunks(progress_t *pProgress)
Apply all the gig file's current instruments, samples, groups and settings to the respective RIFF chu...
dimension_t
Defines the type of dimension, that is how the dimension zones (and thus how the dimension regions ar...
ScriptGroup(File *file, RIFF::List *lstRTIS)
uint32_t LoopEnd
Caution: Use the respective field in the DimensionRegion instead of this one! (Intended purpose: The ...
curve_type_t ReleaseVelocityResponseCurve
Defines a transformation curve to the incoming release veloctiy values affecting envelope times.
Different samples triggered each time a note is played, dimension regions selected in sequence.
dimension_def_t pDimensionDefinitions[8]
Defines the five (gig2) or eight (gig3) possible dimensions (the dimension's controller and number of...
uint8_t zones
Number of zones the dimension has.
Effect 5 Depth (MIDI Controller 95)
#define GIG_EXP_DECODE(x)
(so far) every exponential paramater in the gig format has a basis of 1.000000008813822
uint8_t AttenuationControllerThreshold
0-127
buffer_t GetCache()
Returns current cached sample points.
void SetVCFVelocityDynamicRange(uint8_t range)
Updates the respective member variable and the lookup table / cache that depends on this value.
vcf_cutoff_ctrl_t
Defines how the filter cutoff frequency is controlled by.
Encapsulates sample waves of Gigasampler/GigaStudio files used for playback.
virtual void SetGain(int32_t gain)
Updates the respective member variable and updates SampleAttenuation which depends on this value.
List * AddSubList(uint32_t uiListType)
Creates a new list sub chunk.
Group(File *file, RIFF::Chunk *ck3gnm)
Constructor.
InstrumentList * pInstruments
unsigned long GuessSize(unsigned long samples)
virtual void UpdateChunks(progress_t *pProgress)
Apply all sample player options to the respective RIFF chunk.
dimension value between 0-127
unsigned long GetSize() const
Chunk size in bytes (without header, thus the chunk data body)
int16_t LFO3InternalDepth
Firm depth of the sample pitch LFO (-1200 - +1200 cents).
virtual void UpdateChunks(progress_t *pProgress)
Apply dimension region settings to the respective RIFF chunks.
String Software
<ISFT-ck>. Identifies the name of the sofware package used to create the file.
String ArchivalLocation
<IARL-ck>. Indicates where the subject of the file is stored.
Sample * GetNextSample()
Returns a pointer to the next Sample object of the file, NULL otherwise.
unsigned long ulWavePoolOffset
double EG2Decay2
Only if EG2InfiniteSustain == false: 2nd stage decay time of the filter cutoff EG (0....
Encapsulates sample waves used for playback.
virtual void UpdateChunks(progress_t *pProgress)
Apply Instrument with all its Regions to the respective RIFF chunks.
type_t type
Controller type.
uint controller_number
MIDI controller number if this controller is a control change controller, 0 otherwise.
uint8_t * VelocityTable
For velocity dimensions with custom defined zone ranges only: used for fast converting from velocity ...
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...
curve_type_t VelocityResponseCurve
Defines a transformation curve to the incoming velocity values affecting amplitude (usually you don't...
A MIDI rule not yet implemented by libgig.
uint16_t EG1Sustain
Sustain value of the sample amplitude EG (0 - 1000 permille).
Sample * GetSample(uint index)
Returns Sample object of index.
String GetFileName()
File name of this DLS file.
Real-time instrument script (gig format extension).
unsigned long NullExtensionSize
The buffer might be bigger than the actual data, if that's the case that unused space at the end of t...
void SetVelocityResponseDepth(uint8_t depth)
Updates the respective member variable and the lookup table / cache that depends on this value.
Sample * GetSampleFromWavePool(unsigned int WavePoolTableIndex, progress_t *pProgress=NULL)
Gigasampler/GigaStudio specific classes and definitions.
float __range_max
Only for internal usage, do not modify!
uint8_t DimensionUpperLimits[8]
gig3: defines the upper limit of the dimension values for this dimension region. In case you wondered...
virtual void CopyAssign(const DimensionRegion *orig)
Make a (semi) deep copy of the DimensionRegion object given by orig and assign it to this object.
virtual void UpdateChunks(progress_t *pProgress)
Apply Region settings and all its DimensionRegions to the respective RIFF chunks.
uint8_t TriggerPoint
The CC value to pass for the note to be triggered.
uint8_t VelocityResponseDepth
Dynamic range of velocity affecting amplitude (0 - 4) (usually you don't have to interpret this param...
uint32_t LoopFraction
The fractional value specifies a fraction of a sample at which to loop. This allows a loop to be fine...
uint32_t TruncatedBits
For 24-bit compressed samples only: number of bits truncated during compression (0,...
Instrument * GetInstrument(uint index, progress_t *pProgress=NULL)
Returns the instrument with the given index.
unsigned long ReadUint16(uint16_t *pData, unsigned long WordCount=1)
Reads WordCount number of 16 Bit unsigned integer words and copies it into the buffer pointed by pDat...
void CopyAssignCore(const Sample *orig)
Make a deep copy of the Sample object given by orig (without the actual sample waveform data however)...
virtual void UpdateChunks(uint8_t *pData) const =0
Group of instrument scripts (gig format extension).
int8_t Pan
Panorama / Balance (-64..0..63 <-> left..middle..right)
Only internally controlled.
Provides convenient access to Gigasampler/GigaStudio .gig files.
void DeleteRegion(Region *pRegion)
void SetGroup(ScriptGroup *pGroup)
Move this script from its current ScriptGroup to another ScriptGroup given by pGroup.
Dimension for keyswitching.
MIDI rule for instruments with legato samples.
void SetReleaseVelocityResponseDepth(uint8_t depth)
Updates the respective member variable and the lookup table / cache that depends on this value.
virtual void UpdateChunks(progress_t *pProgress)
Apply sample and its settings to the respective RIFF chunks.
Sample * GetFirstSample()
Returns the first Sample of this Group.
struct gig::MidiRuleCtrlTrigger::trigger_t pTriggers[32]
dimension_def_t * GetDimensionDefinition(dimension_t type)
Searches in the current Region for a dimension of the given dimension type and returns the precise co...
uint16_t EG2Sustain
Sustain value of the filter cutoff EG (0 - 1000 permille).
uint32_t Instruments
Reflects the number of available Instrument objects.
Provides all neccessary information for the synthesis of a DLS Instrument.
Provides access to a Gigasampler/GigaStudio instrument.
void SetScriptSlotBypassed(uint index, bool bBypass)
Defines whether execution shall be skipped.
void DeleteGroup(Group *pGroup)
Delete a group and its samples.
bool SustainDefeat
If true: Sustain pedal will not hold a note.
Encoding_t Encoding
Format the script's source code text is encoded with.
buffer_t RAMCache
Buffers samples (already uncompressed) in RAM.
virtual void CopyAssign(const Instrument *orig)
Make a (semi) deep copy of the Instrument object given by orig and assign it to this object.
bool NoteOff
If a note off should be triggered instead of a note on.
String libraryName()
Returns the name of this C++ library.
unsigned long GetPos() const
Returns the current position in the sample (in sample points).
virtual void LoadGroups()
Quadtuple version number ("major.minor.release.build").
void MoveTo(Instrument *dst)
Move this instrument at the position before.
double LFO2Frequency
Frequency of the filter cutoff LFO (0.10 - 10.00 Hz).
unsigned long GetNewSize()
New chunk size if it was modified with Resize().
uint32_t SamplePeriod
Specifies the duration of time that passes during the playback of one sample in nanoseconds (normally...
uint16_t EG1PreAttack
Preattack value of the sample amplitude EG (0 - 1000 permille).
Script * GetScriptOfSlot(uint index)
Get instrument script (gig format extension).
unsigned long * FrameTable
For positioning within compressed samples only: stores the offset values for each frame.
void CopyAssignCore(const Instrument *orig)
curve_type_t
Defines the shape of a function graph.
uint8_t bits
Number of "bits" (1 bit = 2 splits/zones, 2 bit = 4 splits/zones, 3 bit = 8 splits/zones,...
selector_t Selector
Method by which pattern is chosen.
uint8_t out_start
Start position of fade out.
uint8_t VCFCutoff
Max. cutoff frequency.
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.
DLS specific classes and definitions.
unsigned long SetPos(unsigned long SampleCount, RIFF::stream_whence_t Whence=RIFF::stream_start)
Sets the position within the sample (in sample points, not in bytes).
Info * pInfo
Points (in any case) to an Info object, providing additional, optional infos and comments.
uint32_t Manufacturer
Specifies the MIDI Manufacturer's Association (MMA) Manufacturer code for the sampler intended to rec...
uint8_t high
High value of range.
bool OverridePedal
If a note off should be triggered even if the sustain pedal is down.
MIDI rule to automatically cycle through specified sequences of different articulations.
Reflects the current playback state for a sample.
General dimension definition.
int Size
Number of steps in the pattern.
void CopyAssignMeta(const Sample *orig)
Make a (semi) deep copy of the Sample object given by orig (without the actual waveform data) and ass...
eg1_ctrl_t EG1Controller
MIDI Controller which has influence on sample amplitude EG parameters (attack, decay,...
uint32_t * pWavePoolTableHi
virtual void UpdateChunks(progress_t *pProgress)
Apply Region settings to the respective RIFF chunks.
split_type_t split_type
Intended for internal usage: will be used to convert a dimension value into the corresponding dimensi...
void DeleteScript(Script *pScript)
Delete an instrument script.
If used sample has more than one channel (thus is not mono).
void Resize(int iNewSize)
Resize chunk.
virtual void UpdateChunks(progress_t *pProgress)
Apply sample and its settings to the respective RIFF chunks.
void SetReleaseVelocityResponseCurve(curve_type_t curve)
Updates the respective member variable and the lookup table / cache that depends on this value.
vcf_res_ctrl_t VCFResonanceController
Specifies which external controller has influence on the filter resonance Q.
Is not compressed at all (default).
curve_type_t VCFVelocityCurve
Defines a transformation curve for the incoming velocity values, affecting the VCF.
#define GIG_PITCH_TRACK_ENCODE(x)
uint8_t EG1ControllerDecayInfluence
Amount EG1 Controller has influence on the EG1 Decay time (0 - 3, where 0 means off).
List * GetNextSubList()
Returns the next sublist (that is a subchunk with chunk ID "LIST") within the list.
Defines Region information of an Instrument.
Effect 4 Depth (MIDI Controller 94)
double GetVelocityAttenuation(uint8_t MIDIKeyVelocity)
Returns the correct amplitude factor for the given MIDIKeyVelocity.
std::list< RIFF::File * > ExtensionFiles
Sample * GetSample()
Returns pointer address to the Sample referenced with this region.
void SetVelocityResponseCurve(curve_type_t curve)
Updates the respective member variable and the lookup table / cache that depends on this value.
#define GIG_EG_CTR_DECAY_INFLUENCE_EXTRACT(x)
double EG1Attack
Attack time of the sample amplitude EG (0.000 - 60.000s).
void DeleteScriptGroup(ScriptGroup *pGroup)
Delete an instrument script group.
unsigned long ReadInt8(int8_t *pData, unsigned long WordCount=1)
Reads WordCount number of 8 Bit signed integer words and copies it into the buffer pointed by pData.
unsigned long ReadUint8(uint8_t *pData, unsigned long WordCount=1)
Reads WordCount number of 8 Bit unsigned integer words and copies it into the buffer pointed by pData...
std::list< Region * > RegionList
Region * GetNextRegion()
Returns the next Region of the instrument.
virtual void UpdateChunks(progress_t *pProgress)
Apply all the DLS file's current instruments, samples and settings to the respective RIFF chunks.
virtual void UpdateFileOffsets()
Updates all file offsets stored all over the file.