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)
67 static void __notify_progress(
progress_t* pProgress,
float subprogress) {
68 if (pProgress && pProgress->
callback) {
70 const float totalprogress = pProgress->
__range_min + subprogress * totalrange;
71 pProgress->
factor = totalprogress;
77 static void __divide_progress(progress_t* pParentProgress, progress_t* pSubProgress,
float totalTasks,
float currentTask) {
78 if (pParentProgress && pParentProgress->callback) {
79 const float totalrange = pParentProgress->__range_max - pParentProgress->__range_min;
80 pSubProgress->callback = pParentProgress->callback;
81 pSubProgress->custom = pParentProgress->custom;
82 pSubProgress->__range_min = pParentProgress->__range_min + totalrange * currentTask / totalTasks;
83 pSubProgress->__range_max = pSubProgress->__range_min + totalrange / totalTasks;
93 inline int get12lo(
const unsigned char* pSrc)
95 const int x = pSrc[0] | (pSrc[1] & 0x0f) << 8;
96 return x & 0x800 ? x - 0x1000 : x;
99 inline int get12hi(
const unsigned char* pSrc)
101 const int x = pSrc[1] >> 4 | pSrc[2] << 4;
102 return x & 0x800 ? x - 0x1000 : x;
105 inline int16_t get16(
const unsigned char* pSrc)
107 return int16_t(pSrc[0] | pSrc[1] << 8);
110 inline int get24(
const unsigned char* pSrc)
112 const int x = pSrc[0] | pSrc[1] << 8 | pSrc[2] << 16;
113 return x & 0x800000 ? x - 0x1000000 : x;
116 inline void store24(
unsigned char* pDst,
int x)
123 void Decompress16(
int compressionmode,
const unsigned char* params,
124 int srcStep,
int dstStep,
125 const unsigned char* pSrc, int16_t* pDst,
126 unsigned long currentframeoffset,
127 unsigned long copysamples)
129 switch (compressionmode) {
131 pSrc += currentframeoffset * srcStep;
132 while (copysamples) {
141 int y = get16(params);
142 int dy = get16(params + 2);
143 while (currentframeoffset) {
147 currentframeoffset--;
149 while (copysamples) {
161 void Decompress24(
int compressionmode,
const unsigned char* params,
162 int dstStep,
const unsigned char* pSrc, uint8_t* pDst,
163 unsigned long currentframeoffset,
164 unsigned long copysamples,
int truncatedBits)
166 int y, dy, ddy, dddy;
168 #define GET_PARAMS(params) \
170 dy = y - get24((params) + 3); \
171 ddy = get24((params) + 6); \
172 dddy = get24((params) + 9)
174 #define SKIP_ONE(x) \
180 #define COPY_ONE(x) \
182 store24(pDst, y << truncatedBits); \
185 switch (compressionmode) {
187 pSrc += currentframeoffset * 3;
188 while (copysamples) {
189 store24(pDst, get24(pSrc) << truncatedBits);
198 while (currentframeoffset) {
201 currentframeoffset--;
203 while (copysamples) {
212 while (currentframeoffset > 1) {
216 currentframeoffset -= 2;
218 if (currentframeoffset) {
220 currentframeoffset--;
227 while (copysamples > 1) {
240 while (currentframeoffset) {
242 currentframeoffset--;
244 while (copysamples) {
252 const int bytesPerFrame[] = { 4096, 2052, 768, 524, 396, 268 };
253 const int bytesPerFrameNoHdr[] = { 4096, 2048, 768, 512, 384, 256 };
254 const int headerSize[] = { 0, 4, 0, 12, 12, 12 };
255 const int bitsPerSample[] = { 16, 8, 24, 16, 12, 8 };
263 static uint32_t* __initCRCTable() {
264 static uint32_t res[256];
266 for (
int i = 0 ; i < 256 ; i++) {
268 for (
int j = 0 ; j < 8 ; j++) {
269 c = (c & 1) ? 0xedb88320 ^ (c >> 1) : c >> 1;
276 static const uint32_t* __CRCTable = __initCRCTable();
283 inline static void __resetCRC(uint32_t& crc) {
306 static void __calculateCRC(
unsigned char* buf,
int bufSize, uint32_t& crc) {
307 for (
int i = 0 ; i < bufSize ; i++) {
308 crc = __CRCTable[(crc ^ buf[i]) & 0xff] ^ (crc >> 8);
317 inline static uint32_t __encodeCRC(
const uint32_t& crc) {
318 return crc ^ 0xffffffff;
339 static int __resolveZoneSize(dimension_def_t& dimension_definition) {
341 ? int(128.0 / dimension_definition.zones) : 0;
439 if (version == 3 &&
BitDepth == 24) {
444 ScanCompressedSample();
509 const int iReadAtOnce = 32*1024;
510 char* buf =
new char[iReadAtOnce * orig->
FrameSize];
512 unsigned long restorePos = pOrig->
GetPos();
515 for (
unsigned long n = pOrig->
Read(buf, iReadAtOnce); n;
516 n = pOrig->
Read(buf, iReadAtOnce))
520 pOrig->
SetPos(restorePos);
555 store32(&pData[28],
Loops);
559 store32(&pData[36],
LoopID);
570 uint16_t iSampleGroup = 0;
572 if (pFile->pGroups) {
573 std::list<Group*>::iterator iter = pFile->pGroups->begin();
574 std::list<Group*>::iterator end = pFile->pGroups->end();
575 for (
int i = 0; iter != end; i++, iter++) {
584 store16(&pData[0], iSampleGroup);
596 void Sample::ScanCompressedSample() {
599 std::list<unsigned long> frameOffsets;
607 for (
int i = 0 ; ; i++) {
614 if (mode_l > 5 || mode_r > 5)
throw gig::Exception(
"Unknown compression mode");
615 const unsigned long frameSize = bytesPerFrame[mode_l] + bytesPerFrame[mode_r];
620 (bitsPerSample[mode_l] + bitsPerSample[mode_r]);
629 for (
int i = 0 ; ; i++) {
634 const unsigned long frameSize = bytesPerFrame[mode];
650 FrameTable =
new unsigned long[frameOffsets.size()];
651 std::list<unsigned long>::iterator end = frameOffsets.end();
652 std::list<unsigned long>::iterator iter = frameOffsets.begin();
653 for (
int i = 0; iter != end; i++, iter++) {
755 unsigned long allocationsize = (SampleCount + NullSamplesCount) * this->
FrameSize;
871 unsigned long frame = this->
SamplePos / 2048;
877 unsigned long orderedBytes = SampleCount * this->
FrameSize;
878 unsigned long result =
pCkData->
SetPos(orderedBytes, Whence);
879 return (result == orderedBytes) ? SampleCount
928 unsigned long samplestoread = SampleCount, totalreadsamples = 0, readsamples, samplestoloopend;
929 uint8_t* pDst = (uint8_t*) pBuffer;
938 if (
GetPos() <= loopEnd) {
946 if (!pPlaybackState->
reverse) {
948 samplestoloopend = loopEnd -
GetPos();
949 readsamples =
Read(&pDst[totalreadsamples * this->
FrameSize], Min(samplestoread, samplestoloopend), pExternalDecompressionBuffer);
950 samplestoread -= readsamples;
951 totalreadsamples += readsamples;
952 if (readsamples == samplestoloopend) {
953 pPlaybackState->
reverse =
true;
956 }
while (samplestoread && readsamples);
966 unsigned long swapareastart = totalreadsamples;
968 unsigned long samplestoreadinloop = Min(samplestoread, loopoffset);
969 unsigned long reverseplaybackend =
GetPos() - samplestoreadinloop;
971 SetPos(reverseplaybackend);
975 readsamples =
Read(&pDst[totalreadsamples * this->
FrameSize], samplestoreadinloop, pExternalDecompressionBuffer);
976 samplestoreadinloop -= readsamples;
977 samplestoread -= readsamples;
978 totalreadsamples += readsamples;
979 }
while (samplestoreadinloop && readsamples);
981 SetPos(reverseplaybackend);
983 if (reverseplaybackend == loop.
LoopStart) {
985 pPlaybackState->
reverse =
false;
989 if (totalreadsamples > swapareastart)
990 SwapMemoryArea(&pDst[swapareastart * this->
FrameSize], (totalreadsamples - swapareastart) * this->FrameSize, this->FrameSize);
992 }
while (samplestoread && readsamples);
998 if (!pPlaybackState->
reverse)
do {
999 samplestoloopend = loopEnd -
GetPos();
1000 readsamples =
Read(&pDst[totalreadsamples * this->
FrameSize], Min(samplestoread, samplestoloopend), pExternalDecompressionBuffer);
1001 samplestoread -= readsamples;
1002 totalreadsamples += readsamples;
1003 if (readsamples == samplestoloopend) {
1004 pPlaybackState->
reverse =
true;
1007 }
while (samplestoread && readsamples);
1009 if (!samplestoread)
break;
1017 unsigned long swapareastart = totalreadsamples;
1021 unsigned long reverseplaybackend = loop.
LoopStart + Abs((loopoffset - samplestoreadinloop) % loop.
LoopLength);
1023 SetPos(reverseplaybackend);
1029 samplestoloopend = loopEnd -
GetPos();
1030 readsamples =
Read(&pDst[totalreadsamples * this->
FrameSize], Min(samplestoreadinloop, samplestoloopend), pExternalDecompressionBuffer);
1031 samplestoreadinloop -= readsamples;
1032 samplestoread -= readsamples;
1033 totalreadsamples += readsamples;
1034 if (readsamples == samplestoloopend) {
1038 }
while (samplestoreadinloop && readsamples);
1040 SetPos(reverseplaybackend);
1043 SwapMemoryArea(&pDst[swapareastart * this->
FrameSize], (totalreadsamples - swapareastart) * this->FrameSize, this->FrameSize);
1051 samplestoloopend = loopEnd -
GetPos();
1052 readsamples =
Read(&pDst[totalreadsamples * this->
FrameSize], Min(samplestoread, samplestoloopend), pExternalDecompressionBuffer);
1053 samplestoread -= readsamples;
1054 totalreadsamples += readsamples;
1055 if (readsamples == samplestoloopend) {
1059 }
while (samplestoread && readsamples);
1067 if (samplestoread)
do {
1068 readsamples =
Read(&pDst[totalreadsamples * this->
FrameSize], samplestoread, pExternalDecompressionBuffer);
1069 samplestoread -= readsamples;
1070 totalreadsamples += readsamples;
1071 }
while (readsamples && samplestoread);
1076 return totalreadsamples;
1102 if (SampleCount == 0)
return 0;
1109 return Channels == 2 ?
pCkData->
Read(pBuffer, SampleCount << 1, 2) >> 1
1116 unsigned long assumedsize =
GuessSize(SampleCount),
1118 remainingsamples = SampleCount,
1119 copysamples, skipsamples,
1126 if (pDecompressionBuffer->
Size < assumedsize) {
1127 std::cerr <<
"gig::Read(): WARNING - decompression buffer size too small!" << std::endl;
1129 remainingsamples = SampleCount;
1133 unsigned char* pSrc = (
unsigned char*) pDecompressionBuffer->
pStart;
1134 int16_t* pDst = static_cast<int16_t*>(pBuffer);
1135 uint8_t* pDst24 =
static_cast<uint8_t*
>(pBuffer);
1136 remainingbytes =
pCkData->
Read(pSrc, assumedsize, 1);
1138 while (remainingsamples && remainingbytes) {
1140 unsigned long framebytes, rightChannelOffset = 0, nextFrameOffset;
1142 int mode_l = *pSrc++, mode_r = 0;
1144 if (Channels == 2) {
1146 framebytes = bytesPerFrame[mode_l] + bytesPerFrame[mode_r] + 2;
1147 rightChannelOffset = bytesPerFrameNoHdr[mode_l];
1148 nextFrameOffset = rightChannelOffset + bytesPerFrameNoHdr[mode_r];
1149 if (remainingbytes < framebytes) {
1151 if (mode_l == 4 && (framesamples & 1)) {
1152 rightChannelOffset = ((framesamples + 1) * bitsPerSample[mode_l]) >> 3;
1155 rightChannelOffset = (framesamples * bitsPerSample[mode_l]) >> 3;
1160 framebytes = bytesPerFrame[mode_l] + 1;
1161 nextFrameOffset = bytesPerFrameNoHdr[mode_l];
1162 if (remainingbytes < framebytes) {
1168 if (currentframeoffset + remainingsamples >= framesamples) {
1169 if (currentframeoffset <= framesamples) {
1170 copysamples = framesamples - currentframeoffset;
1171 skipsamples = currentframeoffset;
1175 skipsamples = framesamples;
1182 copysamples = remainingsamples;
1183 skipsamples = currentframeoffset;
1185 this->
FrameOffset = currentframeoffset + copysamples;
1187 remainingsamples -= copysamples;
1189 if (remainingbytes > framebytes) {
1190 remainingbytes -= framebytes;
1191 if (remainingsamples == 0 &&
1192 currentframeoffset + copysamples == framesamples) {
1200 else remainingbytes = 0;
1202 currentframeoffset -= skipsamples;
1204 if (copysamples == 0) {
1209 const unsigned char*
const param_l = pSrc;
1211 if (mode_l != 2) pSrc += 12;
1213 if (Channels == 2) {
1214 const unsigned char*
const param_r = pSrc;
1215 if (mode_r != 2) pSrc += 12;
1217 Decompress24(mode_l, param_l, 6, pSrc, pDst24,
1219 Decompress24(mode_r, param_r, 6, pSrc + rightChannelOffset, pDst24 + 3,
1221 pDst24 += copysamples * 6;
1224 Decompress24(mode_l, param_l, 3, pSrc, pDst24,
1226 pDst24 += copysamples * 3;
1230 if (mode_l) pSrc += 4;
1233 if (Channels == 2) {
1234 const unsigned char*
const param_r = pSrc;
1235 if (mode_r) pSrc += 4;
1237 step = (2 - mode_l) + (2 - mode_r);
1238 Decompress16(mode_l, param_l, step, 2, pSrc, pDst, skipsamples, copysamples);
1239 Decompress16(mode_r, param_r, step, 2, pSrc + (2 - mode_l), pDst + 1,
1240 skipsamples, copysamples);
1241 pDst += copysamples << 1;
1245 Decompress16(mode_l, param_l, step, 1, pSrc, pDst, skipsamples, copysamples);
1246 pDst += copysamples;
1249 pSrc += nextFrameOffset;
1253 if (remainingsamples && remainingbytes < WorstCaseFrameSize && pCkData->GetState() ==
RIFF::stream_ready) {
1254 assumedsize =
GuessSize(remainingsamples);
1258 pSrc = (
unsigned char*) pDecompressionBuffer->
pStart;
1262 this->
SamplePos += (SampleCount - remainingsamples);
1264 return (SampleCount - remainingsamples);
1298 if (
GetSize() < SampleCount)
throw Exception(
"Could not write sample data, current sample size to small");
1303 res = Channels == 2 ?
pCkData->
Write(pBuffer, SampleCount << 1, 2) >> 1
1306 __calculateCRC((
unsigned char *)pBuffer, SampleCount *
FrameSize, crc);
1335 const double worstCaseHeaderOverhead =
1336 (256.0 + 12.0 + 2.0 ) / 256.0;
1337 result.
Size = (
unsigned long) (
double(MaxReadSize) * 3.0 * 2.0 * worstCaseHeaderOverhead);
1351 if (DecompressionBuffer.
Size && DecompressionBuffer.
pStart) {
1352 delete[] (int8_t*) DecompressionBuffer.
pStart;
1353 DecompressionBuffer.
pStart = NULL;
1354 DecompressionBuffer.
Size = 0;
1387 uint DimensionRegion::Instances = 0;
1388 DimensionRegion::VelocityTableMap* DimensionRegion::pVelocityTables = NULL;
1399 if (!pVelocityTables) pVelocityTables =
new VelocityTableMap;
1420 uint8_t eg1ctrloptions = _3ewa->
ReadUint8();
1426 uint8_t eg2ctrloptions = _3ewa->
ReadUint8();
1452 uint8_t velocityresponse = _3ewa->
ReadUint8();
1453 if (velocityresponse < 5) {
1456 }
else if (velocityresponse < 10) {
1459 }
else if (velocityresponse < 15) {
1466 uint8_t releasevelocityresponse = _3ewa->
ReadUint8();
1467 if (releasevelocityresponse < 5) {
1470 }
else if (releasevelocityresponse < 10) {
1473 }
else if (releasevelocityresponse < 15) {
1485 uint8_t pitchTrackDimensionBypass = _3ewa->
ReadInt8();
1491 Pan = (pan < 64) ? pan : -((
int)pan - 63);
1503 bool extResonanceCtrl = lfo2ctrl & 0x40;
1511 EG3Depth = (eg3depth <= 1200) ? eg3depth
1512 : (-1) * (int16_t) ((eg3depth ^ 0xfff) + 1);
1515 uint8_t regoptions = _3ewa->
ReadUint8();
1530 uint8_t vcfvelscale = _3ewa->
ReadUint8();
1534 uint8_t vcfresonance = _3ewa->
ReadUint8();
1537 uint8_t vcfbreakpoint = _3ewa->
ReadUint8();
1540 uint8_t vcfvelocity = _3ewa->
ReadUint8();
1545 if (lfo3ctrl & 0x40)
1640 pVelocityReleaseTable = GetReleaseVelocityTable(
1667 for (
int k = 0 ; k < 128 ; k++)
1715 pRegion = pOriginalRegion;
1723 if (mSamples && mSamples->count(orig->
pSample)) {
1730 for (
int k = 0 ; k < 128 ; k++)
1778 const uint32_t chunksize = _3ewa->
GetNewSize();
1779 store32(&pData[0], chunksize);
1782 store32(&pData[4], lfo3freq);
1785 store32(&pData[8], eg3attack);
1804 store32(&pData[28], eg1attack);
1807 store32(&pData[32], eg1decay1);
1814 store32(&pData[40], eg1release);
1816 const uint8_t eg1ctl = (uint8_t) EncodeLeverageController(
EG1Controller);
1819 const uint8_t eg1ctrloptions =
1824 pData[45] = eg1ctrloptions;
1826 const uint8_t eg2ctl = (uint8_t) EncodeLeverageController(
EG2Controller);
1829 const uint8_t eg2ctrloptions =
1834 pData[47] = eg2ctrloptions;
1837 store32(&pData[48], lfo1freq);
1840 store32(&pData[52], eg2attack);
1843 store32(&pData[56], eg2decay1);
1850 store32(&pData[64], eg2release);
1857 store32(&pData[72], lfo2freq);
1864 store32(&pData[80], eg1decay2);
1871 store32(&pData[88], eg2decay2);
1884 velocityresponse += 5;
1887 velocityresponse += 10;
1891 throw Exception(
"Could not update DimensionRegion's chunk, unknown VelocityResponseCurve selected");
1893 pData[96] = velocityresponse;
1903 releasevelocityresponse += 5;
1906 releasevelocityresponse += 10;
1910 throw Exception(
"Could not update DimensionRegion's chunk, unknown ReleaseVelocityResponseCurve selected");
1912 pData[97] = releasevelocityresponse;
1929 pitchTrackDimensionBypass |= 0x10;
1932 pitchTrackDimensionBypass |= 0x20;
1938 throw Exception(
"Could not update DimensionRegion's chunk, unknown DimensionBypass selected");
1940 pData[108] = pitchTrackDimensionBypass;
1943 const uint8_t pan = (
Pan >= 0) ?
Pan : ((-
Pan) + 63);
1946 const uint8_t selfmask = (
SelfMask) ? 0x01 : 0x00;
1947 pData[110] = selfmask;
1956 pData[112] = lfo3ctrl;
1960 pData[113] = attenctl;
1967 pData[114] = lfo2ctrl;
1976 pData[115] = lfo1ctrl;
1980 : uint16_t(((-
EG3Depth) - 1) ^ 0xfff);
1981 store16(&pData[116], eg3depth);
1986 pData[120] = channeloffset;
1989 uint8_t regoptions = 0;
1992 pData[121] = regoptions;
2005 const uint8_t eg1hold = (
EG1Hold) ? 0x80 : 0x00;
2006 pData[131] = eg1hold;
2008 const uint8_t vcfcutoff = (
VCFEnabled ? 0x80 : 0x00) |
2010 pData[132] = vcfcutoff;
2016 pData[134] = vcfvelscale;
2022 pData[136] = vcfresonance;
2026 pData[137] = vcfbreakpoint;
2030 pData[138] = vcfvelocity;
2033 pData[139] = vcftype;
2035 if (chunksize >= 148) {
2040 double* DimensionRegion::GetReleaseVelocityTable(
curve_type_t releaseVelocityResponseCurve, uint8_t releaseVelocityResponseDepth) {
2042 uint8_t depth = releaseVelocityResponseDepth;
2051 return GetVelocityTable(curveType, depth, 0);
2054 double* DimensionRegion::GetCutoffVelocityTable(
curve_type_t vcfVelocityCurve,
2055 uint8_t vcfVelocityDynamicRange,
2056 uint8_t vcfVelocityScale,
2060 uint8_t depth = vcfVelocityDynamicRange;
2069 return GetVelocityTable(curveType, depth,
2071 ? vcfVelocityScale : 0);
2075 double* DimensionRegion::GetVelocityTable(
curve_type_t curveType, uint8_t depth, uint8_t scaling)
2078 uint32_t tableKey = (curveType<<16) | (depth<<8) | scaling;
2079 if (pVelocityTables->count(tableKey)) {
2080 table = (*pVelocityTables)[tableKey];
2083 table = CreateVelocityTable(curveType, depth, scaling);
2084 (*pVelocityTables)[tableKey] = table;
2099 leverage_ctrl_t DimensionRegion::DecodeLeverageController(_lev_ctrl_t EncodedController) {
2101 switch (EncodedController) {
2103 case _lev_ctrl_none:
2107 case _lev_ctrl_velocity:
2111 case _lev_ctrl_channelaftertouch:
2117 case _lev_ctrl_modwheel:
2121 case _lev_ctrl_breath:
2125 case _lev_ctrl_foot:
2129 case _lev_ctrl_effect1:
2133 case _lev_ctrl_effect2:
2137 case _lev_ctrl_genpurpose1:
2141 case _lev_ctrl_genpurpose2:
2145 case _lev_ctrl_genpurpose3:
2149 case _lev_ctrl_genpurpose4:
2153 case _lev_ctrl_portamentotime:
2157 case _lev_ctrl_sustainpedal:
2161 case _lev_ctrl_portamento:
2165 case _lev_ctrl_sostenutopedal:
2169 case _lev_ctrl_softpedal:
2173 case _lev_ctrl_genpurpose5:
2177 case _lev_ctrl_genpurpose6:
2181 case _lev_ctrl_genpurpose7:
2185 case _lev_ctrl_genpurpose8:
2189 case _lev_ctrl_effect1depth:
2193 case _lev_ctrl_effect2depth:
2197 case _lev_ctrl_effect3depth:
2201 case _lev_ctrl_effect4depth:
2205 case _lev_ctrl_effect5depth:
2213 case _lev_ctrl_CC3_EXT:
2217 case _lev_ctrl_CC6_EXT:
2221 case _lev_ctrl_CC7_EXT:
2225 case _lev_ctrl_CC8_EXT:
2229 case _lev_ctrl_CC9_EXT:
2233 case _lev_ctrl_CC10_EXT:
2237 case _lev_ctrl_CC11_EXT:
2241 case _lev_ctrl_CC14_EXT:
2245 case _lev_ctrl_CC15_EXT:
2249 case _lev_ctrl_CC20_EXT:
2253 case _lev_ctrl_CC21_EXT:
2257 case _lev_ctrl_CC22_EXT:
2261 case _lev_ctrl_CC23_EXT:
2265 case _lev_ctrl_CC24_EXT:
2269 case _lev_ctrl_CC25_EXT:
2273 case _lev_ctrl_CC26_EXT:
2277 case _lev_ctrl_CC27_EXT:
2281 case _lev_ctrl_CC28_EXT:
2285 case _lev_ctrl_CC29_EXT:
2289 case _lev_ctrl_CC30_EXT:
2293 case _lev_ctrl_CC31_EXT:
2297 case _lev_ctrl_CC68_EXT:
2301 case _lev_ctrl_CC69_EXT:
2305 case _lev_ctrl_CC70_EXT:
2309 case _lev_ctrl_CC71_EXT:
2313 case _lev_ctrl_CC72_EXT:
2317 case _lev_ctrl_CC73_EXT:
2321 case _lev_ctrl_CC74_EXT:
2325 case _lev_ctrl_CC75_EXT:
2329 case _lev_ctrl_CC76_EXT:
2333 case _lev_ctrl_CC77_EXT:
2337 case _lev_ctrl_CC78_EXT:
2341 case _lev_ctrl_CC79_EXT:
2345 case _lev_ctrl_CC84_EXT:
2349 case _lev_ctrl_CC85_EXT:
2353 case _lev_ctrl_CC86_EXT:
2357 case _lev_ctrl_CC87_EXT:
2361 case _lev_ctrl_CC89_EXT:
2365 case _lev_ctrl_CC90_EXT:
2369 case _lev_ctrl_CC96_EXT:
2373 case _lev_ctrl_CC97_EXT:
2377 case _lev_ctrl_CC102_EXT:
2381 case _lev_ctrl_CC103_EXT:
2385 case _lev_ctrl_CC104_EXT:
2389 case _lev_ctrl_CC105_EXT:
2393 case _lev_ctrl_CC106_EXT:
2397 case _lev_ctrl_CC107_EXT:
2401 case _lev_ctrl_CC108_EXT:
2405 case _lev_ctrl_CC109_EXT:
2409 case _lev_ctrl_CC110_EXT:
2413 case _lev_ctrl_CC111_EXT:
2417 case _lev_ctrl_CC112_EXT:
2421 case _lev_ctrl_CC113_EXT:
2425 case _lev_ctrl_CC114_EXT:
2429 case _lev_ctrl_CC115_EXT:
2433 case _lev_ctrl_CC116_EXT:
2437 case _lev_ctrl_CC117_EXT:
2441 case _lev_ctrl_CC118_EXT:
2445 case _lev_ctrl_CC119_EXT:
2454 return decodedcontroller;
2460 DimensionRegion::_lev_ctrl_t DimensionRegion::EncodeLeverageController(leverage_ctrl_t DecodedController) {
2461 _lev_ctrl_t encodedcontroller;
2462 switch (DecodedController.type) {
2465 encodedcontroller = _lev_ctrl_none;
2468 encodedcontroller = _lev_ctrl_velocity;
2471 encodedcontroller = _lev_ctrl_channelaftertouch;
2476 switch (DecodedController.controller_number) {
2478 encodedcontroller = _lev_ctrl_modwheel;
2481 encodedcontroller = _lev_ctrl_breath;
2484 encodedcontroller = _lev_ctrl_foot;
2487 encodedcontroller = _lev_ctrl_effect1;
2490 encodedcontroller = _lev_ctrl_effect2;
2493 encodedcontroller = _lev_ctrl_genpurpose1;
2496 encodedcontroller = _lev_ctrl_genpurpose2;
2499 encodedcontroller = _lev_ctrl_genpurpose3;
2502 encodedcontroller = _lev_ctrl_genpurpose4;
2505 encodedcontroller = _lev_ctrl_portamentotime;
2508 encodedcontroller = _lev_ctrl_sustainpedal;
2511 encodedcontroller = _lev_ctrl_portamento;
2514 encodedcontroller = _lev_ctrl_sostenutopedal;
2517 encodedcontroller = _lev_ctrl_softpedal;
2520 encodedcontroller = _lev_ctrl_genpurpose5;
2523 encodedcontroller = _lev_ctrl_genpurpose6;
2526 encodedcontroller = _lev_ctrl_genpurpose7;
2529 encodedcontroller = _lev_ctrl_genpurpose8;
2532 encodedcontroller = _lev_ctrl_effect1depth;
2535 encodedcontroller = _lev_ctrl_effect2depth;
2538 encodedcontroller = _lev_ctrl_effect3depth;
2541 encodedcontroller = _lev_ctrl_effect4depth;
2544 encodedcontroller = _lev_ctrl_effect5depth;
2551 encodedcontroller = _lev_ctrl_CC3_EXT;
2554 encodedcontroller = _lev_ctrl_CC6_EXT;
2557 encodedcontroller = _lev_ctrl_CC7_EXT;
2560 encodedcontroller = _lev_ctrl_CC8_EXT;
2563 encodedcontroller = _lev_ctrl_CC9_EXT;
2566 encodedcontroller = _lev_ctrl_CC10_EXT;
2569 encodedcontroller = _lev_ctrl_CC11_EXT;
2572 encodedcontroller = _lev_ctrl_CC14_EXT;
2575 encodedcontroller = _lev_ctrl_CC15_EXT;
2578 encodedcontroller = _lev_ctrl_CC20_EXT;
2581 encodedcontroller = _lev_ctrl_CC21_EXT;
2584 encodedcontroller = _lev_ctrl_CC22_EXT;
2587 encodedcontroller = _lev_ctrl_CC23_EXT;
2590 encodedcontroller = _lev_ctrl_CC24_EXT;
2593 encodedcontroller = _lev_ctrl_CC25_EXT;
2596 encodedcontroller = _lev_ctrl_CC26_EXT;
2599 encodedcontroller = _lev_ctrl_CC27_EXT;
2602 encodedcontroller = _lev_ctrl_CC28_EXT;
2605 encodedcontroller = _lev_ctrl_CC29_EXT;
2608 encodedcontroller = _lev_ctrl_CC30_EXT;
2611 encodedcontroller = _lev_ctrl_CC31_EXT;
2614 encodedcontroller = _lev_ctrl_CC68_EXT;
2617 encodedcontroller = _lev_ctrl_CC69_EXT;
2620 encodedcontroller = _lev_ctrl_CC70_EXT;
2623 encodedcontroller = _lev_ctrl_CC71_EXT;
2626 encodedcontroller = _lev_ctrl_CC72_EXT;
2629 encodedcontroller = _lev_ctrl_CC73_EXT;
2632 encodedcontroller = _lev_ctrl_CC74_EXT;
2635 encodedcontroller = _lev_ctrl_CC75_EXT;
2638 encodedcontroller = _lev_ctrl_CC76_EXT;
2641 encodedcontroller = _lev_ctrl_CC77_EXT;
2644 encodedcontroller = _lev_ctrl_CC78_EXT;
2647 encodedcontroller = _lev_ctrl_CC79_EXT;
2650 encodedcontroller = _lev_ctrl_CC84_EXT;
2653 encodedcontroller = _lev_ctrl_CC85_EXT;
2656 encodedcontroller = _lev_ctrl_CC86_EXT;
2659 encodedcontroller = _lev_ctrl_CC87_EXT;
2662 encodedcontroller = _lev_ctrl_CC89_EXT;
2665 encodedcontroller = _lev_ctrl_CC90_EXT;
2668 encodedcontroller = _lev_ctrl_CC96_EXT;
2671 encodedcontroller = _lev_ctrl_CC97_EXT;
2674 encodedcontroller = _lev_ctrl_CC102_EXT;
2677 encodedcontroller = _lev_ctrl_CC103_EXT;
2680 encodedcontroller = _lev_ctrl_CC104_EXT;
2683 encodedcontroller = _lev_ctrl_CC105_EXT;
2686 encodedcontroller = _lev_ctrl_CC106_EXT;
2689 encodedcontroller = _lev_ctrl_CC107_EXT;
2692 encodedcontroller = _lev_ctrl_CC108_EXT;
2695 encodedcontroller = _lev_ctrl_CC109_EXT;
2698 encodedcontroller = _lev_ctrl_CC110_EXT;
2701 encodedcontroller = _lev_ctrl_CC111_EXT;
2704 encodedcontroller = _lev_ctrl_CC112_EXT;
2707 encodedcontroller = _lev_ctrl_CC113_EXT;
2710 encodedcontroller = _lev_ctrl_CC114_EXT;
2713 encodedcontroller = _lev_ctrl_CC115_EXT;
2716 encodedcontroller = _lev_ctrl_CC116_EXT;
2719 encodedcontroller = _lev_ctrl_CC117_EXT;
2722 encodedcontroller = _lev_ctrl_CC118_EXT;
2725 encodedcontroller = _lev_ctrl_CC119_EXT;
2729 throw gig::Exception(
"leverage controller number is not supported by the gig format");
2735 return encodedcontroller;
2742 VelocityTableMap::iterator iter;
2743 for (iter = pVelocityTables->begin(); iter != pVelocityTables->end(); iter++) {
2744 double* pTable = iter->second;
2745 if (pTable)
delete[] pTable;
2747 pVelocityTables->clear();
2748 delete pVelocityTables;
2749 pVelocityTables = NULL;
2766 return pVelocityAttenuationTable[MIDIKeyVelocity];
2770 return pVelocityReleaseTable[MIDIKeyVelocity];
2774 return pVelocityCutoffTable[MIDIKeyVelocity];
2782 pVelocityAttenuationTable =
2794 pVelocityAttenuationTable =
2806 pVelocityAttenuationTable =
2867 double* DimensionRegion::CreateVelocityTable(
curve_type_t curveType, uint8_t depth, uint8_t scaling) {
2872 const int lin0[] = { 1, 1, 127, 127 };
2873 const int lin1[] = { 1, 21, 127, 127 };
2874 const int lin2[] = { 1, 45, 127, 127 };
2875 const int lin3[] = { 1, 74, 127, 127 };
2876 const int lin4[] = { 1, 127, 127, 127 };
2879 const int non0[] = { 1, 4, 24, 5, 57, 17, 92, 57, 122, 127, 127, 127 };
2880 const int non1[] = { 1, 4, 46, 9, 93, 56, 118, 106, 123, 127,
2882 const int non2[] = { 1, 4, 46, 9, 57, 20, 102, 107, 107, 127,
2884 const int non3[] = { 1, 15, 10, 19, 67, 73, 80, 80, 90, 98, 98, 127,
2886 const int non4[] = { 1, 25, 33, 57, 82, 81, 92, 127, 127, 127 };
2889 const int spe0[] = { 1, 2, 76, 10, 90, 15, 95, 20, 99, 28, 103, 44,
2890 113, 127, 127, 127 };
2891 const int spe1[] = { 1, 2, 27, 5, 67, 18, 89, 29, 95, 35, 107, 67,
2892 118, 127, 127, 127 };
2893 const int spe2[] = { 1, 1, 33, 1, 53, 5, 61, 13, 69, 32, 79, 74,
2894 85, 90, 91, 127, 127, 127 };
2895 const int spe3[] = { 1, 32, 28, 35, 66, 48, 89, 59, 95, 65, 99, 73,
2896 117, 127, 127, 127 };
2897 const int spe4[] = { 1, 4, 23, 5, 49, 13, 57, 17, 92, 57, 122, 127,
2901 const int spe5[] = { 1, 2, 30, 5, 60, 19, 77, 70, 83, 85, 88, 106,
2902 91, 127, 127, 127 };
2904 const int*
const curves[] = { non0, non1, non2, non3, non4,
2905 lin0, lin1, lin2, lin3, lin4,
2906 spe0, spe1, spe2, spe3, spe4, spe5 };
2908 double*
const table =
new double[128];
2910 const int* curve = curves[curveType * 5 + depth];
2911 const int s = scaling == 0 ? 20 : scaling;
2914 for (
int x = 1 ; x < 128 ; x++) {
2916 if (x > curve[2]) curve += 2;
2917 double y = curve[1] + (x - curve[0]) *
2918 (
double(curve[3] - curve[1]) / (curve[2] - curve[0]));
2923 if (s < 20 && y >= 0.5)
2924 y = y / ((2 - 40.0 / s) * y + 40.0 / s - 1);
2941 for (
int i = 0; i < 256; i++) {
2957 for (
int i = 0; i < dimensionBits; i++) {
2998 uint32_t wavepoolindex = _3lnk->
ReadUint32();
3005 for (
int i = 0 ; i < 8 ; i++) {
3048 const int iMaxDimensions = version3 ? 8 : 5;
3049 const int iMaxDimensionRegions = version3 ? 256 : 32;
3054 const int _3lnkChunkSize = version3 ? 1092 : 172;
3064 store32(&pData[0], DimensionRegions);
3066 for (
int i = 0; i < iMaxDimensions; i++) {
3078 const int iWavePoolOffset = version3 ? 68 : 44;
3079 for (uint i = 0; i < iMaxDimensionRegions; i++) {
3080 int iWaveIndex = -1;
3081 if (i < DimensionRegions) {
3083 File::SampleList::iterator iter = pFile->
pSamples->begin();
3084 File::SampleList::iterator end = pFile->
pSamples->end();
3085 for (
int index = 0; iter != end; ++iter, ++index) {
3092 store32(&pData[iWavePoolOffset + i * 4], iWaveIndex);
3099 int dimensionRegionNr = 0;
3104 dimensionRegionNr++;
3108 if (dimensionRegionNr == 0)
throw gig::Exception(
"No dimension region found.");
3128 if (veldim == -1)
return;
3144 table =
new uint8_t[128];
3148 int velocityZone = 0;
3150 for (
int k = i ; k < end ; k += step) {
3152 for (; tableidx <= d->
DimensionUpperLimits[veldim] ; tableidx++) table[tableidx] = velocityZone;
3156 for (
int k = i ; k < end ; k += step) {
3158 for (; tableidx <= d->
VelocityUpperLimit ; tableidx++) table[tableidx] = velocityZone;
3172 if (j == veldim) i += skipveldim;
3185 if (j == Dimensions)
break;
3206 if (pDimDef->
zones < 2)
3207 throw gig::Exception(
"Could not add new dimension, amount of requested zones must always be at least two");
3208 if (pDimDef->
bits < 1)
3209 throw gig::Exception(
"Could not add new dimension, amount of requested requested zone bits must always be at least one");
3211 if (pDimDef->
zones != 2)
3212 throw gig::Exception(
"Could not add new 'sample channel' dimensions, the requested amount of zones must always be 2 for this dimension type");
3213 if (pDimDef->
bits != 1)
3214 throw gig::Exception(
"Could not add new 'sample channel' dimensions, the requested amount of zone bits must always be 1 for this dimension type");
3221 throw gig::Exception(
"Could not add new dimension, max. amount of " + ToString(iMaxDimensions) +
" dimensions already reached");
3223 int iCurrentBits = 0;
3226 if (iCurrentBits >= iMaxDimensions)
3227 throw gig::Exception(
"Could not add new dimension, max. amount of " + ToString(iMaxDimensions) +
" dimension bits already reached");
3228 const int iNewBits = iCurrentBits + pDimDef->
bits;
3229 if (iNewBits > iMaxDimensions)
3230 throw gig::Exception(
"Could not add new dimension, new dimension would exceed max. amount of " + ToString(iMaxDimensions) +
" dimension bits");
3234 throw gig::Exception(
"Could not add new dimension, there is already a dimension of the same type");
3241 for (
int i = 0 ; i < pos ; i++)
3246 for (
int i = 0 ; i < (1 << iCurrentBits) ; i++) {
3247 for (
int j = Dimensions ; j > pos ; j--) {
3267 for (
int i = (1 << iCurrentBits) - (1 << bitpos) ; i >= 0 ; i -= (1 << bitpos)) {
3268 for (
int k = 0 ; k < (1 << bitpos) ; k++) {
3271 for (
int j = 1 ; j < (1 << pDimDef->
bits) ; j++) {
3272 for (
int k = 0 ; k < (1 << bitpos) ; k++) {
3274 if (moveTo) _3prg->
MoveSubChunk(pNewDimRgnListChunk, moveTo);
3287 int mask = (1 << bitpos) - 1;
3288 for (
int z = 0 ; z < pDimDef->
zones ; z++) {
3289 uint8_t upperLimit = uint8_t((z + 1) * 128.0 / pDimDef->
zones - 1);
3290 for (
int i = 0 ; i < 1 << iCurrentBits ; i++) {
3318 int iDimensionNr = -1;
3325 if (iDimensionNr < 0)
throw gig::Exception(
"Invalid dimension_def_t pointer");
3329 for (
int i = 0; i < iDimensionNr; i++)
3334 for (
int i = iDimensionNr + 1; i <
Dimensions; i++)
3341 for (
int iUpperBit = 0; iUpperBit < 1 << iUpperBits; iUpperBit++) {
3343 for (
int iLowerBit = 0; iLowerBit < 1 << iLowerBits; iLowerBit++) {
3345 iObsoleteBit << iLowerBits |
3358 for (
int iFrom = 2, iTo = 1; iFrom < 256 && iTo < 256 - 1; iTo++) {
3360 if (iFrom <= iTo) iFrom = iTo + 1;
3372 for (
int i = iDimensionNr + 1; i <
Dimensions; i++) {
3379 for (
int i = iDimensionNr + 1; i <
Dimensions; i++) {
3409 throw gig::Exception(
"Could not delete dimension zone, no such dimension of given type");
3410 if (oldDef->
zones <= 2)
3411 throw gig::Exception(
"Could not delete dimension zone, because it would end up with only one zone.");
3412 if (zone < 0 || zone >= oldDef->
zones)
3413 throw gig::Exception(
"Could not delete dimension zone, requested zone index out of bounds.");
3415 const int newZoneSize = oldDef->
zones - 1;
3428 tempRgn =
new Region(instr, rgn);
3440 def.
zones = newZoneSize;
3449 int tempReducedDimensionIndex = -1;
3450 for (
int d = 0; d < tempRgn->
Dimensions; ++d) {
3452 tempReducedDimensionIndex = d;
3458 for (
int iDst = 0; iDst < 256; ++iDst) {
3460 if (!dstDimRgn)
continue;
3461 std::map<dimension_t,int> dimCase;
3462 bool isValidZone =
true;
3463 for (
int d = 0, baseBits = 0; d < tempRgn->
Dimensions; ++d) {
3466 (iDst >> baseBits) & ((1 << dstBits) - 1);
3467 baseBits += dstBits;
3470 isValidZone =
false;
3474 if (!isValidZone)
continue;
3477 const bool isLastZone = (dimCase[type] == newZoneSize - 1);
3478 if (dimCase[type] >= zone) dimCase[type]++;
3493 for (
int iSrc = 0; iSrc < 256; ++iSrc) {
3495 if (!srcDimRgn)
continue;
3496 std::map<dimension_t,int> dimCase;
3497 for (
int d = 0, baseBits = 0; d < tempRgn->
Dimensions; ++d) {
3500 (iSrc >> baseBits) & ((1 << srcBits) - 1);
3501 baseBits += srcBits;
3506 if (!dstDimRgn)
continue;
3533 throw gig::Exception(
"Could not split dimension zone, no such dimension of given type");
3534 if (zone < 0 || zone >= oldDef->
zones)
3535 throw gig::Exception(
"Could not split dimension zone, requested zone index out of bounds.");
3537 const int newZoneSize = oldDef->
zones + 1;
3550 tempRgn =
new Region(instr, rgn);
3562 def.
zones = newZoneSize;
3563 if ((1 << oldDef->
bits) < newZoneSize) def.
bits++;
3571 int tempIncreasedDimensionIndex = -1;
3572 for (
int d = 0; d < tempRgn->
Dimensions; ++d) {
3574 tempIncreasedDimensionIndex = d;
3580 for (
int iSrc = 0; iSrc < 256; ++iSrc) {
3582 if (!srcDimRgn)
continue;
3583 std::map<dimension_t,int> dimCase;
3584 bool isValidZone =
true;
3585 for (
int d = 0, baseBits = 0; d <
Dimensions; ++d) {
3588 (iSrc >> baseBits) & ((1 << srcBits) - 1);
3590 if (dimCase[pDimensionDefinitions[d].dimension] >= pDimensionDefinitions[d].zones) {
3591 isValidZone =
false;
3594 baseBits += srcBits;
3596 if (!isValidZone)
continue;
3599 if (dimCase[type] > zone) dimCase[type]++;
3605 if (dimCase[type] == zone) {
3612 std::map<dimension_t,int> lowerCase = dimCase;
3632 for (
int iSrc = 0; iSrc < 256; ++iSrc) {
3634 if (!srcDimRgn)
continue;
3635 std::map<dimension_t,int> dimCase;
3636 for (
int d = 0, baseBits = 0; d < tempRgn->
Dimensions; ++d) {
3639 (iSrc >> baseBits) & ((1 << srcBits) - 1);
3640 baseBits += srcBits;
3645 if (!dstDimRgn)
continue;
3670 if (oldType == newType)
return;
3673 throw gig::Exception(
"No dimension with provided old dimension type exists on this region");
3675 throw gig::Exception(
"Cannot change to dimension type 'sample channel', because existing dimension does not have 2 zones");
3677 throw gig::Exception(
"There is already a dimension with requested new dimension type on this region");
3679 def->
split_type = __resolveSplitType(newType);
3683 uint8_t bits[8] = {};
3684 for (std::map<dimension_t,int>::const_iterator it = DimCase.begin();
3685 it != DimCase.end(); ++it)
3689 bits[d] = it->second;
3690 goto nextDimCaseSlice;
3717 for (
int i = 0; i < 256; i++) {
3757 if (DimValues[i] <=
pDimensionRegions[bits << bitpos]->DimensionUpperLimits[i])
break;
3766 bits = DimValues[i] & limiter_mask;
3769 dimregidx |= bits << bitpos;
3774 if (!dimreg)
return NULL;
3783 dimregidx |= (bits & limiter_mask) << velbitpos;
3806 if (DimValues[i] <=
pDimensionRegions[bits << bitpos]->DimensionUpperLimits[i])
break;
3815 bits = DimValues[i] & limiter_mask;
3818 dimregidx |= bits << bitpos;
3824 if (!dimreg)
return -1;
3833 dimregidx |= (bits & limiter_mask) << velbitpos;
3874 if ((int32_t)WavePoolTableIndex == -1)
return NULL;
3927 for (
int i = 0; i < 256; i++) {
3948 for (
int i = 0 ; i <
Triggers ; i++) {
3961 ControllerNumber(0),
3970 for (
int i = 0 ; i <
Triggers ; i++) {
4002 BypassUseController(false),
4004 BypassController(1),
4007 ReleaseTriggerKey(0),
4050 for (
int i = 0 ; i < n ; i++) {
4055 for (
int i = 0 ; i < n ; i++) {
4065 Selector(selector_none),
4089 char* str =
reinterpret_cast<char*
>(pData);
4092 for (
int i = 0 ; i < n ; i++, pos += 32) {
4098 for (
int i = 0 ; i < n ; i++, pos += 49) {
4099 strncpy(&str[pos],
pPatterns[i].Name.c_str(), 16);
4101 memcpy(&pData[pos + 16], &(
pPatterns[i][0]), 32);
4120 Name.resize(nameSize,
' ');
4121 for (
int i = 0; i < nameSize; ++i)
4124 ckScri->
SetPos(
sizeof(int32_t) + headerSize);
4127 data.resize(scriptSize);
4128 for (
int i = 0; i < scriptSize; ++i)
4136 Name =
"Unnamed Script";
4148 s.resize(data.size(),
' ');
4149 memcpy(&s[0], &data[0], data.size());
4160 data.resize(text.size());
4161 memcpy(&data[0], &text[0], text.size());
4167 __calculateCRC(&data[0], data.size(), crc);
4170 const int chunkSize = 7*
sizeof(int32_t) +
Name.size() + data.size();
4172 else pChunk->
Resize(chunkSize);
4176 store32(&pData[pos], 6*
sizeof(int32_t) +
Name.size());
4177 pos +=
sizeof(int32_t);
4179 pos +=
sizeof(int32_t);
4181 pos +=
sizeof(int32_t);
4183 pos +=
sizeof(int32_t);
4184 store32(&pData[pos],
Bypass ? 1 : 0);
4185 pos +=
sizeof(int32_t);
4186 store32(&pData[pos], crc);
4187 pos +=
sizeof(int32_t);
4188 store32(&pData[pos],
Name.size());
4189 pos +=
sizeof(int32_t);
4190 for (
int i = 0; i <
Name.size(); ++i, ++pos)
4191 pData[pos] =
Name[i];
4192 for (
int i = 0; i < data.size(); ++i, ++pos)
4193 pData[pos] = data[i];
4203 if (this->pGroup = pGroup)
return;
4206 this->pGroup = pGroup;
4220 File* pFile = pGroup->pFile;
4238 Name =
"Default Group";
4244 std::list<Script*>::iterator iter = pScripts->begin();
4245 std::list<Script*>::iterator end = pScripts->end();
4246 while (iter != end) {
4262 for (std::list<Script*>::iterator it = pScripts->begin();
4263 it != pScripts->end(); ++it)
4265 (*it)->UpdateChunks();
4279 std::list<Script*>::iterator it = pScripts->begin();
4280 for (uint i = 0; it != pScripts->end(); ++i, ++it)
4281 if (i == index)
return *it;
4299 pScripts->push_back(pScript);
4315 std::list<Script*>::iterator iter =
4316 find(pScripts->begin(), pScripts->end(), pScript);
4317 if (iter == pScripts->end())
4318 throw gig::Exception(
"Could not delete script, could not find given script");
4319 pScripts->erase(iter);
4321 if (pScript->pChunk)
4327 if (pScripts)
return;
4328 pScripts =
new std::list<Script*>;
4335 pScripts->push_back(
new Script(
this, ck));
4361 pMidiRules[0] = NULL;
4373 uint8_t dimkeystart = _3ewg->
ReadUint8();
4388 }
else if (id1 == 0) {
4390 }
else if (id1 == 3) {
4396 else if (id1 != 0 || id2 != 0) {
4401 pMidiRules[i] = NULL;
4413 __notify_progress(pProgress, (
float)
pRegions->size() / (float)
Regions);
4432 ckSCSL->
SetPos(headerSize);
4433 int unknownSpace = slotSize - 2*
sizeof(uint32_t);
4434 for (
int i = 0; i < slotCount; ++i) {
4435 _ScriptPooolEntry e;
4439 scriptPoolFileOffsets.push_back(e);
4445 __notify_progress(pProgress, 1.0f);
4450 RegionList::iterator iter =
pRegions->begin();
4451 RegionList::iterator end =
pRegions->end();
4452 for (; iter != end; ++iter) {
4454 for (
int iKey = pRegion->
KeyRange.
low; iKey <= pRegion->KeyRange.high; iKey++) {
4461 for (
int i = 0 ; pMidiRules[i] ; i++) {
4462 delete pMidiRules[i];
4464 delete[] pMidiRules;
4465 if (pScriptRefs)
delete pScriptRefs;
4483 RegionList::iterator iter =
pRegions->begin();
4484 RegionList::iterator end =
pRegions->end();
4485 for (; iter != end; ++iter)
4486 (*iter)->UpdateChunks();
4510 pData[10] = dimkeystart;
4513 if (pMidiRules[0] == 0 && _3ewg->
GetSize() >= 34) {
4517 for (
int i = 0 ; pMidiRules[i] ; i++) {
4530 const int slotCount = pScriptRefs->size();
4531 const int headerSize = 3 *
sizeof(uint32_t);
4532 const int slotSize = 2 *
sizeof(uint32_t);
4533 const int totalChunkSize = headerSize + slotCount * slotSize;
4536 else ckSCSL->
Resize(totalChunkSize);
4539 store32(&pData[pos], headerSize);
4540 pos +=
sizeof(uint32_t);
4541 store32(&pData[pos], slotCount);
4542 pos +=
sizeof(uint32_t);
4543 store32(&pData[pos], slotSize);
4544 pos +=
sizeof(uint32_t);
4545 for (
int i = 0; i < slotCount; ++i) {
4548 int bogusFileOffset = 0;
4549 store32(&pData[pos], bogusFileOffset);
4550 pos +=
sizeof(uint32_t);
4551 store32(&pData[pos], (*pScriptRefs)[i].bypass ? 1 : 0);
4552 pos +=
sizeof(uint32_t);
4566 const int slotCount = pScriptRefs->size();
4567 const int headerSize = 3 *
sizeof(uint32_t);
4568 ckSCSL->
SetPos(headerSize);
4569 for (
int i = 0; i < slotCount; ++i) {
4570 uint32_t fileOffset =
4571 (*pScriptRefs)[i].script->pChunk->GetFilePos() -
4572 (*pScriptRefs)[i].script->pChunk->GetPos() -
4658 return pMidiRules[i];
4667 delete pMidiRules[0];
4680 delete pMidiRules[0];
4693 delete pMidiRules[0];
4706 delete pMidiRules[i];
4711 if (pScriptRefs)
return;
4712 pScriptRefs =
new std::vector<_ScriptPooolRef>;
4713 if (scriptPoolFileOffsets.empty())
return;
4715 for (uint k = 0; k < scriptPoolFileOffsets.size(); ++k) {
4716 uint32_t soughtOffset = scriptPoolFileOffsets[k].fileOffset;
4719 for (uint s = 0; group->
GetScript(s); ++s) {
4721 if (script->pChunk) {
4722 uint32_t offset = script->pChunk->
GetFilePos() -
4723 script->pChunk->
GetPos() -
4725 if (offset == soughtOffset)
4727 _ScriptPooolRef ref;
4728 ref.script = script;
4729 ref.bypass = scriptPoolFileOffsets[k].bypass;
4730 pScriptRefs->push_back(ref);
4738 scriptPoolFileOffsets.clear();
4755 if (index >= pScriptRefs->size())
return NULL;
4756 return pScriptRefs->at(index).script;
4796 _ScriptPooolRef ref = { pScript, bypass };
4797 pScriptRefs->push_back(ref);
4816 if (index1 >= pScriptRefs->size() || index2 >= pScriptRefs->size())
4818 _ScriptPooolRef tmp = (*pScriptRefs)[index1];
4819 (*pScriptRefs)[index1] = (*pScriptRefs)[index2];
4820 (*pScriptRefs)[index2] = tmp;
4831 if (index >= pScriptRefs->size())
return;
4832 pScriptRefs->erase( pScriptRefs->begin() + index );
4849 for (
int i = pScriptRefs->size() - 1; i >= 0; --i) {
4850 if ((*pScriptRefs)[i].script == pScript) {
4851 pScriptRefs->erase( pScriptRefs->begin() + i );
4871 return pScriptRefs ? pScriptRefs->size() : scriptPoolFileOffsets.size();
4892 return pScriptRefs ? pScriptRefs->at(index).bypass
4893 : scriptPoolFileOffsets.at(index).bypass;
4913 pScriptRefs->at(index).bypass = bBypass;
4915 scriptPoolFileOffsets.at(index).bypass = bBypass;
4951 scriptPoolFileOffsets = orig->scriptPoolFileOffsets;
4952 pScriptRefs = orig->pScriptRefs;
4955 for (
int i = 0 ; pMidiRules[i] ; i++) {
4956 delete pMidiRules[i];
4959 pMidiRules[0] = NULL;
4965 RegionList::const_iterator it = orig->
pRegions->begin();
4966 for (
int i = 0; i < orig->
Regions; ++i, ++it) {
4970 static_cast<gig::Region*>(*it),
4991 pNameChunk = ck3gnm;
5021 if (strcmp(static_cast<char*>(ck->LoadChunkData()),
"") == 0) {
5046 if (pSample->GetGroup() ==
this)
return pSample;
5064 if (pSample->GetGroup() ==
this)
return pSample;
5084 Group* pOtherGroup = NULL;
5086 if (pOtherGroup !=
this)
break;
5089 "Could not move samples to another group, since there is no "
5090 "other Group. This is a bug, report it!"
5105 0, 2, 19980628 & 0xffff, 19980628 >> 16
5110 0, 3, 20030331 & 0xffff, 20030331 >> 16
5138 pScriptGroups = NULL;
5154 pScriptGroups = NULL;
5160 std::list<Group*>::iterator iter = pGroups->begin();
5161 std::list<Group*>::iterator end = pGroups->end();
5162 while (iter != end) {
5168 if (pScriptGroups) {
5169 std::list<ScriptGroup*>::iterator iter = pScriptGroups->begin();
5170 std::list<ScriptGroup*>::iterator end = pScriptGroups->end();
5171 while (iter != end) {
5175 delete pScriptGroups;
5200 DLS::File::SampleList::iterator it =
pSamples->begin();
5201 for (
int i = 0; i < index; ++i) {
5203 if (it ==
pSamples->end())
return NULL;
5205 if (it ==
pSamples->end())
return NULL;
5244 if (iter ==
pSamples->end())
throw gig::Exception(
"Could not delete sample, could not find given sample");
5253 for (
Region* region = instrument->GetFirstRegion() ; region ;
5254 region = instrument->GetNextRegion()) {
5256 if (region->GetSample() == pSample) region->SetSample(NULL);
5258 for (
int i = 0 ; i < region->DimensionRegions ; i++) {
5281 int iSampleIndex = 0;
5290 int nameLen = name.length();
5292 if (nameLen > 4 && name.substr(nameLen - 4) ==
".gig") nameLen -= 4;
5294 for (
int fileNo = 0 ; ; ) {
5297 unsigned long wvplFileOffset = wvpl->
GetFilePos();
5302 const float subprogress = (float) iSampleIndex / (
float) iTotalSamples;
5303 __notify_progress(pProgress, subprogress);
5305 unsigned long waveFileOffset = wave->
GetFilePos();
5306 pSamples->push_back(
new Sample(
this, wave, waveFileOffset - wvplFileOffset, fileNo));
5313 if (fileNo == lastFileNo)
break;
5317 sprintf(suffix,
".gx%02d", fileNo);
5318 name.replace(nameLen, 5, suffix);
5324 __notify_progress(pProgress, 1.0);
5353 __divide_progress(pProgress, &subprogress, 3.0f, 0.0f);
5354 __notify_progress(&subprogress, 0.0f);
5357 __notify_progress(&subprogress, 1.0f);
5360 if (pProgress && pProgress->
callback) {
5364 __notify_progress(&subprogress, 0.0f);
5366 __notify_progress(&subprogress, 1.0f);
5371 if (i == index)
return static_cast<gig::Instrument*
>( *InstrumentsIterator );
5439 static int iCallCount = -1;
5441 std::map<Group*,Group*> mGroups;
5442 std::map<Sample*,Sample*> mSamples;
5445 for (
int i = 0; pFile->
GetGroup(i); ++i) {
5448 "COPY" + ToString(iCallCount) +
"_" + pFile->
GetGroup(i)->
Name;
5453 for (
int i = 0; pFile->
GetSample(i); ++i) {
5485 for (
int i = 0; pFile->
GetSample(i); ++i) {
5513 if (lstInstruments) {
5514 int iInstrumentIndex = 0;
5519 const float localProgress = (float) iInstrumentIndex / (
float)
Instruments;
5520 __notify_progress(pProgress, localProgress);
5524 __divide_progress(pProgress, &subprogress,
Instruments, iInstrumentIndex);
5532 __notify_progress(pProgress, 1.0);
5544 int iWaveIndex = -1;
5545 File::SampleList::iterator iter =
pSamples->begin();
5546 File::SampleList::iterator end =
pSamples->end();
5547 for (
int index = 0; iter != end; ++iter, ++index) {
5548 if (*iter == pSample) {
5553 if (iWaveIndex < 0)
throw gig::Exception(
"Could not update crc, could not find sample");
5556 _3crc->
SetPos(iWaveIndex * 8);
5565 GroupsIterator = pGroups->begin();
5566 return *GroupsIterator;
5570 if (!pGroups)
return NULL;
5572 return (GroupsIterator == pGroups->end()) ? NULL : *GroupsIterator;
5583 GroupsIterator = pGroups->begin();
5584 for (uint i = 0; GroupsIterator != pGroups->end(); i++) {
5585 if (i == index)
return *GroupsIterator;
5603 GroupsIterator = pGroups->begin();
5604 for (uint i = 0; GroupsIterator != pGroups->end(); ++GroupsIterator, ++i)
5605 if ((*GroupsIterator)->Name == name)
return *GroupsIterator;
5614 pGroups->push_back(pGroup);
5629 std::list<Group*>::iterator iter = find(pGroups->begin(), pGroups->end(), pGroup);
5630 if (iter == pGroups->end())
throw gig::Exception(
"Could not delete group, could not find given group");
5631 if (pGroups->size() == 1)
throw gig::Exception(
"Cannot delete group, there must be at least one default group!");
5637 pGroups->erase(iter);
5653 std::list<Group*>::iterator iter = find(pGroups->begin(), pGroups->end(), pGroup);
5654 if (iter == pGroups->end())
throw gig::Exception(
"Could not delete group, could not find given group");
5655 if (pGroups->size() == 1)
throw gig::Exception(
"Cannot delete group, there must be at least one default group!");
5658 pGroups->erase(iter);
5663 if (!pGroups) pGroups =
new std::list<Group*>;
5673 strcmp(static_cast<char*>(ck->
LoadChunkData()),
"") == 0)
break;
5675 pGroups->push_back(
new Group(
this, ck));
5682 if (!pGroups->size()) {
5684 pGroup->
Name =
"Default Group";
5685 pGroups->push_back(pGroup);
5698 std::list<ScriptGroup*>::iterator it = pScriptGroups->begin();
5699 for (uint i = 0; it != pScriptGroups->end(); ++i, ++it)
5700 if (i == index)
return *it;
5714 std::list<ScriptGroup*>::iterator it = pScriptGroups->begin();
5715 for (uint i = 0; it != pScriptGroups->end(); ++i, ++it)
5716 if ((*it)->Name == name)
return *it;
5731 pScriptGroups->push_back(pScriptGroup);
5732 return pScriptGroup;
5749 std::list<ScriptGroup*>::iterator iter =
5750 find(pScriptGroups->begin(), pScriptGroups->end(), pScriptGroup);
5751 if (iter == pScriptGroups->end())
5752 throw gig::Exception(
"Could not delete script group, could not find given script group");
5753 pScriptGroups->erase(iter);
5754 for (
int i = 0; pScriptGroup->
GetScript(i); ++i)
5756 if (pScriptGroup->pList)
5758 delete pScriptGroup;
5762 if (pScriptGroups)
return;
5763 pScriptGroups =
new std::list<ScriptGroup*>;
5770 pScriptGroups->push_back(
new ScriptGroup(
this, lst));
5797 if (pScriptGroups) {
5799 if (pScriptGroups->empty()) {
5806 for (std::list<ScriptGroup*>::iterator it = pScriptGroups->begin();
5807 it != pScriptGroups->end(); ++it)
5809 (*it)->UpdateChunks();
5822 if (first != info) {
5843 for (
int i = 0 ; i < 128 ; i++) {
5844 if (i >= pGroups->size()) ::SaveString(
CHUNK_ID_3GNM, _3gnm, _3gnl,
"",
"",
true, 64);
5849 std::list<Group*>::iterator iter = pGroups->begin();
5850 std::list<Group*>::iterator end = pGroups->end();
5851 for (; iter != end; ++iter) {
5852 (*iter)->UpdateChunks();
5872 int sublen =
pSamples->size() / 8 + 49;
5877 if (einf->
GetSize() != einfSize) {
5881 }
else if (newFile) {
5887 std::map<gig::Sample*,int> sampleMap;
5890 sampleMap[pSample] = sampleIdx++;
5893 int totnbusedsamples = 0;
5894 int totnbusedchannels = 0;
5895 int totnbregions = 0;
5896 int totnbdimregions = 0;
5898 int instrumentIdx = 0;
5900 memset(&pData[48], 0, sublen - 48);
5904 int nbusedsamples = 0;
5905 int nbusedchannels = 0;
5906 int nbdimregions = 0;
5909 memset(&pData[(instrumentIdx + 1) * sublen + 48], 0, sublen - 48);
5911 for (
Region* region = instrument->GetFirstRegion() ; region ;
5912 region = instrument->GetNextRegion()) {
5913 for (
int i = 0 ; i < region->DimensionRegions ; i++) {
5916 int sampleIdx = sampleMap[d->
pSample];
5917 int byte = 48 + sampleIdx / 8;
5918 int bit = 1 << (sampleIdx & 7);
5919 if ((pData[(instrumentIdx + 1) * sublen + byte] & bit) == 0) {
5920 pData[(instrumentIdx + 1) * sublen + byte] |= bit;
5924 if ((pData[byte] & bit) == 0) {
5933 nbdimregions += region->DimensionRegions;
5937 store32(&pData[(instrumentIdx + 1) * sublen + 4], nbusedchannels);
5938 store32(&pData[(instrumentIdx + 1) * sublen + 8], nbusedsamples);
5939 store32(&pData[(instrumentIdx + 1) * sublen + 12], 1);
5940 store32(&pData[(instrumentIdx + 1) * sublen + 16], instrument->Regions);
5941 store32(&pData[(instrumentIdx + 1) * sublen + 20], nbdimregions);
5942 store32(&pData[(instrumentIdx + 1) * sublen + 24], nbloops);
5944 store32(&pData[(instrumentIdx + 1) * sublen + 36], instrumentIdx);
5945 store32(&pData[(instrumentIdx + 1) * sublen + 40],
pSamples->size());
5948 totnbregions += instrument->Regions;
5949 totnbdimregions += nbdimregions;
5950 totnbloops += nbloops;
5955 store32(&pData[4], totnbusedchannels);
5956 store32(&pData[8], totnbusedsamples);
5958 store32(&pData[16], totnbregions);
5959 store32(&pData[20], totnbdimregions);
5960 store32(&pData[24], totnbloops);
5963 store32(&pData[40],
pSamples->size());
5976 }
else if (newFile) {
5991 instrument->UpdateScriptFileOffsets();
6031 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).
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 information 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.
virtual void UpdateChunks()
Apply dimension region settings to the respective RIFF chunks.
MidiRuleAlternator * AddMidiRuleAlternator()
Adds the alternator MIDI rule to the instrument.
virtual void UpdateChunks()
Apply Instrument with all its Regions to the respective RIFF chunks.
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.
lfo1_ctrl_t
Defines how LFO1 is controlled by.
Group of Gigasampler objects.
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).
virtual void UpdateChunks()
Apply all the gig file's current instruments, samples, groups and settings to the respective RIFF chu...
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.
uint ScriptSlotCount() const
Instrument's amount of script slots.
#define GIG_EG_CTR_RELEASE_INFLUENCE_ENCODE(x)
virtual void UpdateChunks()
Apply Instrument with all its Regions to the respective RIFF chunks.
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...
void(* callback)(progress_t *)
Callback function pointer which has to be assigned to a function for progress notification.
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.
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).
uint8_t Key
Key to trigger.
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.
unsigned long GetSize() const
Returns sample size.
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.
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.
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 an 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.
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)
void UpdateChunks(uint8_t *pData) const
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").
float __range_min
Only for internal usage, do not modify!
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()
virtual void UpdateChunks()
Apply Region settings and all its DimensionRegions to the respective RIFF chunks. ...
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.
virtual void UpdateChunks()
Apply all the DLS file's current instruments, samples and settings to the respective RIFF chunks...
Group * GetGroup() const
Returns pointer to the Group this Sample belongs to.
InstrumentList::iterator InstrumentsIterator
Instrument(File *pFile, RIFF::List *insList, progress_t *pProgress=NULL)
Used for indicating the progress of a certain task.
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)
lfo3_ctrl_t
Defines how LFO3 is controlled by.
bool b64BitWavePoolOffsets
ScriptGroup * GetGroup() const
Returns the script group this script currently belongs to.
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)...
float __range_max
Only for internal usage, do not modify!
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.
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.
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.
virtual void UpdateChunks()
Apply Region settings to the respective RIFF chunks.
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.
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...
virtual void UpdateChunks()
Update chunks with current group settings.
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...
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.
void UpdateChunks(uint8_t *pData) const
Ordinary MIDI control change controller, see field 'controller_number'.
vcf_type_t
Defines which frequencies are filtered by the VCF.
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...
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.
uint8_t VCFKeyboardTrackingBreakpoint
See VCFKeyboardTracking (0 - 127).
eg2_ctrl_t EG2Controller
MIDI Controller which has influence on filter cutoff EG parameters (attack, decay, release).
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 * custom
This pointer can be used for arbitrary data.
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)...
float factor
Reflects current progress as value between 0.0 and 1.0.
uint8_t EG2ControllerDecayInfluence
Amount EG2 Controller has influence on the EG2 Decay time (0 - 3, where 0 means off).
unsigned long GetPos() const
Returns the current position in the sample (in sample points).
bool Polyphonic
If alternator should step forward only when all notes are off.
Abstract base class for all MIDI rules.
void SetVelocityResponseCurveScaling(uint8_t scaling)
Updates the respective member variable and the lookup table / cache that depends on this value...
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.
unsigned long GetSize() const
Chunk size in bytes (without header, thus the chunk data body)
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 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
virtual void UpdateChunks()
Apply sample and its settings to the respective RIFF chunks.
unsigned long GuessSize(unsigned long samples)
dimension value between 0-127
int16_t LFO3InternalDepth
Firm depth of the sample pitch LFO (-1200 - +1200 cents).
bool IsNew() const
Returns true if this file has been created new from scratch and has not been stored to disk yet...
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
virtual void Save()
Save changes to same file.
double EG2Decay2
Only if EG2InfiniteSustain == false: 2nd stage decay time of the filter cutoff EG (0...
Encapsulates sample waves used for playback.
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)
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...
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, 4 or 6)
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).
virtual void UpdateChunks()
Apply sample and its settings to the respective RIFF chunks.
int8_t Pan
Panorama / Balance (-64..0..63 <-> left..middle..right)
Only internally controlled.
Parses Gigasampler files and provides abstract access to the data.
void DeleteRegion(Region *pRegion)
void SetGroup(ScriptGroup *pGroup)
Move this script from its current ScriptGroup to another ScriptGroup given by pGroup.
lfo2_ctrl_t
Defines how LFO2 is controlled by.
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...
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 all neccessary information for the synthesis of an 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.
virtual void LoadGroups()
Quadtuple version number ("major.minor.release.build").
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...
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.
virtual void UpdateChunks()
Apply all sample player options to the respective RIFF chunk.
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.
Region * GetParent() const
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, release).
uint32_t * pWavePoolTableHi
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.
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
void UpdateChunks(uint8_t *pData) const
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 UpdateFileOffsets()
Updates all file offsets stored all over the file.