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)
2050 switch (curveType) {
2054 printf(
"Warning: Invalid depth (0x%x) for velocity curve type (0x%x).\n", depth, curveType);
2061 printf(
"Warning: Invalid depth (0x%x) for velocity curve type 'special'.\n", depth);
2068 printf(
"Warning: Unknown velocity curve type (0x%x).\n", curveType);
2076 uint32_t tableKey = (curveType<<16) | (depth<<8) | scaling;
2077 if (pVelocityTables->count(tableKey)) {
2078 table = (*pVelocityTables)[tableKey];
2081 table = CreateVelocityTable(curveType, depth, scaling);
2082 (*pVelocityTables)[tableKey] = table;
2097 leverage_ctrl_t DimensionRegion::DecodeLeverageController(_lev_ctrl_t EncodedController) {
2099 switch (EncodedController) {
2101 case _lev_ctrl_none:
2105 case _lev_ctrl_velocity:
2109 case _lev_ctrl_channelaftertouch:
2115 case _lev_ctrl_modwheel:
2119 case _lev_ctrl_breath:
2123 case _lev_ctrl_foot:
2127 case _lev_ctrl_effect1:
2131 case _lev_ctrl_effect2:
2135 case _lev_ctrl_genpurpose1:
2139 case _lev_ctrl_genpurpose2:
2143 case _lev_ctrl_genpurpose3:
2147 case _lev_ctrl_genpurpose4:
2151 case _lev_ctrl_portamentotime:
2155 case _lev_ctrl_sustainpedal:
2159 case _lev_ctrl_portamento:
2163 case _lev_ctrl_sostenutopedal:
2167 case _lev_ctrl_softpedal:
2171 case _lev_ctrl_genpurpose5:
2175 case _lev_ctrl_genpurpose6:
2179 case _lev_ctrl_genpurpose7:
2183 case _lev_ctrl_genpurpose8:
2187 case _lev_ctrl_effect1depth:
2191 case _lev_ctrl_effect2depth:
2195 case _lev_ctrl_effect3depth:
2199 case _lev_ctrl_effect4depth:
2203 case _lev_ctrl_effect5depth:
2211 case _lev_ctrl_CC3_EXT:
2215 case _lev_ctrl_CC6_EXT:
2219 case _lev_ctrl_CC7_EXT:
2223 case _lev_ctrl_CC8_EXT:
2227 case _lev_ctrl_CC9_EXT:
2231 case _lev_ctrl_CC10_EXT:
2235 case _lev_ctrl_CC11_EXT:
2239 case _lev_ctrl_CC14_EXT:
2243 case _lev_ctrl_CC15_EXT:
2247 case _lev_ctrl_CC20_EXT:
2251 case _lev_ctrl_CC21_EXT:
2255 case _lev_ctrl_CC22_EXT:
2259 case _lev_ctrl_CC23_EXT:
2263 case _lev_ctrl_CC24_EXT:
2267 case _lev_ctrl_CC25_EXT:
2271 case _lev_ctrl_CC26_EXT:
2275 case _lev_ctrl_CC27_EXT:
2279 case _lev_ctrl_CC28_EXT:
2283 case _lev_ctrl_CC29_EXT:
2287 case _lev_ctrl_CC30_EXT:
2291 case _lev_ctrl_CC31_EXT:
2295 case _lev_ctrl_CC68_EXT:
2299 case _lev_ctrl_CC69_EXT:
2303 case _lev_ctrl_CC70_EXT:
2307 case _lev_ctrl_CC71_EXT:
2311 case _lev_ctrl_CC72_EXT:
2315 case _lev_ctrl_CC73_EXT:
2319 case _lev_ctrl_CC74_EXT:
2323 case _lev_ctrl_CC75_EXT:
2327 case _lev_ctrl_CC76_EXT:
2331 case _lev_ctrl_CC77_EXT:
2335 case _lev_ctrl_CC78_EXT:
2339 case _lev_ctrl_CC79_EXT:
2343 case _lev_ctrl_CC84_EXT:
2347 case _lev_ctrl_CC85_EXT:
2351 case _lev_ctrl_CC86_EXT:
2355 case _lev_ctrl_CC87_EXT:
2359 case _lev_ctrl_CC89_EXT:
2363 case _lev_ctrl_CC90_EXT:
2367 case _lev_ctrl_CC96_EXT:
2371 case _lev_ctrl_CC97_EXT:
2375 case _lev_ctrl_CC102_EXT:
2379 case _lev_ctrl_CC103_EXT:
2383 case _lev_ctrl_CC104_EXT:
2387 case _lev_ctrl_CC105_EXT:
2391 case _lev_ctrl_CC106_EXT:
2395 case _lev_ctrl_CC107_EXT:
2399 case _lev_ctrl_CC108_EXT:
2403 case _lev_ctrl_CC109_EXT:
2407 case _lev_ctrl_CC110_EXT:
2411 case _lev_ctrl_CC111_EXT:
2415 case _lev_ctrl_CC112_EXT:
2419 case _lev_ctrl_CC113_EXT:
2423 case _lev_ctrl_CC114_EXT:
2427 case _lev_ctrl_CC115_EXT:
2431 case _lev_ctrl_CC116_EXT:
2435 case _lev_ctrl_CC117_EXT:
2439 case _lev_ctrl_CC118_EXT:
2443 case _lev_ctrl_CC119_EXT:
2452 return decodedcontroller;
2458 DimensionRegion::_lev_ctrl_t DimensionRegion::EncodeLeverageController(
leverage_ctrl_t DecodedController) {
2459 _lev_ctrl_t encodedcontroller;
2460 switch (DecodedController.
type) {
2463 encodedcontroller = _lev_ctrl_none;
2466 encodedcontroller = _lev_ctrl_velocity;
2469 encodedcontroller = _lev_ctrl_channelaftertouch;
2476 encodedcontroller = _lev_ctrl_modwheel;
2479 encodedcontroller = _lev_ctrl_breath;
2482 encodedcontroller = _lev_ctrl_foot;
2485 encodedcontroller = _lev_ctrl_effect1;
2488 encodedcontroller = _lev_ctrl_effect2;
2491 encodedcontroller = _lev_ctrl_genpurpose1;
2494 encodedcontroller = _lev_ctrl_genpurpose2;
2497 encodedcontroller = _lev_ctrl_genpurpose3;
2500 encodedcontroller = _lev_ctrl_genpurpose4;
2503 encodedcontroller = _lev_ctrl_portamentotime;
2506 encodedcontroller = _lev_ctrl_sustainpedal;
2509 encodedcontroller = _lev_ctrl_portamento;
2512 encodedcontroller = _lev_ctrl_sostenutopedal;
2515 encodedcontroller = _lev_ctrl_softpedal;
2518 encodedcontroller = _lev_ctrl_genpurpose5;
2521 encodedcontroller = _lev_ctrl_genpurpose6;
2524 encodedcontroller = _lev_ctrl_genpurpose7;
2527 encodedcontroller = _lev_ctrl_genpurpose8;
2530 encodedcontroller = _lev_ctrl_effect1depth;
2533 encodedcontroller = _lev_ctrl_effect2depth;
2536 encodedcontroller = _lev_ctrl_effect3depth;
2539 encodedcontroller = _lev_ctrl_effect4depth;
2542 encodedcontroller = _lev_ctrl_effect5depth;
2549 encodedcontroller = _lev_ctrl_CC3_EXT;
2552 encodedcontroller = _lev_ctrl_CC6_EXT;
2555 encodedcontroller = _lev_ctrl_CC7_EXT;
2558 encodedcontroller = _lev_ctrl_CC8_EXT;
2561 encodedcontroller = _lev_ctrl_CC9_EXT;
2564 encodedcontroller = _lev_ctrl_CC10_EXT;
2567 encodedcontroller = _lev_ctrl_CC11_EXT;
2570 encodedcontroller = _lev_ctrl_CC14_EXT;
2573 encodedcontroller = _lev_ctrl_CC15_EXT;
2576 encodedcontroller = _lev_ctrl_CC20_EXT;
2579 encodedcontroller = _lev_ctrl_CC21_EXT;
2582 encodedcontroller = _lev_ctrl_CC22_EXT;
2585 encodedcontroller = _lev_ctrl_CC23_EXT;
2588 encodedcontroller = _lev_ctrl_CC24_EXT;
2591 encodedcontroller = _lev_ctrl_CC25_EXT;
2594 encodedcontroller = _lev_ctrl_CC26_EXT;
2597 encodedcontroller = _lev_ctrl_CC27_EXT;
2600 encodedcontroller = _lev_ctrl_CC28_EXT;
2603 encodedcontroller = _lev_ctrl_CC29_EXT;
2606 encodedcontroller = _lev_ctrl_CC30_EXT;
2609 encodedcontroller = _lev_ctrl_CC31_EXT;
2612 encodedcontroller = _lev_ctrl_CC68_EXT;
2615 encodedcontroller = _lev_ctrl_CC69_EXT;
2618 encodedcontroller = _lev_ctrl_CC70_EXT;
2621 encodedcontroller = _lev_ctrl_CC71_EXT;
2624 encodedcontroller = _lev_ctrl_CC72_EXT;
2627 encodedcontroller = _lev_ctrl_CC73_EXT;
2630 encodedcontroller = _lev_ctrl_CC74_EXT;
2633 encodedcontroller = _lev_ctrl_CC75_EXT;
2636 encodedcontroller = _lev_ctrl_CC76_EXT;
2639 encodedcontroller = _lev_ctrl_CC77_EXT;
2642 encodedcontroller = _lev_ctrl_CC78_EXT;
2645 encodedcontroller = _lev_ctrl_CC79_EXT;
2648 encodedcontroller = _lev_ctrl_CC84_EXT;
2651 encodedcontroller = _lev_ctrl_CC85_EXT;
2654 encodedcontroller = _lev_ctrl_CC86_EXT;
2657 encodedcontroller = _lev_ctrl_CC87_EXT;
2660 encodedcontroller = _lev_ctrl_CC89_EXT;
2663 encodedcontroller = _lev_ctrl_CC90_EXT;
2666 encodedcontroller = _lev_ctrl_CC96_EXT;
2669 encodedcontroller = _lev_ctrl_CC97_EXT;
2672 encodedcontroller = _lev_ctrl_CC102_EXT;
2675 encodedcontroller = _lev_ctrl_CC103_EXT;
2678 encodedcontroller = _lev_ctrl_CC104_EXT;
2681 encodedcontroller = _lev_ctrl_CC105_EXT;
2684 encodedcontroller = _lev_ctrl_CC106_EXT;
2687 encodedcontroller = _lev_ctrl_CC107_EXT;
2690 encodedcontroller = _lev_ctrl_CC108_EXT;
2693 encodedcontroller = _lev_ctrl_CC109_EXT;
2696 encodedcontroller = _lev_ctrl_CC110_EXT;
2699 encodedcontroller = _lev_ctrl_CC111_EXT;
2702 encodedcontroller = _lev_ctrl_CC112_EXT;
2705 encodedcontroller = _lev_ctrl_CC113_EXT;
2708 encodedcontroller = _lev_ctrl_CC114_EXT;
2711 encodedcontroller = _lev_ctrl_CC115_EXT;
2714 encodedcontroller = _lev_ctrl_CC116_EXT;
2717 encodedcontroller = _lev_ctrl_CC117_EXT;
2720 encodedcontroller = _lev_ctrl_CC118_EXT;
2723 encodedcontroller = _lev_ctrl_CC119_EXT;
2727 throw gig::Exception(
"leverage controller number is not supported by the gig format");
2733 return encodedcontroller;
2740 VelocityTableMap::iterator iter;
2741 for (iter = pVelocityTables->begin(); iter != pVelocityTables->end(); iter++) {
2742 double* pTable = iter->second;
2743 if (pTable)
delete[] pTable;
2745 pVelocityTables->clear();
2746 delete pVelocityTables;
2747 pVelocityTables = NULL;
2764 return pVelocityAttenuationTable[MIDIKeyVelocity];
2768 return pVelocityReleaseTable[MIDIKeyVelocity];
2772 return pVelocityCutoffTable[MIDIKeyVelocity];
2780 pVelocityAttenuationTable =
2792 pVelocityAttenuationTable =
2804 pVelocityAttenuationTable =
2865 double* DimensionRegion::CreateVelocityTable(
curve_type_t curveType, uint8_t depth, uint8_t scaling) {
2870 const int lin0[] = { 1, 1, 127, 127 };
2871 const int lin1[] = { 1, 21, 127, 127 };
2872 const int lin2[] = { 1, 45, 127, 127 };
2873 const int lin3[] = { 1, 74, 127, 127 };
2874 const int lin4[] = { 1, 127, 127, 127 };
2877 const int non0[] = { 1, 4, 24, 5, 57, 17, 92, 57, 122, 127, 127, 127 };
2878 const int non1[] = { 1, 4, 46, 9, 93, 56, 118, 106, 123, 127,
2880 const int non2[] = { 1, 4, 46, 9, 57, 20, 102, 107, 107, 127,
2882 const int non3[] = { 1, 15, 10, 19, 67, 73, 80, 80, 90, 98, 98, 127,
2884 const int non4[] = { 1, 25, 33, 57, 82, 81, 92, 127, 127, 127 };
2887 const int spe0[] = { 1, 2, 76, 10, 90, 15, 95, 20, 99, 28, 103, 44,
2888 113, 127, 127, 127 };
2889 const int spe1[] = { 1, 2, 27, 5, 67, 18, 89, 29, 95, 35, 107, 67,
2890 118, 127, 127, 127 };
2891 const int spe2[] = { 1, 1, 33, 1, 53, 5, 61, 13, 69, 32, 79, 74,
2892 85, 90, 91, 127, 127, 127 };
2893 const int spe3[] = { 1, 32, 28, 35, 66, 48, 89, 59, 95, 65, 99, 73,
2894 117, 127, 127, 127 };
2895 const int spe4[] = { 1, 4, 23, 5, 49, 13, 57, 17, 92, 57, 122, 127,
2899 const int spe5[] = { 1, 2, 30, 5, 60, 19, 77, 70, 83, 85, 88, 106,
2900 91, 127, 127, 127 };
2902 const int*
const curves[] = { non0, non1, non2, non3, non4,
2903 lin0, lin1, lin2, lin3, lin4,
2904 spe0, spe1, spe2, spe3, spe4, spe5 };
2906 double*
const table =
new double[128];
2908 const int* curve = curves[curveType * 5 + depth];
2909 const int s = scaling == 0 ? 20 : scaling;
2912 for (
int x = 1 ; x < 128 ; x++) {
2914 if (x > curve[2]) curve += 2;
2915 double y = curve[1] + (x - curve[0]) *
2916 (
double(curve[3] - curve[1]) / (curve[2] - curve[0]));
2921 if (s < 20 && y >= 0.5)
2922 y = y / ((2 - 40.0 / s) * y + 40.0 / s - 1);
2939 for (
int i = 0; i < 256; i++) {
2955 for (
int i = 0; i < dimensionBits; i++) {
2996 uint32_t wavepoolindex = _3lnk->
ReadUint32();
3003 for (
int i = 0 ; i < 8 ; i++) {
3047 const int iMaxDimensions = version3 ? 8 : 5;
3048 const int iMaxDimensionRegions = version3 ? 256 : 32;
3053 const int _3lnkChunkSize = version3 ? 1092 : 172;
3063 store32(&pData[0], DimensionRegions);
3065 for (
int i = 0; i < iMaxDimensions; i++) {
3077 const int iWavePoolOffset = version3 ? 68 : 44;
3078 for (uint i = 0; i < iMaxDimensionRegions; i++) {
3079 int iWaveIndex = -1;
3080 if (i < DimensionRegions) {
3082 File::SampleList::iterator iter = pFile->
pSamples->begin();
3083 File::SampleList::iterator end = pFile->
pSamples->end();
3084 for (
int index = 0; iter != end; ++iter, ++index) {
3091 store32(&pData[iWavePoolOffset + i * 4], iWaveIndex);
3098 int dimensionRegionNr = 0;
3103 dimensionRegionNr++;
3107 if (dimensionRegionNr == 0)
throw gig::Exception(
"No dimension region found.");
3127 if (veldim == -1)
return;
3143 table =
new uint8_t[128];
3147 int velocityZone = 0;
3149 for (
int k = i ; k < end ; k += step) {
3151 for (; tableidx <= d->
DimensionUpperLimits[veldim] ; tableidx++) table[tableidx] = velocityZone;
3155 for (
int k = i ; k < end ; k += step) {
3157 for (; tableidx <= d->
VelocityUpperLimit ; tableidx++) table[tableidx] = velocityZone;
3171 if (j == veldim) i += skipveldim;
3184 if (j == Dimensions)
break;
3205 if (pDimDef->
zones < 2)
3206 throw gig::Exception(
"Could not add new dimension, amount of requested zones must always be at least two");
3207 if (pDimDef->
bits < 1)
3208 throw gig::Exception(
"Could not add new dimension, amount of requested requested zone bits must always be at least one");
3210 if (pDimDef->
zones != 2)
3211 throw gig::Exception(
"Could not add new 'sample channel' dimensions, the requested amount of zones must always be 2 for this dimension type");
3212 if (pDimDef->
bits != 1)
3213 throw gig::Exception(
"Could not add new 'sample channel' dimensions, the requested amount of zone bits must always be 1 for this dimension type");
3220 throw gig::Exception(
"Could not add new dimension, max. amount of " + ToString(iMaxDimensions) +
" dimensions already reached");
3222 int iCurrentBits = 0;
3225 if (iCurrentBits >= iMaxDimensions)
3226 throw gig::Exception(
"Could not add new dimension, max. amount of " + ToString(iMaxDimensions) +
" dimension bits already reached");
3227 const int iNewBits = iCurrentBits + pDimDef->
bits;
3228 if (iNewBits > iMaxDimensions)
3229 throw gig::Exception(
"Could not add new dimension, new dimension would exceed max. amount of " + ToString(iMaxDimensions) +
" dimension bits");
3233 throw gig::Exception(
"Could not add new dimension, there is already a dimension of the same type");
3240 for (
int i = 0 ; i < pos ; i++)
3245 for (
int i = 0 ; i < (1 << iCurrentBits) ; i++) {
3246 for (
int j = Dimensions ; j > pos ; j--) {
3266 for (
int i = (1 << iCurrentBits) - (1 << bitpos) ; i >= 0 ; i -= (1 << bitpos)) {
3267 for (
int k = 0 ; k < (1 << bitpos) ; k++) {
3270 for (
int j = 1 ; j < (1 << pDimDef->
bits) ; j++) {
3271 for (
int k = 0 ; k < (1 << bitpos) ; k++) {
3273 if (moveTo) _3prg->
MoveSubChunk(pNewDimRgnListChunk, moveTo);
3286 int mask = (1 << bitpos) - 1;
3287 for (
int z = 0 ; z < pDimDef->
zones ; z++) {
3288 uint8_t upperLimit = uint8_t((z + 1) * 128.0 / pDimDef->
zones - 1);
3289 for (
int i = 0 ; i < 1 << iCurrentBits ; i++) {
3317 int iDimensionNr = -1;
3324 if (iDimensionNr < 0)
throw gig::Exception(
"Invalid dimension_def_t pointer");
3328 for (
int i = 0; i < iDimensionNr; i++)
3333 for (
int i = iDimensionNr + 1; i <
Dimensions; i++)
3340 for (
int iUpperBit = 0; iUpperBit < 1 << iUpperBits; iUpperBit++) {
3342 for (
int iLowerBit = 0; iLowerBit < 1 << iLowerBits; iLowerBit++) {
3344 iObsoleteBit << iLowerBits |
3357 for (
int iFrom = 2, iTo = 1; iFrom < 256 && iTo < 256 - 1; iTo++) {
3359 if (iFrom <= iTo) iFrom = iTo + 1;
3371 for (
int i = iDimensionNr + 1; i <
Dimensions; i++) {
3378 for (
int i = iDimensionNr + 1; i <
Dimensions; i++) {
3408 throw gig::Exception(
"Could not delete dimension zone, no such dimension of given type");
3409 if (oldDef->
zones <= 2)
3410 throw gig::Exception(
"Could not delete dimension zone, because it would end up with only one zone.");
3411 if (zone < 0 || zone >= oldDef->
zones)
3412 throw gig::Exception(
"Could not delete dimension zone, requested zone index out of bounds.");
3414 const int newZoneSize = oldDef->
zones - 1;
3427 tempRgn =
new Region(instr, rgn);
3439 def.
zones = newZoneSize;
3448 int tempReducedDimensionIndex = -1;
3449 for (
int d = 0; d < tempRgn->
Dimensions; ++d) {
3451 tempReducedDimensionIndex = d;
3457 for (
int iDst = 0; iDst < 256; ++iDst) {
3459 if (!dstDimRgn)
continue;
3460 std::map<dimension_t,int> dimCase;
3461 bool isValidZone =
true;
3462 for (
int d = 0, baseBits = 0; d < tempRgn->
Dimensions; ++d) {
3465 (iDst >> baseBits) & ((1 << dstBits) - 1);
3466 baseBits += dstBits;
3469 isValidZone =
false;
3473 if (!isValidZone)
continue;
3476 const bool isLastZone = (dimCase[type] == newZoneSize - 1);
3477 if (dimCase[type] >= zone) dimCase[type]++;
3492 for (
int iSrc = 0; iSrc < 256; ++iSrc) {
3494 if (!srcDimRgn)
continue;
3495 std::map<dimension_t,int> dimCase;
3496 for (
int d = 0, baseBits = 0; d < tempRgn->
Dimensions; ++d) {
3499 (iSrc >> baseBits) & ((1 << srcBits) - 1);
3500 baseBits += srcBits;
3505 if (!dstDimRgn)
continue;
3532 throw gig::Exception(
"Could not split dimension zone, no such dimension of given type");
3533 if (zone < 0 || zone >= oldDef->
zones)
3534 throw gig::Exception(
"Could not split dimension zone, requested zone index out of bounds.");
3536 const int newZoneSize = oldDef->
zones + 1;
3549 tempRgn =
new Region(instr, rgn);
3561 def.
zones = newZoneSize;
3562 if ((1 << oldDef->
bits) < newZoneSize) def.
bits++;
3570 int tempIncreasedDimensionIndex = -1;
3571 for (
int d = 0; d < tempRgn->
Dimensions; ++d) {
3573 tempIncreasedDimensionIndex = d;
3579 for (
int iSrc = 0; iSrc < 256; ++iSrc) {
3581 if (!srcDimRgn)
continue;
3582 std::map<dimension_t,int> dimCase;
3583 bool isValidZone =
true;
3584 for (
int d = 0, baseBits = 0; d <
Dimensions; ++d) {
3587 (iSrc >> baseBits) & ((1 << srcBits) - 1);
3589 if (dimCase[pDimensionDefinitions[d].dimension] >= pDimensionDefinitions[d].zones) {
3590 isValidZone =
false;
3593 baseBits += srcBits;
3595 if (!isValidZone)
continue;
3598 if (dimCase[type] > zone) dimCase[type]++;
3604 if (dimCase[type] == zone) {
3611 std::map<dimension_t,int> lowerCase = dimCase;
3631 for (
int iSrc = 0; iSrc < 256; ++iSrc) {
3633 if (!srcDimRgn)
continue;
3634 std::map<dimension_t,int> dimCase;
3635 for (
int d = 0, baseBits = 0; d < tempRgn->
Dimensions; ++d) {
3638 (iSrc >> baseBits) & ((1 << srcBits) - 1);
3639 baseBits += srcBits;
3644 if (!dstDimRgn)
continue;
3669 if (oldType == newType)
return;
3672 throw gig::Exception(
"No dimension with provided old dimension type exists on this region");
3674 throw gig::Exception(
"Cannot change to dimension type 'sample channel', because existing dimension does not have 2 zones");
3676 throw gig::Exception(
"There is already a dimension with requested new dimension type on this region");
3678 def->
split_type = __resolveSplitType(newType);
3682 uint8_t bits[8] = {};
3683 for (std::map<dimension_t,int>::const_iterator it = DimCase.begin();
3684 it != DimCase.end(); ++it)
3688 bits[d] = it->second;
3689 goto nextDimCaseSlice;
3716 for (
int i = 0; i < 256; i++) {
3756 if (DimValues[i] <=
pDimensionRegions[bits << bitpos]->DimensionUpperLimits[i])
break;
3765 bits = DimValues[i] & limiter_mask;
3768 dimregidx |= bits << bitpos;
3773 if (!dimreg)
return NULL;
3782 dimregidx |= (bits & limiter_mask) << velbitpos;
3805 if (DimValues[i] <=
pDimensionRegions[bits << bitpos]->DimensionUpperLimits[i])
break;
3814 bits = DimValues[i] & limiter_mask;
3817 dimregidx |= bits << bitpos;
3823 if (!dimreg)
return -1;
3832 dimregidx |= (bits & limiter_mask) << velbitpos;
3873 if ((int32_t)WavePoolTableIndex == -1)
return NULL;
3876 if (WavePoolTableIndex + 1 > file->
WavePoolCount)
return NULL;
3927 for (
int i = 0; i < 256; i++) {
3948 for (
int i = 0 ; i < Triggers ; i++) {
3949 pTriggers[i].TriggerPoint = _3ewg->
ReadUint8();
3950 pTriggers[i].Descending = _3ewg->
ReadUint8();
3951 pTriggers[i].VelSensitivity = _3ewg->
ReadUint8();
3953 pTriggers[i].NoteOff = _3ewg->
ReadUint8();
3954 pTriggers[i].Velocity = _3ewg->
ReadUint8();
3955 pTriggers[i].OverridePedal = _3ewg->
ReadUint8();
3961 ControllerNumber(0),
3970 for (
int i = 0 ; i <
Triggers ; i++) {
3985 BypassUseController = _3ewg->
ReadUint8();
4002 BypassUseController(false),
4004 BypassController(1),
4007 ReleaseTriggerKey(0),
4034 Polyphonic = flags & 8;
4035 Chained = flags & 4;
4036 Selector = (flags & 2) ? selector_controller :
4037 (flags & 1) ? selector_key_switch : selector_none;
4043 KeySwitchRange.low = _3ewg->
ReadUint8();
4044 KeySwitchRange.high = _3ewg->
ReadUint8();
4049 int n = std::min(
int(Articulations), 32);
4050 for (
int i = 0 ; i < n ; i++) {
4054 n = std::min(
int(Patterns), 32);
4055 for (
int i = 0 ; i < n ; i++) {
4058 _3ewg->
Read(&pPatterns[i][0], 1, 32);
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)
4131 Compression = COMPRESSION_NONE;
4132 Encoding = ENCODING_ASCII;
4133 Language = LANGUAGE_NKSP;
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());
4176 __calculateCRC(&data[0], data.size(), crc);
4179 const int chunkSize = 7*
sizeof(int32_t) + Name.size() + data.size();
4180 if (!pChunk) pChunk = pGroup->pList->AddSubChunk(
CHUNK_ID_SCRI, chunkSize);
4181 else pChunk->Resize(chunkSize);
4183 uint8_t* pData = (uint8_t*) pChunk->LoadChunkData();
4185 store32(&pData[pos], 6*
sizeof(int32_t) + Name.size());
4186 pos +=
sizeof(int32_t);
4187 store32(&pData[pos], Compression);
4188 pos +=
sizeof(int32_t);
4189 store32(&pData[pos], Encoding);
4190 pos +=
sizeof(int32_t);
4191 store32(&pData[pos], Language);
4192 pos +=
sizeof(int32_t);
4193 store32(&pData[pos], Bypass ? 1 : 0);
4194 pos +=
sizeof(int32_t);
4195 store32(&pData[pos], crc);
4196 pos +=
sizeof(int32_t);
4197 store32(&pData[pos], Name.size());
4198 pos +=
sizeof(int32_t);
4199 for (
int i = 0; i < Name.size(); ++i, ++pos)
4200 pData[pos] = Name[i];
4201 for (
int i = 0; i < data.size(); ++i, ++pos)
4202 pData[pos] = data[i];
4212 if (this->pGroup = pGroup)
return;
4214 pChunk->GetParent()->MoveSubChunk(pChunk, pGroup->pList);
4215 this->pGroup = pGroup;
4229 File* pFile = pGroup->pFile;
4247 Name =
"Default Group";
4253 std::list<Script*>::iterator iter = pScripts->begin();
4254 std::list<Script*>::iterator end = pScripts->end();
4255 while (iter != end) {
4280 for (std::list<Script*>::iterator it = pScripts->begin();
4281 it != pScripts->end(); ++it)
4283 (*it)->UpdateChunks(pProgress);
4296 if (!pScripts) LoadScripts();
4297 std::list<Script*>::iterator it = pScripts->begin();
4298 for (uint i = 0; it != pScripts->end(); ++i, ++it)
4299 if (i == index)
return *it;
4315 if (!pScripts) LoadScripts();
4317 pScripts->push_back(pScript);
4332 if (!pScripts) LoadScripts();
4333 std::list<Script*>::iterator iter =
4334 find(pScripts->begin(), pScripts->end(), pScript);
4335 if (iter == pScripts->end())
4336 throw gig::Exception(
"Could not delete script, could not find given script");
4337 pScripts->erase(iter);
4339 if (pScript->pChunk)
4345 if (pScripts)
return;
4346 pScripts =
new std::list<Script*>;
4349 for (
RIFF::Chunk* ck = pList->GetFirstSubChunk(); ck;
4350 ck = pList->GetNextSubChunk())
4353 pScripts->push_back(
new Script(
this, ck));
4379 pMidiRules[0] = NULL;
4391 uint8_t dimkeystart = _3ewg->
ReadUint8();
4406 }
else if (id1 == 0) {
4408 }
else if (id1 == 3) {
4414 else if (id1 != 0 || id2 != 0) {
4419 pMidiRules[i] = NULL;
4431 __notify_progress(pProgress, (
float)
pRegions->size() / (float)
Regions);
4450 ckSCSL->
SetPos(headerSize);
4451 int unknownSpace = slotSize - 2*
sizeof(uint32_t);
4452 for (
int i = 0; i < slotCount; ++i) {
4453 _ScriptPooolEntry e;
4457 scriptPoolFileOffsets.push_back(e);
4463 __notify_progress(pProgress, 1.0f);
4468 RegionList::iterator iter =
pRegions->begin();
4469 RegionList::iterator end =
pRegions->end();
4470 for (; iter != end; ++iter) {
4474 for (
int iKey = low; iKey <= high; iKey++) {
4481 for (
int i = 0 ; pMidiRules[i] ; i++) {
4482 delete pMidiRules[i];
4484 delete[] pMidiRules;
4485 if (pScriptRefs)
delete pScriptRefs;
4504 RegionList::iterator iter =
pRegions->begin();
4505 RegionList::iterator end =
pRegions->end();
4506 for (; iter != end; ++iter)
4507 (*iter)->UpdateChunks(pProgress);
4531 pData[10] = dimkeystart;
4534 if (pMidiRules[0] == 0 && _3ewg->
GetSize() >= 34) {
4538 for (
int i = 0 ; pMidiRules[i] ; i++) {
4551 const int slotCount = pScriptRefs->size();
4552 const int headerSize = 3 *
sizeof(uint32_t);
4553 const int slotSize = 2 *
sizeof(uint32_t);
4554 const int totalChunkSize = headerSize + slotCount * slotSize;
4557 else ckSCSL->
Resize(totalChunkSize);
4560 store32(&pData[pos], headerSize);
4561 pos +=
sizeof(uint32_t);
4562 store32(&pData[pos], slotCount);
4563 pos +=
sizeof(uint32_t);
4564 store32(&pData[pos], slotSize);
4565 pos +=
sizeof(uint32_t);
4566 for (
int i = 0; i < slotCount; ++i) {
4569 int bogusFileOffset = 0;
4570 store32(&pData[pos], bogusFileOffset);
4571 pos +=
sizeof(uint32_t);
4572 store32(&pData[pos], (*pScriptRefs)[i].bypass ? 1 : 0);
4573 pos +=
sizeof(uint32_t);
4584 if (pScriptRefs && pScriptRefs->size() > 0) {
4587 const int slotCount = pScriptRefs->size();
4588 const int headerSize = 3 *
sizeof(uint32_t);
4589 ckSCSL->
SetPos(headerSize);
4590 for (
int i = 0; i < slotCount; ++i) {
4591 uint32_t fileOffset =
4592 (*pScriptRefs)[i].script->pChunk->GetFilePos() -
4593 (*pScriptRefs)[i].script->pChunk->GetPos() -
4698 "gig::Instrument::MoveTo() can only be used for moving within " 4699 "the same gig file." 4708 DLS::File::InstrumentList::iterator itFrom =
4709 std::find(list.begin(), list.end(),
static_cast<DLS::Instrument*
>(
this));
4711 DLS::File::InstrumentList::iterator itTo =
4712 std::find(list.begin(), list.end(),
static_cast<DLS::Instrument*
>(dst));
4714 list.splice(itTo, list, itFrom);
4736 return pMidiRules[i];
4745 delete pMidiRules[0];
4758 delete pMidiRules[0];
4771 delete pMidiRules[0];
4784 delete pMidiRules[i];
4789 if (pScriptRefs)
return;
4790 pScriptRefs =
new std::vector<_ScriptPooolRef>;
4791 if (scriptPoolFileOffsets.empty())
return;
4793 for (uint k = 0; k < scriptPoolFileOffsets.size(); ++k) {
4794 uint32_t soughtOffset = scriptPoolFileOffsets[k].fileOffset;
4797 for (uint s = 0; group->
GetScript(s); ++s) {
4799 if (script->pChunk) {
4800 uint32_t offset = script->pChunk->
GetFilePos() -
4801 script->pChunk->
GetPos() -
4803 if (offset == soughtOffset)
4805 _ScriptPooolRef ref;
4806 ref.script = script;
4807 ref.bypass = scriptPoolFileOffsets[k].bypass;
4808 pScriptRefs->push_back(ref);
4816 scriptPoolFileOffsets.clear();
4833 if (index >= pScriptRefs->size())
return NULL;
4834 return pScriptRefs->at(index).script;
4874 _ScriptPooolRef ref = { pScript, bypass };
4875 pScriptRefs->push_back(ref);
4894 if (index1 >= pScriptRefs->size() || index2 >= pScriptRefs->size())
4896 _ScriptPooolRef tmp = (*pScriptRefs)[index1];
4897 (*pScriptRefs)[index1] = (*pScriptRefs)[index2];
4898 (*pScriptRefs)[index2] = tmp;
4909 if (index >= pScriptRefs->size())
return;
4910 pScriptRefs->erase( pScriptRefs->begin() + index );
4927 for (
int i = pScriptRefs->size() - 1; i >= 0; --i) {
4928 if ((*pScriptRefs)[i].script == pScript) {
4929 pScriptRefs->erase( pScriptRefs->begin() + i );
4949 return pScriptRefs ? pScriptRefs->size() : scriptPoolFileOffsets.size();
4970 return pScriptRefs ? pScriptRefs->at(index).bypass
4971 : scriptPoolFileOffsets.at(index).bypass;
4991 pScriptRefs->at(index).bypass = bBypass;
4993 scriptPoolFileOffsets.at(index).bypass = bBypass;
5029 scriptPoolFileOffsets = orig->scriptPoolFileOffsets;
5030 pScriptRefs = orig->pScriptRefs;
5033 for (
int i = 0 ; pMidiRules[i] ; i++) {
5034 delete pMidiRules[i];
5037 pMidiRules[0] = NULL;
5043 RegionList::const_iterator it = orig->
pRegions->begin();
5044 for (
int i = 0; i < orig->
Regions; ++i, ++it) {
5048 static_cast<gig::Region*>(*it),
5069 pNameChunk = ck3gnm;
5075 if (pNameChunk) pNameChunk->GetParent()->DeleteSubChunk(pNameChunk);
5098 if (!pNameChunk && pFile->pVersion && pFile->pVersion->major == 3) {
5101 if (strcmp(static_cast<char*>(ck->LoadChunkData()),
"") == 0) {
5125 for (
Sample* pSample = pFile->GetFirstSample(); pSample; pSample = pFile->GetNextSample()) {
5126 if (pSample->GetGroup() ==
this)
return pSample;
5143 for (
Sample* pSample = pFile->GetNextSample(); pSample; pSample = pFile->GetNextSample()) {
5144 if (pSample->GetGroup() ==
this)
return pSample;
5164 Group* pOtherGroup = NULL;
5165 for (pOtherGroup = pFile->GetFirstGroup(); pOtherGroup; pOtherGroup = pFile->GetNextGroup()) {
5166 if (pOtherGroup !=
this)
break;
5169 "Could not move samples to another group, since there is no " 5170 "other Group. This is a bug, report it!" 5173 for (
Sample* pSample = GetFirstSample(); pSample; pSample = GetNextSample()) {
5185 0, 2, 19980628 & 0xffff, 19980628 >> 16
5190 0, 3, 20030331 & 0xffff, 20030331 >> 16
5218 pScriptGroups = NULL;
5234 pScriptGroups = NULL;
5240 std::list<Group*>::iterator iter = pGroups->begin();
5241 std::list<Group*>::iterator end = pGroups->end();
5242 while (iter != end) {
5248 if (pScriptGroups) {
5249 std::list<ScriptGroup*>::iterator iter = pScriptGroups->begin();
5250 std::list<ScriptGroup*>::iterator end = pScriptGroups->end();
5251 while (iter != end) {
5255 delete pScriptGroups;
5280 DLS::File::SampleList::iterator it =
pSamples->begin();
5281 for (
int i = 0; i < index; ++i) {
5283 if (it ==
pSamples->end())
return NULL;
5285 if (it ==
pSamples->end())
return NULL;
5324 if (iter ==
pSamples->end())
throw gig::Exception(
"Could not delete sample, could not find given sample");
5333 for (
Region* region = instrument->GetFirstRegion() ; region ;
5334 region = instrument->GetNextRegion()) {
5336 if (region->GetSample() == pSample) region->SetSample(NULL);
5338 for (
int i = 0 ; i < region->DimensionRegions ; i++) {
5361 int iSampleIndex = 0;
5370 int nameLen = name.length();
5372 if (nameLen > 4 && name.substr(nameLen - 4) ==
".gig") nameLen -= 4;
5374 for (
int fileNo = 0 ; ; ) {
5377 unsigned long wvplFileOffset = wvpl->
GetFilePos();
5382 const float subprogress = (float) iSampleIndex / (
float) iTotalSamples;
5383 __notify_progress(pProgress, subprogress);
5385 unsigned long waveFileOffset = wave->
GetFilePos();
5386 pSamples->push_back(
new Sample(
this, wave, waveFileOffset - wvplFileOffset, fileNo));
5393 if (fileNo == lastFileNo)
break;
5397 sprintf(suffix,
".gx%02d", fileNo);
5398 name.replace(nameLen, 5, suffix);
5404 __notify_progress(pProgress, 1.0);
5433 __divide_progress(pProgress, &subprogress, 3.0f, 0.0f);
5434 __notify_progress(&subprogress, 0.0f);
5437 __notify_progress(&subprogress, 1.0f);
5440 if (pProgress && pProgress->
callback) {
5444 __notify_progress(&subprogress, 0.0f);
5446 __notify_progress(&subprogress, 1.0f);
5451 if (i == index)
return static_cast<gig::Instrument*
>( *InstrumentsIterator );
5519 static int iCallCount = -1;
5521 std::map<Group*,Group*> mGroups;
5522 std::map<Sample*,Sample*> mSamples;
5525 for (
int i = 0; pFile->
GetGroup(i); ++i) {
5528 "COPY" + ToString(iCallCount) +
"_" + pFile->
GetGroup(i)->
Name;
5533 for (
int i = 0; pFile->
GetSample(i); ++i) {
5565 for (
int i = 0; pFile->
GetSample(i); ++i) {
5593 if (lstInstruments) {
5594 int iInstrumentIndex = 0;
5599 const float localProgress = (float) iInstrumentIndex / (
float)
Instruments;
5600 __notify_progress(pProgress, localProgress);
5604 __divide_progress(pProgress, &subprogress,
Instruments, iInstrumentIndex);
5612 __notify_progress(pProgress, 1.0);
5624 int iWaveIndex = -1;
5625 File::SampleList::iterator iter =
pSamples->begin();
5626 File::SampleList::iterator end =
pSamples->end();
5627 for (
int index = 0; iter != end; ++iter, ++index) {
5628 if (*iter == pSample) {
5633 if (iWaveIndex < 0)
throw gig::Exception(
"Could not update crc, could not find sample");
5636 _3crc->
SetPos(iWaveIndex * 8);
5645 GroupsIterator = pGroups->begin();
5646 return *GroupsIterator;
5650 if (!pGroups)
return NULL;
5652 return (GroupsIterator == pGroups->end()) ? NULL : *GroupsIterator;
5663 GroupsIterator = pGroups->begin();
5664 for (uint i = 0; GroupsIterator != pGroups->end(); i++) {
5665 if (i == index)
return *GroupsIterator;
5683 GroupsIterator = pGroups->begin();
5684 for (uint i = 0; GroupsIterator != pGroups->end(); ++GroupsIterator, ++i)
5685 if ((*GroupsIterator)->Name == name)
return *GroupsIterator;
5694 pGroups->push_back(pGroup);
5709 std::list<Group*>::iterator iter = find(pGroups->begin(), pGroups->end(), pGroup);
5710 if (iter == pGroups->end())
throw gig::Exception(
"Could not delete group, could not find given group");
5711 if (pGroups->size() == 1)
throw gig::Exception(
"Cannot delete group, there must be at least one default group!");
5717 pGroups->erase(iter);
5733 std::list<Group*>::iterator iter = find(pGroups->begin(), pGroups->end(), pGroup);
5734 if (iter == pGroups->end())
throw gig::Exception(
"Could not delete group, could not find given group");
5735 if (pGroups->size() == 1)
throw gig::Exception(
"Cannot delete group, there must be at least one default group!");
5738 pGroups->erase(iter);
5743 if (!pGroups) pGroups =
new std::list<Group*>;
5753 strcmp(static_cast<char*>(ck->
LoadChunkData()),
"") == 0)
break;
5755 pGroups->push_back(
new Group(
this, ck));
5762 if (!pGroups->size()) {
5764 pGroup->
Name =
"Default Group";
5765 pGroups->push_back(pGroup);
5778 std::list<ScriptGroup*>::iterator it = pScriptGroups->begin();
5779 for (uint i = 0; it != pScriptGroups->end(); ++i, ++it)
5780 if (i == index)
return *it;
5794 std::list<ScriptGroup*>::iterator it = pScriptGroups->begin();
5795 for (uint i = 0; it != pScriptGroups->end(); ++i, ++it)
5796 if ((*it)->Name == name)
return *it;
5811 pScriptGroups->push_back(pScriptGroup);
5812 return pScriptGroup;
5829 std::list<ScriptGroup*>::iterator iter =
5830 find(pScriptGroups->begin(), pScriptGroups->end(), pScriptGroup);
5831 if (iter == pScriptGroups->end())
5832 throw gig::Exception(
"Could not delete script group, could not find given script group");
5833 pScriptGroups->erase(iter);
5834 for (
int i = 0; pScriptGroup->
GetScript(i); ++i)
5836 if (pScriptGroup->pList)
5838 delete pScriptGroup;
5842 if (pScriptGroups)
return;
5843 pScriptGroups =
new std::list<ScriptGroup*>;
5850 pScriptGroups->push_back(
new ScriptGroup(
this, lst));
5878 if (pScriptGroups) {
5880 if (pScriptGroups->empty()) {
5887 for (std::list<ScriptGroup*>::iterator it = pScriptGroups->begin();
5888 it != pScriptGroups->end(); ++it)
5890 (*it)->UpdateChunks(pProgress);
5903 if (first != info) {
5924 for (
int i = 0 ; i < 128 ; i++) {
5925 if (i >= pGroups->size()) ::SaveString(
CHUNK_ID_3GNM, _3gnm, _3gnl,
"",
"",
true, 64);
5930 std::list<Group*>::iterator iter = pGroups->begin();
5931 std::list<Group*>::iterator end = pGroups->end();
5932 for (; iter != end; ++iter) {
5933 (*iter)->UpdateChunks(pProgress);
5953 int sublen =
pSamples->size() / 8 + 49;
5958 if (einf->
GetSize() != einfSize) {
5962 }
else if (newFile) {
5968 std::map<gig::Sample*,int> sampleMap;
5971 sampleMap[pSample] = sampleIdx++;
5974 int totnbusedsamples = 0;
5975 int totnbusedchannels = 0;
5976 int totnbregions = 0;
5977 int totnbdimregions = 0;
5979 int instrumentIdx = 0;
5981 memset(&pData[48], 0, sublen - 48);
5985 int nbusedsamples = 0;
5986 int nbusedchannels = 0;
5987 int nbdimregions = 0;
5990 memset(&pData[(instrumentIdx + 1) * sublen + 48], 0, sublen - 48);
5992 for (
Region* region = instrument->GetFirstRegion() ; region ;
5993 region = instrument->GetNextRegion()) {
5994 for (
int i = 0 ; i < region->DimensionRegions ; i++) {
5997 int sampleIdx = sampleMap[d->
pSample];
5998 int byte = 48 + sampleIdx / 8;
5999 int bit = 1 << (sampleIdx & 7);
6000 if ((pData[(instrumentIdx + 1) * sublen + byte] & bit) == 0) {
6001 pData[(instrumentIdx + 1) * sublen + byte] |= bit;
6005 if ((pData[byte] & bit) == 0) {
6014 nbdimregions += region->DimensionRegions;
6018 store32(&pData[(instrumentIdx + 1) * sublen + 4], nbusedchannels);
6019 store32(&pData[(instrumentIdx + 1) * sublen + 8], nbusedsamples);
6020 store32(&pData[(instrumentIdx + 1) * sublen + 12], 1);
6021 store32(&pData[(instrumentIdx + 1) * sublen + 16], instrument->Regions);
6022 store32(&pData[(instrumentIdx + 1) * sublen + 20], nbdimregions);
6023 store32(&pData[(instrumentIdx + 1) * sublen + 24], nbloops);
6025 store32(&pData[(instrumentIdx + 1) * sublen + 36], instrumentIdx);
6026 store32(&pData[(instrumentIdx + 1) * sublen + 40],
pSamples->size());
6029 totnbregions += instrument->Regions;
6030 totnbdimregions += nbdimregions;
6031 totnbloops += nbloops;
6036 store32(&pData[4], totnbusedchannels);
6037 store32(&pData[8], totnbusedsamples);
6039 store32(&pData[16], totnbregions);
6040 store32(&pData[20], totnbdimregions);
6041 store32(&pData[24], totnbloops);
6044 store32(&pData[40],
pSamples->size());
6057 }
else if (newFile) {
6072 instrument->UpdateScriptFileOffsets();
6112 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.
lfo1_ctrl_t
Defines how LFO1 is controlled by.
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.
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.
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.
Sampler(RIFF::List *ParentList)
#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.
bool VCFResonanceDynamic
If true: Increases the resonance Q according to changes of controllers that actually control the VCF ...
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.
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)
lfo3_ctrl_t
Defines how LFO3 is controlled by.
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.
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.
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...
uint16_t high
High value of range.
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.
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...
virtual void UpdateChunks(progress_t *pProgress)
Update chunks with current group settings.
RegionList::iterator RegionsIterator
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, 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 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, 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).
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.
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...
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.
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, release).
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.
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.