/[svn]/libgig/trunk/src/gig.cpp
ViewVC logotype

Diff of /libgig/trunk/src/gig.cpp

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1195 by persson, Thu May 17 17:24:26 2007 UTC revision 1358 by schoenebeck, Sun Sep 30 18:13:33 2007 UTC
# Line 278  namespace { Line 278  namespace {
278    
279    
280    
281    // *************** CRC ***************
282    // *
283    
284        const uint32_t* CRC::table(initTable());
285    
286        uint32_t* CRC::initTable() {
287            uint32_t* res = new uint32_t[256];
288    
289            for (int i = 0 ; i < 256 ; i++) {
290                uint32_t c = i;
291                for (int j = 0 ; j < 8 ; j++) {
292                    c = (c & 1) ? 0xedb88320 ^ (c >> 1) : c >> 1;
293                }
294                res[i] = c;
295            }
296            return res;
297        }
298    
299    
300    
301  // *************** Sample ***************  // *************** Sample ***************
302  // *  // *
303    
# Line 342  namespace { Line 362  namespace {
362              Manufacturer  = 0;              Manufacturer  = 0;
363              Product       = 0;              Product       = 0;
364              SamplePeriod  = uint32_t(1000000000.0 / SamplesPerSecond + 0.5);              SamplePeriod  = uint32_t(1000000000.0 / SamplesPerSecond + 0.5);
365              MIDIUnityNote = 64;              MIDIUnityNote = 60;
366              FineTune      = 0;              FineTune      = 0;
367              SMPTEFormat   = smpte_format_no_offset;              SMPTEFormat   = smpte_format_no_offset;
368              SMPTEOffset   = 0;              SMPTEOffset   = 0;
# Line 1132  namespace { Line 1152  namespace {
1152       *       *
1153       * Note: there is currently no support for writing compressed samples.       * Note: there is currently no support for writing compressed samples.
1154       *       *
1155         * For 16 bit samples, the data in the source buffer should be
1156         * int16_t (using native endianness). For 24 bit, the buffer
1157         * should contain three bytes per sample, little-endian.
1158         *
1159       * @param pBuffer     - source buffer       * @param pBuffer     - source buffer
1160       * @param SampleCount - number of sample points to write       * @param SampleCount - number of sample points to write
1161       * @throws DLS::Exception if current sample size is too small       * @throws DLS::Exception if current sample size is too small
# Line 1140  namespace { Line 1164  namespace {
1164       */       */
1165      unsigned long Sample::Write(void* pBuffer, unsigned long SampleCount) {      unsigned long Sample::Write(void* pBuffer, unsigned long SampleCount) {
1166          if (Compressed) throw gig::Exception("There is no support for writing compressed gig samples (yet)");          if (Compressed) throw gig::Exception("There is no support for writing compressed gig samples (yet)");
1167          return DLS::Sample::Write(pBuffer, SampleCount);  
1168            // if this is the first write in this sample, reset the
1169            // checksum calculator
1170            if (pCkData->GetPos() == 0) {
1171                crc.reset();
1172            }
1173            if (GetSize() < SampleCount) throw Exception("Could not write sample data, current sample size to small");
1174            unsigned long res;
1175            if (BitDepth == 24) {
1176                res = pCkData->Write(pBuffer, SampleCount * FrameSize, 1) / FrameSize;
1177            } else { // 16 bit
1178                res = Channels == 2 ? pCkData->Write(pBuffer, SampleCount << 1, 2) >> 1
1179                                    : pCkData->Write(pBuffer, SampleCount, 2);
1180            }
1181            crc.update((unsigned char *)pBuffer, SampleCount * FrameSize);
1182    
1183            // if this is the last write, update the checksum chunk in the
1184            // file
1185            if (pCkData->GetPos() == pCkData->GetSize()) {
1186                File* pFile = static_cast<File*>(GetParent());
1187                pFile->SetSampleChecksum(this, crc.getValue());
1188            }
1189            return res;
1190      }      }
1191    
1192      /**      /**
# Line 1216  namespace { Line 1262  namespace {
1262      uint                               DimensionRegion::Instances       = 0;      uint                               DimensionRegion::Instances       = 0;
1263      DimensionRegion::VelocityTableMap* DimensionRegion::pVelocityTables = NULL;      DimensionRegion::VelocityTableMap* DimensionRegion::pVelocityTables = NULL;
1264    
1265      DimensionRegion::DimensionRegion(RIFF::List* _3ewl) : DLS::Sampler(_3ewl) {      DimensionRegion::DimensionRegion(Region* pParent, RIFF::List* _3ewl) : DLS::Sampler(_3ewl) {
1266          Instances++;          Instances++;
1267    
1268          pSample = NULL;          pSample = NULL;
1269            pRegion = pParent;
1270    
1271            if (_3ewl->GetSubChunk(CHUNK_ID_WSMP)) memcpy(&Crossfade, &SamplerOptions, 4);
1272            else memset(&Crossfade, 0, 4);
1273    
         memcpy(&Crossfade, &SamplerOptions, 4);  
1274          if (!pVelocityTables) pVelocityTables = new VelocityTableMap;          if (!pVelocityTables) pVelocityTables = new VelocityTableMap;
1275    
1276          RIFF::Chunk* _3ewa = _3ewl->GetSubChunk(CHUNK_ID_3EWA);          RIFF::Chunk* _3ewa = _3ewl->GetSubChunk(CHUNK_ID_3EWA);
# Line 1385  namespace { Line 1434  namespace {
1434              LFO1ControlDepth                = 0;              LFO1ControlDepth                = 0;
1435              LFO3ControlDepth                = 0;              LFO3ControlDepth                = 0;
1436              EG1Attack                       = 0.0;              EG1Attack                       = 0.0;
1437              EG1Decay1                       = 0.0;              EG1Decay1                       = 0.005;
1438              EG1Sustain                      = 0;              EG1Sustain                      = 1000;
1439              EG1Release                      = 0.0;              EG1Release                      = 0.3;
1440              EG1Controller.type              = eg1_ctrl_t::type_none;              EG1Controller.type              = eg1_ctrl_t::type_none;
1441              EG1Controller.controller_number = 0;              EG1Controller.controller_number = 0;
1442              EG1ControllerInvert             = false;              EG1ControllerInvert             = false;
# Line 1402  namespace { Line 1451  namespace {
1451              EG2ControllerReleaseInfluence   = 0;              EG2ControllerReleaseInfluence   = 0;
1452              LFO1Frequency                   = 1.0;              LFO1Frequency                   = 1.0;
1453              EG2Attack                       = 0.0;              EG2Attack                       = 0.0;
1454              EG2Decay1                       = 0.0;              EG2Decay1                       = 0.005;
1455              EG2Sustain                      = 0;              EG2Sustain                      = 1000;
1456              EG2Release                      = 0.0;              EG2Release                      = 0.3;
1457              LFO2ControlDepth                = 0;              LFO2ControlDepth                = 0;
1458              LFO2Frequency                   = 1.0;              LFO2Frequency                   = 1.0;
1459              LFO2InternalDepth               = 0;              LFO2InternalDepth               = 0;
1460              EG1Decay2                       = 0.0;              EG1Decay2                       = 0.0;
1461              EG1InfiniteSustain              = false;              EG1InfiniteSustain              = true;
1462              EG1PreAttack                    = 1000;              EG1PreAttack                    = 0;
1463              EG2Decay2                       = 0.0;              EG2Decay2                       = 0.0;
1464              EG2InfiniteSustain              = false;              EG2InfiniteSustain              = true;
1465              EG2PreAttack                    = 1000;              EG2PreAttack                    = 0;
1466              VelocityResponseCurve           = curve_type_nonlinear;              VelocityResponseCurve           = curve_type_nonlinear;
1467              VelocityResponseDepth           = 3;              VelocityResponseDepth           = 3;
1468              ReleaseVelocityResponseCurve    = curve_type_nonlinear;              ReleaseVelocityResponseCurve    = curve_type_nonlinear;
# Line 1456  namespace { Line 1505  namespace {
1505              VCFVelocityDynamicRange         = 0x04;              VCFVelocityDynamicRange         = 0x04;
1506              VCFVelocityCurve                = curve_type_linear;              VCFVelocityCurve                = curve_type_linear;
1507              VCFType                         = vcf_type_lowpass;              VCFType                         = vcf_type_lowpass;
1508              memset(DimensionUpperLimits, 0, 8);              memset(DimensionUpperLimits, 127, 8);
1509          }          }
1510    
1511          pVelocityAttenuationTable = GetVelocityTable(VelocityResponseCurve,          pVelocityAttenuationTable = GetVelocityTable(VelocityResponseCurve,
1512                                                       VelocityResponseDepth,                                                       VelocityResponseDepth,
1513                                                       VelocityResponseCurveScaling);                                                       VelocityResponseCurveScaling);
1514    
1515          curve_type_t curveType = ReleaseVelocityResponseCurve;          pVelocityReleaseTable = GetReleaseVelocityTable(
1516          uint8_t depth = ReleaseVelocityResponseDepth;                                      ReleaseVelocityResponseCurve,
1517                                        ReleaseVelocityResponseDepth
1518                                    );
1519    
1520            pVelocityCutoffTable = GetCutoffVelocityTable(VCFVelocityCurve,
1521                                                          VCFVelocityDynamicRange,
1522                                                          VCFVelocityScale,
1523                                                          VCFCutoffController);
1524    
1525          // this models a strange behaviour or bug in GSt: two of the          SampleAttenuation = pow(10.0, -Gain / (20.0 * 655360));
1526          // velocity response curves for release time are not used even          VelocityTable = 0;
1527          // if specified, instead another curve is chosen.      }
         if ((curveType == curve_type_nonlinear && depth == 0) ||  
             (curveType == curve_type_special   && depth == 4)) {  
             curveType = curve_type_nonlinear;  
             depth = 3;  
         }  
         pVelocityReleaseTable = GetVelocityTable(curveType, depth, 0);  
1528    
1529          curveType = VCFVelocityCurve;      /*
1530          depth = VCFVelocityDynamicRange;       * Constructs a DimensionRegion by copying all parameters from
1531         * another DimensionRegion
1532         */
1533        DimensionRegion::DimensionRegion(RIFF::List* _3ewl, const DimensionRegion& src) : DLS::Sampler(_3ewl) {
1534            Instances++;
1535            *this = src; // default memberwise shallow copy of all parameters
1536            pParentList = _3ewl; // restore the chunk pointer
1537    
1538          // even stranger GSt: two of the velocity response curves for          // deep copy of owned structures
1539          // filter cutoff are not used, instead another special curve          if (src.VelocityTable) {
1540          // is chosen. This curve is not used anywhere else.              VelocityTable = new uint8_t[128];
1541          if ((curveType == curve_type_nonlinear && depth == 0) ||              for (int k = 0 ; k < 128 ; k++)
1542              (curveType == curve_type_special   && depth == 4)) {                  VelocityTable[k] = src.VelocityTable[k];
             curveType = curve_type_special;  
             depth = 5;  
1543          }          }
1544          pVelocityCutoffTable = GetVelocityTable(curveType, depth,          if (src.pSampleLoops) {
1545                                                  VCFCutoffController <= vcf_cutoff_ctrl_none2 ? VCFVelocityScale : 0);              pSampleLoops = new DLS::sample_loop_t[src.SampleLoops];
1546                for (int k = 0 ; k < src.SampleLoops ; k++)
1547                    pSampleLoops[k] = src.pSampleLoops[k];
1548            }
1549        }
1550    
1551        /**
1552         * Updates the respective member variable and updates @c SampleAttenuation
1553         * which depends on this value.
1554         */
1555        void DimensionRegion::SetGain(int32_t gain) {
1556            DLS::Sampler::SetGain(gain);
1557          SampleAttenuation = pow(10.0, -Gain / (20.0 * 655360));          SampleAttenuation = pow(10.0, -Gain / (20.0 * 655360));
         VelocityTable = 0;  
1558      }      }
1559    
1560      /**      /**
# Line 1505  namespace { Line 1568  namespace {
1568          // first update base class's chunk          // first update base class's chunk
1569          DLS::Sampler::UpdateChunks();          DLS::Sampler::UpdateChunks();
1570    
1571            RIFF::Chunk* wsmp = pParentList->GetSubChunk(CHUNK_ID_WSMP);
1572            uint8_t* pData = (uint8_t*) wsmp->LoadChunkData();
1573            pData[12] = Crossfade.in_start;
1574            pData[13] = Crossfade.in_end;
1575            pData[14] = Crossfade.out_start;
1576            pData[15] = Crossfade.out_end;
1577    
1578          // make sure '3ewa' chunk exists          // make sure '3ewa' chunk exists
1579          RIFF::Chunk* _3ewa = pParentList->GetSubChunk(CHUNK_ID_3EWA);          RIFF::Chunk* _3ewa = pParentList->GetSubChunk(CHUNK_ID_3EWA);
1580          if (!_3ewa)  _3ewa = pParentList->AddSubChunk(CHUNK_ID_3EWA, 140);          if (!_3ewa) {
1581          uint8_t* pData = (uint8_t*) _3ewa->LoadChunkData();              File* pFile = (File*) GetParent()->GetParent()->GetParent();
1582                bool version3 = pFile->pVersion && pFile->pVersion->major == 3;
1583                _3ewa = pParentList->AddSubChunk(CHUNK_ID_3EWA, version3 ? 148 : 140);
1584            }
1585            pData = (uint8_t*) _3ewa->LoadChunkData();
1586    
1587          // update '3ewa' chunk with DimensionRegion's current settings          // update '3ewa' chunk with DimensionRegion's current settings
1588    
# Line 1554  namespace { Line 1628  namespace {
1628          pData[44] = eg1ctl;          pData[44] = eg1ctl;
1629    
1630          const uint8_t eg1ctrloptions =          const uint8_t eg1ctrloptions =
1631              (EG1ControllerInvert) ? 0x01 : 0x00 |              (EG1ControllerInvert ? 0x01 : 0x00) |
1632              GIG_EG_CTR_ATTACK_INFLUENCE_ENCODE(EG1ControllerAttackInfluence) |              GIG_EG_CTR_ATTACK_INFLUENCE_ENCODE(EG1ControllerAttackInfluence) |
1633              GIG_EG_CTR_DECAY_INFLUENCE_ENCODE(EG1ControllerDecayInfluence) |              GIG_EG_CTR_DECAY_INFLUENCE_ENCODE(EG1ControllerDecayInfluence) |
1634              GIG_EG_CTR_RELEASE_INFLUENCE_ENCODE(EG1ControllerReleaseInfluence);              GIG_EG_CTR_RELEASE_INFLUENCE_ENCODE(EG1ControllerReleaseInfluence);
# Line 1564  namespace { Line 1638  namespace {
1638          pData[46] = eg2ctl;          pData[46] = eg2ctl;
1639    
1640          const uint8_t eg2ctrloptions =          const uint8_t eg2ctrloptions =
1641              (EG2ControllerInvert) ? 0x01 : 0x00 |              (EG2ControllerInvert ? 0x01 : 0x00) |
1642              GIG_EG_CTR_ATTACK_INFLUENCE_ENCODE(EG2ControllerAttackInfluence) |              GIG_EG_CTR_ATTACK_INFLUENCE_ENCODE(EG2ControllerAttackInfluence) |
1643              GIG_EG_CTR_DECAY_INFLUENCE_ENCODE(EG2ControllerDecayInfluence) |              GIG_EG_CTR_DECAY_INFLUENCE_ENCODE(EG2ControllerDecayInfluence) |
1644              GIG_EG_CTR_RELEASE_INFLUENCE_ENCODE(EG2ControllerReleaseInfluence);              GIG_EG_CTR_RELEASE_INFLUENCE_ENCODE(EG2ControllerReleaseInfluence);
# Line 1742  namespace { Line 1816  namespace {
1816          const uint8_t eg1hold = (EG1Hold) ? 0x80 : 0x00; // bit 7          const uint8_t eg1hold = (EG1Hold) ? 0x80 : 0x00; // bit 7
1817          pData[131] = eg1hold;          pData[131] = eg1hold;
1818    
1819          const uint8_t vcfcutoff = (VCFEnabled) ? 0x80 : 0x00 |  /* bit 7 */          const uint8_t vcfcutoff = (VCFEnabled ? 0x80 : 0x00) |  /* bit 7 */
1820                                    (VCFCutoff & 0x7f);   /* lower 7 bits */                                    (VCFCutoff & 0x7f);   /* lower 7 bits */
1821          pData[132] = vcfcutoff;          pData[132] = vcfcutoff;
1822    
1823          pData[133] = VCFCutoffController;          pData[133] = VCFCutoffController;
1824    
1825          const uint8_t vcfvelscale = (VCFCutoffControllerInvert) ? 0x80 : 0x00 | /* bit 7 */          const uint8_t vcfvelscale = (VCFCutoffControllerInvert ? 0x80 : 0x00) | /* bit 7 */
1826                                      (VCFVelocityScale & 0x7f); /* lower 7 bits */                                      (VCFVelocityScale & 0x7f); /* lower 7 bits */
1827          pData[134] = vcfvelscale;          pData[134] = vcfvelscale;
1828    
1829          // next byte unknown          // next byte unknown
1830    
1831          const uint8_t vcfresonance = (VCFResonanceDynamic) ? 0x00 : 0x80 | /* bit 7 */          const uint8_t vcfresonance = (VCFResonanceDynamic ? 0x00 : 0x80) | /* bit 7 */
1832                                       (VCFResonance & 0x7f); /* lower 7 bits */                                       (VCFResonance & 0x7f); /* lower 7 bits */
1833          pData[136] = vcfresonance;          pData[136] = vcfresonance;
1834    
1835          const uint8_t vcfbreakpoint = (VCFKeyboardTracking) ? 0x80 : 0x00 | /* bit 7 */          const uint8_t vcfbreakpoint = (VCFKeyboardTracking ? 0x80 : 0x00) | /* bit 7 */
1836                                        (VCFKeyboardTrackingBreakpoint & 0x7f); /* lower 7 bits */                                        (VCFKeyboardTrackingBreakpoint & 0x7f); /* lower 7 bits */
1837          pData[137] = vcfbreakpoint;          pData[137] = vcfbreakpoint;
1838    
# Line 1774  namespace { Line 1848  namespace {
1848          }          }
1849      }      }
1850    
1851        double* DimensionRegion::GetReleaseVelocityTable(curve_type_t releaseVelocityResponseCurve, uint8_t releaseVelocityResponseDepth) {
1852            curve_type_t curveType = releaseVelocityResponseCurve;
1853            uint8_t depth = releaseVelocityResponseDepth;
1854            // this models a strange behaviour or bug in GSt: two of the
1855            // velocity response curves for release time are not used even
1856            // if specified, instead another curve is chosen.
1857            if ((curveType == curve_type_nonlinear && depth == 0) ||
1858                (curveType == curve_type_special   && depth == 4)) {
1859                curveType = curve_type_nonlinear;
1860                depth = 3;
1861            }
1862            return GetVelocityTable(curveType, depth, 0);
1863        }
1864    
1865        double* DimensionRegion::GetCutoffVelocityTable(curve_type_t vcfVelocityCurve,
1866                                                        uint8_t vcfVelocityDynamicRange,
1867                                                        uint8_t vcfVelocityScale,
1868                                                        vcf_cutoff_ctrl_t vcfCutoffController)
1869        {
1870            curve_type_t curveType = vcfVelocityCurve;
1871            uint8_t depth = vcfVelocityDynamicRange;
1872            // even stranger GSt: two of the velocity response curves for
1873            // filter cutoff are not used, instead another special curve
1874            // is chosen. This curve is not used anywhere else.
1875            if ((curveType == curve_type_nonlinear && depth == 0) ||
1876                (curveType == curve_type_special   && depth == 4)) {
1877                curveType = curve_type_special;
1878                depth = 5;
1879            }
1880            return GetVelocityTable(curveType, depth,
1881                                    (vcfCutoffController <= vcf_cutoff_ctrl_none2)
1882                                        ? vcfVelocityScale : 0);
1883        }
1884    
1885      // get the corresponding velocity table from the table map or create & calculate that table if it doesn't exist yet      // get the corresponding velocity table from the table map or create & calculate that table if it doesn't exist yet
1886      double* DimensionRegion::GetVelocityTable(curve_type_t curveType, uint8_t depth, uint8_t scaling)      double* DimensionRegion::GetVelocityTable(curve_type_t curveType, uint8_t depth, uint8_t scaling)
1887      {      {
# Line 1789  namespace { Line 1897  namespace {
1897          return table;          return table;
1898      }      }
1899    
1900        Region* DimensionRegion::GetParent() const {
1901            return pRegion;
1902        }
1903    
1904      leverage_ctrl_t DimensionRegion::DecodeLeverageController(_lev_ctrl_t EncodedController) {      leverage_ctrl_t DimensionRegion::DecodeLeverageController(_lev_ctrl_t EncodedController) {
1905          leverage_ctrl_t decodedcontroller;          leverage_ctrl_t decodedcontroller;
1906          switch (EncodedController) {          switch (EncodedController) {
# Line 2042  namespace { Line 2154  namespace {
2154          return pVelocityCutoffTable[MIDIKeyVelocity];          return pVelocityCutoffTable[MIDIKeyVelocity];
2155      }      }
2156    
2157        /**
2158         * Updates the respective member variable and the lookup table / cache
2159         * that depends on this value.
2160         */
2161        void DimensionRegion::SetVelocityResponseCurve(curve_type_t curve) {
2162            pVelocityAttenuationTable =
2163                GetVelocityTable(
2164                    curve, VelocityResponseDepth, VelocityResponseCurveScaling
2165                );
2166            VelocityResponseCurve = curve;
2167        }
2168    
2169        /**
2170         * Updates the respective member variable and the lookup table / cache
2171         * that depends on this value.
2172         */
2173        void DimensionRegion::SetVelocityResponseDepth(uint8_t depth) {
2174            pVelocityAttenuationTable =
2175                GetVelocityTable(
2176                    VelocityResponseCurve, depth, VelocityResponseCurveScaling
2177                );
2178            VelocityResponseDepth = depth;
2179        }
2180    
2181        /**
2182         * Updates the respective member variable and the lookup table / cache
2183         * that depends on this value.
2184         */
2185        void DimensionRegion::SetVelocityResponseCurveScaling(uint8_t scaling) {
2186            pVelocityAttenuationTable =
2187                GetVelocityTable(
2188                    VelocityResponseCurve, VelocityResponseDepth, scaling
2189                );
2190            VelocityResponseCurveScaling = scaling;
2191        }
2192    
2193        /**
2194         * Updates the respective member variable and the lookup table / cache
2195         * that depends on this value.
2196         */
2197        void DimensionRegion::SetReleaseVelocityResponseCurve(curve_type_t curve) {
2198            pVelocityReleaseTable = GetReleaseVelocityTable(curve, ReleaseVelocityResponseDepth);
2199            ReleaseVelocityResponseCurve = curve;
2200        }
2201    
2202        /**
2203         * Updates the respective member variable and the lookup table / cache
2204         * that depends on this value.
2205         */
2206        void DimensionRegion::SetReleaseVelocityResponseDepth(uint8_t depth) {
2207            pVelocityReleaseTable = GetReleaseVelocityTable(ReleaseVelocityResponseCurve, depth);
2208            ReleaseVelocityResponseDepth = depth;
2209        }
2210    
2211        /**
2212         * Updates the respective member variable and the lookup table / cache
2213         * that depends on this value.
2214         */
2215        void DimensionRegion::SetVCFCutoffController(vcf_cutoff_ctrl_t controller) {
2216            pVelocityCutoffTable = GetCutoffVelocityTable(VCFVelocityCurve, VCFVelocityDynamicRange, VCFVelocityScale, controller);
2217            VCFCutoffController = controller;
2218        }
2219    
2220        /**
2221         * Updates the respective member variable and the lookup table / cache
2222         * that depends on this value.
2223         */
2224        void DimensionRegion::SetVCFVelocityCurve(curve_type_t curve) {
2225            pVelocityCutoffTable = GetCutoffVelocityTable(curve, VCFVelocityDynamicRange, VCFVelocityScale, VCFCutoffController);
2226            VCFVelocityCurve = curve;
2227        }
2228    
2229        /**
2230         * Updates the respective member variable and the lookup table / cache
2231         * that depends on this value.
2232         */
2233        void DimensionRegion::SetVCFVelocityDynamicRange(uint8_t range) {
2234            pVelocityCutoffTable = GetCutoffVelocityTable(VCFVelocityCurve, range, VCFVelocityScale, VCFCutoffController);
2235            VCFVelocityDynamicRange = range;
2236        }
2237    
2238        /**
2239         * Updates the respective member variable and the lookup table / cache
2240         * that depends on this value.
2241         */
2242        void DimensionRegion::SetVCFVelocityScale(uint8_t scaling) {
2243            pVelocityCutoffTable = GetCutoffVelocityTable(VCFVelocityCurve, VCFVelocityDynamicRange, scaling, VCFCutoffController);
2244            VCFVelocityScale = scaling;
2245        }
2246    
2247      double* DimensionRegion::CreateVelocityTable(curve_type_t curveType, uint8_t depth, uint8_t scaling) {      double* DimensionRegion::CreateVelocityTable(curve_type_t curveType, uint8_t depth, uint8_t scaling) {
2248    
2249          // line-segment approximations of the 15 velocity curves          // line-segment approximations of the 15 velocity curves
# Line 2133  namespace { Line 2335  namespace {
2335              for (int i = 0; i < dimensionBits; i++) {              for (int i = 0; i < dimensionBits; i++) {
2336                  dimension_t dimension = static_cast<dimension_t>(_3lnk->ReadUint8());                  dimension_t dimension = static_cast<dimension_t>(_3lnk->ReadUint8());
2337                  uint8_t     bits      = _3lnk->ReadUint8();                  uint8_t     bits      = _3lnk->ReadUint8();
2338                  _3lnk->ReadUint8(); // probably the position of the dimension                  _3lnk->ReadUint8(); // bit position of the dimension (bits[0] + bits[1] + ... + bits[i-1])
2339                  _3lnk->ReadUint8(); // unknown                  _3lnk->ReadUint8(); // (1 << bit position of next dimension) - (1 << bit position of this dimension)
2340                  uint8_t     zones     = _3lnk->ReadUint8(); // new for v3: number of zones doesn't have to be == pow(2,bits)                  uint8_t     zones     = _3lnk->ReadUint8(); // new for v3: number of zones doesn't have to be == pow(2,bits)
2341                  if (dimension == dimension_none) { // inactive dimension                  if (dimension == dimension_none) { // inactive dimension
2342                      pDimensionDefinitions[i].dimension  = dimension_none;                      pDimensionDefinitions[i].dimension  = dimension_none;
# Line 2188  namespace { Line 2390  namespace {
2390              RIFF::List* _3prg = rgnList->GetSubList(LIST_TYPE_3PRG);              RIFF::List* _3prg = rgnList->GetSubList(LIST_TYPE_3PRG);
2391              if (!_3prg) _3prg = rgnList->AddSubList(LIST_TYPE_3PRG);              if (!_3prg) _3prg = rgnList->AddSubList(LIST_TYPE_3PRG);
2392              RIFF::List* _3ewl = _3prg->AddSubList(LIST_TYPE_3EWL);              RIFF::List* _3ewl = _3prg->AddSubList(LIST_TYPE_3EWL);
2393              pDimensionRegions[0] = new DimensionRegion(_3ewl);              pDimensionRegions[0] = new DimensionRegion(this, _3ewl);
2394              DimensionRegions = 1;              DimensionRegions = 1;
2395          }          }
2396      }      }
# Line 2218  namespace { Line 2420  namespace {
2420          }          }
2421    
2422          File* pFile = (File*) GetParent()->GetParent();          File* pFile = (File*) GetParent()->GetParent();
2423          const int iMaxDimensions = (pFile->pVersion && pFile->pVersion->major == 3) ? 8 : 5;          bool version3 = pFile->pVersion && pFile->pVersion->major == 3;
2424          const int iMaxDimensionRegions = (pFile->pVersion && pFile->pVersion->major == 3) ? 256 : 32;          const int iMaxDimensions =  version3 ? 8 : 5;
2425            const int iMaxDimensionRegions = version3 ? 256 : 32;
2426    
2427          // make sure '3lnk' chunk exists          // make sure '3lnk' chunk exists
2428          RIFF::Chunk* _3lnk = pCkRegion->GetSubChunk(CHUNK_ID_3LNK);          RIFF::Chunk* _3lnk = pCkRegion->GetSubChunk(CHUNK_ID_3LNK);
2429          if (!_3lnk) {          if (!_3lnk) {
2430              const int _3lnkChunkSize = (pFile->pVersion && pFile->pVersion->major == 3) ? 1092 : 172;              const int _3lnkChunkSize = version3 ? 1092 : 172;
2431              _3lnk = pCkRegion->AddSubChunk(CHUNK_ID_3LNK, _3lnkChunkSize);              _3lnk = pCkRegion->AddSubChunk(CHUNK_ID_3LNK, _3lnkChunkSize);
2432              memset(_3lnk->LoadChunkData(), 0, _3lnkChunkSize);              memset(_3lnk->LoadChunkData(), 0, _3lnkChunkSize);
2433    
# Line 2235  namespace { Line 2438  namespace {
2438          // update dimension definitions in '3lnk' chunk          // update dimension definitions in '3lnk' chunk
2439          uint8_t* pData = (uint8_t*) _3lnk->LoadChunkData();          uint8_t* pData = (uint8_t*) _3lnk->LoadChunkData();
2440          store32(&pData[0], DimensionRegions);          store32(&pData[0], DimensionRegions);
2441            int shift = 0;
2442          for (int i = 0; i < iMaxDimensions; i++) {          for (int i = 0; i < iMaxDimensions; i++) {
2443              pData[4 + i * 8] = (uint8_t) pDimensionDefinitions[i].dimension;              pData[4 + i * 8] = (uint8_t) pDimensionDefinitions[i].dimension;
2444              pData[5 + i * 8] = pDimensionDefinitions[i].bits;              pData[5 + i * 8] = pDimensionDefinitions[i].bits;
2445              // next 2 bytes unknown              pData[6 + i * 8] = pDimensionDefinitions[i].dimension == dimension_none ? 0 : shift;
2446                pData[7 + i * 8] = (1 << (shift + pDimensionDefinitions[i].bits)) - (1 << shift);
2447              pData[8 + i * 8] = pDimensionDefinitions[i].zones;              pData[8 + i * 8] = pDimensionDefinitions[i].zones;
2448              // next 3 bytes unknown              // next 3 bytes unknown, always zero?
2449    
2450                shift += pDimensionDefinitions[i].bits;
2451          }          }
2452    
2453          // update wave pool table in '3lnk' chunk          // update wave pool table in '3lnk' chunk
2454          const int iWavePoolOffset = (pFile->pVersion && pFile->pVersion->major == 3) ? 68 : 44;          const int iWavePoolOffset = version3 ? 68 : 44;
2455          for (uint i = 0; i < iMaxDimensionRegions; i++) {          for (uint i = 0; i < iMaxDimensionRegions; i++) {
2456              int iWaveIndex = -1;              int iWaveIndex = -1;
2457              if (i < DimensionRegions) {              if (i < DimensionRegions) {
# Line 2257  namespace { Line 2464  namespace {
2464                          break;                          break;
2465                      }                      }
2466                  }                  }
                 if (iWaveIndex < 0) throw gig::Exception("Could not update gig::Region, could not find DimensionRegion's sample");  
2467              }              }
2468              store32(&pData[iWavePoolOffset + i * 4], iWaveIndex);              store32(&pData[iWavePoolOffset + i * 4], iWaveIndex);
2469          }          }
# Line 2270  namespace { Line 2476  namespace {
2476              RIFF::List* _3ewl = _3prg->GetFirstSubList();              RIFF::List* _3ewl = _3prg->GetFirstSubList();
2477              while (_3ewl) {              while (_3ewl) {
2478                  if (_3ewl->GetListType() == LIST_TYPE_3EWL) {                  if (_3ewl->GetListType() == LIST_TYPE_3EWL) {
2479                      pDimensionRegions[dimensionRegionNr] = new DimensionRegion(_3ewl);                      pDimensionRegions[dimensionRegionNr] = new DimensionRegion(this, _3ewl);
2480                      dimensionRegionNr++;                      dimensionRegionNr++;
2481                  }                  }
2482                  _3ewl = _3prg->GetNextSubList();                  _3ewl = _3prg->GetNextSubList();
# Line 2279  namespace { Line 2485  namespace {
2485          }          }
2486      }      }
2487    
2488        void Region::SetKeyRange(uint16_t Low, uint16_t High) {
2489            // update KeyRange struct and make sure regions are in correct order
2490            DLS::Region::SetKeyRange(Low, High);
2491            // update Region key table for fast lookup
2492            ((gig::Instrument*)GetParent())->UpdateRegionKeyTable();
2493        }
2494    
2495      void Region::UpdateVelocityTable() {      void Region::UpdateVelocityTable() {
2496          // get velocity dimension's index          // get velocity dimension's index
2497          int veldim = -1;          int veldim = -1;
# Line 2384  namespace { Line 2597  namespace {
2597              if (pDimensionDefinitions[i].dimension == pDimDef->dimension)              if (pDimensionDefinitions[i].dimension == pDimDef->dimension)
2598                  throw gig::Exception("Could not add new dimension, there is already a dimension of the same type");                  throw gig::Exception("Could not add new dimension, there is already a dimension of the same type");
2599    
2600            // pos is where the new dimension should be placed, normally
2601            // last in list, except for the samplechannel dimension which
2602            // has to be first in list
2603            int pos = pDimDef->dimension == dimension_samplechannel ? 0 : Dimensions;
2604            int bitpos = 0;
2605            for (int i = 0 ; i < pos ; i++)
2606                bitpos += pDimensionDefinitions[i].bits;
2607    
2608            // make room for the new dimension
2609            for (int i = Dimensions ; i > pos ; i--) pDimensionDefinitions[i] = pDimensionDefinitions[i - 1];
2610            for (int i = 0 ; i < (1 << iCurrentBits) ; i++) {
2611                for (int j = Dimensions ; j > pos ; j--) {
2612                    pDimensionRegions[i]->DimensionUpperLimits[j] =
2613                        pDimensionRegions[i]->DimensionUpperLimits[j - 1];
2614                }
2615            }
2616    
2617          // assign definition of new dimension          // assign definition of new dimension
2618          pDimensionDefinitions[Dimensions] = *pDimDef;          pDimensionDefinitions[pos] = *pDimDef;
2619    
2620          // auto correct certain dimension definition fields (where possible)          // auto correct certain dimension definition fields (where possible)
2621          pDimensionDefinitions[Dimensions].split_type  =          pDimensionDefinitions[pos].split_type  =
2622              __resolveSplitType(pDimensionDefinitions[Dimensions].dimension);              __resolveSplitType(pDimensionDefinitions[pos].dimension);
2623          pDimensionDefinitions[Dimensions].zone_size =          pDimensionDefinitions[pos].zone_size =
2624              __resolveZoneSize(pDimensionDefinitions[Dimensions]);              __resolveZoneSize(pDimensionDefinitions[pos]);
2625    
2626          // create new dimension region(s) for this new dimension          // create new dimension region(s) for this new dimension, and make
2627          for (int i = 1 << iCurrentBits; i < 1 << iNewBits; i++) {          // sure that the dimension regions are placed correctly in both the
2628              //TODO: maybe we should copy existing dimension regions if possible instead of simply creating new ones with default values          // RIFF list and the pDimensionRegions array
2629              RIFF::List* _3prg = pCkRegion->GetSubList(LIST_TYPE_3PRG);          RIFF::Chunk* moveTo = NULL;
2630              RIFF::List* pNewDimRgnListChunk = _3prg->AddSubList(LIST_TYPE_3EWL);          RIFF::List* _3prg = pCkRegion->GetSubList(LIST_TYPE_3PRG);
2631              pDimensionRegions[i] = new DimensionRegion(pNewDimRgnListChunk);          for (int i = (1 << iCurrentBits) - (1 << bitpos) ; i >= 0 ; i -= (1 << bitpos)) {
2632              DimensionRegions++;              for (int k = 0 ; k < (1 << bitpos) ; k++) {
2633                    pDimensionRegions[(i << pDimDef->bits) + k] = pDimensionRegions[i + k];
2634                }
2635                for (int j = 1 ; j < (1 << pDimDef->bits) ; j++) {
2636                    for (int k = 0 ; k < (1 << bitpos) ; k++) {
2637                        RIFF::List* pNewDimRgnListChunk = _3prg->AddSubList(LIST_TYPE_3EWL);
2638                        if (moveTo) _3prg->MoveSubChunk(pNewDimRgnListChunk, moveTo);
2639                        // create a new dimension region and copy all parameter values from
2640                        // an existing dimension region
2641                        pDimensionRegions[(i << pDimDef->bits) + (j << bitpos) + k] =
2642                            new DimensionRegion(pNewDimRgnListChunk, *pDimensionRegions[i + k]);
2643    
2644                        DimensionRegions++;
2645                    }
2646                }
2647                moveTo = pDimensionRegions[i]->pParentList;
2648            }
2649    
2650            // initialize the upper limits for this dimension
2651            int mask = (1 << bitpos) - 1;
2652            for (int z = 0 ; z < pDimDef->zones ; z++) {
2653                uint8_t upperLimit = uint8_t((z + 1) * 128.0 / pDimDef->zones - 1);
2654                for (int i = 0 ; i < 1 << iCurrentBits ; i++) {
2655                    pDimensionRegions[((i & ~mask) << pDimDef->bits) |
2656                                      (z << bitpos) |
2657                                      (i & mask)]->DimensionUpperLimits[pos] = upperLimit;
2658                }
2659          }          }
2660    
2661          Dimensions++;          Dimensions++;
# Line 2442  namespace { Line 2698  namespace {
2698          for (int i = iDimensionNr + 1; i < Dimensions; i++)          for (int i = iDimensionNr + 1; i < Dimensions; i++)
2699              iUpperBits += pDimensionDefinitions[i].bits;              iUpperBits += pDimensionDefinitions[i].bits;
2700    
2701            RIFF::List* _3prg = pCkRegion->GetSubList(LIST_TYPE_3PRG);
2702    
2703          // delete dimension regions which belong to the given dimension          // delete dimension regions which belong to the given dimension
2704          // (that is where the dimension's bit > 0)          // (that is where the dimension's bit > 0)
2705          for (int iUpperBit = 0; iUpperBit < 1 << iUpperBits; iUpperBit++) {          for (int iUpperBit = 0; iUpperBit < 1 << iUpperBits; iUpperBit++) {
# Line 2450  namespace { Line 2708  namespace {
2708                      int iToDelete = iUpperBit    << (pDimensionDefinitions[iDimensionNr].bits + iLowerBits) |                      int iToDelete = iUpperBit    << (pDimensionDefinitions[iDimensionNr].bits + iLowerBits) |
2709                                      iObsoleteBit << iLowerBits |                                      iObsoleteBit << iLowerBits |
2710                                      iLowerBit;                                      iLowerBit;
2711    
2712                        _3prg->DeleteSubChunk(pDimensionRegions[iToDelete]->pParentList);
2713                      delete pDimensionRegions[iToDelete];                      delete pDimensionRegions[iToDelete];
2714                      pDimensionRegions[iToDelete] = NULL;                      pDimensionRegions[iToDelete] = NULL;
2715                      DimensionRegions--;                      DimensionRegions--;
# Line 2470  namespace { Line 2730  namespace {
2730              }              }
2731          }          }
2732    
2733            // remove the this dimension from the upper limits arrays
2734            for (int j = 0 ; j < 256 && pDimensionRegions[j] ; j++) {
2735                DimensionRegion* d = pDimensionRegions[j];
2736                for (int i = iDimensionNr + 1; i < Dimensions; i++) {
2737                    d->DimensionUpperLimits[i - 1] = d->DimensionUpperLimits[i];
2738                }
2739                d->DimensionUpperLimits[Dimensions - 1] = 127;
2740            }
2741    
2742          // 'remove' dimension definition          // 'remove' dimension definition
2743          for (int i = iDimensionNr + 1; i < Dimensions; i++) {          for (int i = iDimensionNr + 1; i < Dimensions; i++) {
2744              pDimensionDefinitions[i - 1] = pDimensionDefinitions[i];              pDimensionDefinitions[i - 1] = pDimensionDefinitions[i];
# Line 2662  namespace { Line 2931  namespace {
2931      }      }
2932    
2933      void Instrument::UpdateRegionKeyTable() {      void Instrument::UpdateRegionKeyTable() {
2934            for (int i = 0; i < 128; i++) RegionKeyTable[i] = NULL;
2935          RegionList::iterator iter = pRegions->begin();          RegionList::iterator iter = pRegions->begin();
2936          RegionList::iterator end  = pRegions->end();          RegionList::iterator end  = pRegions->end();
2937          for (; iter != end; ++iter) {          for (; iter != end; ++iter) {
# Line 2701  namespace { Line 2971  namespace {
2971          if (!lart)  lart = pCkInstrument->AddSubList(LIST_TYPE_LART);          if (!lart)  lart = pCkInstrument->AddSubList(LIST_TYPE_LART);
2972          // make sure '3ewg' RIFF chunk exists          // make sure '3ewg' RIFF chunk exists
2973          RIFF::Chunk* _3ewg = lart->GetSubChunk(CHUNK_ID_3EWG);          RIFF::Chunk* _3ewg = lart->GetSubChunk(CHUNK_ID_3EWG);
2974          if (!_3ewg)  _3ewg = lart->AddSubChunk(CHUNK_ID_3EWG, 12);          if (!_3ewg)  {
2975                File* pFile = (File*) GetParent();
2976    
2977                // 3ewg is bigger in gig3, as it includes the iMIDI rules
2978                int size = (pFile->pVersion && pFile->pVersion->major == 3) ? 16416 : 12;
2979                _3ewg = lart->AddSubChunk(CHUNK_ID_3EWG, size);
2980                memset(_3ewg->LoadChunkData(), 0, size);
2981            }
2982          // update '3ewg' RIFF chunk          // update '3ewg' RIFF chunk
2983          uint8_t* pData = (uint8_t*) _3ewg->LoadChunkData();          uint8_t* pData = (uint8_t*) _3ewg->LoadChunkData();
2984          store16(&pData[0], EffectSend);          store16(&pData[0], EffectSend);
2985          store32(&pData[2], Attenuation);          store32(&pData[2], Attenuation);
2986          store16(&pData[6], FineTune);          store16(&pData[6], FineTune);
2987          store16(&pData[8], PitchbendRange);          store16(&pData[8], PitchbendRange);
2988          const uint8_t dimkeystart = (PianoReleaseMode) ? 0x01 : 0x00 |          const uint8_t dimkeystart = (PianoReleaseMode ? 0x01 : 0x00) |
2989                                      DimensionKeyRange.low << 1;                                      DimensionKeyRange.low << 1;
2990          pData[10] = dimkeystart;          pData[10] = dimkeystart;
2991          pData[11] = DimensionKeyRange.high;          pData[11] = DimensionKeyRange.high;
# Line 2722  namespace { Line 2999  namespace {
2999       *             there is no Region defined for the given \a Key       *             there is no Region defined for the given \a Key
3000       */       */
3001      Region* Instrument::GetRegion(unsigned int Key) {      Region* Instrument::GetRegion(unsigned int Key) {
3002          if (!pRegions || !pRegions->size() || Key > 127) return NULL;          if (!pRegions || pRegions->empty() || Key > 127) return NULL;
3003          return RegionKeyTable[Key];          return RegionKeyTable[Key];
3004    
3005          /*for (int i = 0; i < Regions; i++) {          /*for (int i = 0; i < Regions; i++) {
# Line 2819  namespace { Line 3096  namespace {
3096          }          }
3097          RIFF::List* _3gnl = _3gri->GetSubList(LIST_TYPE_3GNL);          RIFF::List* _3gnl = _3gri->GetSubList(LIST_TYPE_3GNL);
3098          if (!_3gnl) _3gnl = _3gri->AddSubList(LIST_TYPE_3GNL);          if (!_3gnl) _3gnl = _3gri->AddSubList(LIST_TYPE_3GNL);
3099    
3100            if (!pNameChunk && pFile->pVersion && pFile->pVersion->major == 3) {
3101                // v3 has a fixed list of 128 strings, find a free one
3102                for (RIFF::Chunk* ck = _3gnl->GetFirstSubChunk() ; ck ; ck = _3gnl->GetNextSubChunk()) {
3103                    if (strcmp(static_cast<char*>(ck->LoadChunkData()), "") == 0) {
3104                        pNameChunk = ck;
3105                        break;
3106                    }
3107                }
3108            }
3109    
3110          // now store the name of this group as <3gnm> chunk as subchunk of the <3gnl> list chunk          // now store the name of this group as <3gnm> chunk as subchunk of the <3gnl> list chunk
3111          ::SaveString(CHUNK_ID_3GNM, pNameChunk, _3gnl, Name, String("Unnamed Group"), true, 64);          ::SaveString(CHUNK_ID_3GNM, pNameChunk, _3gnl, Name, String("Unnamed Group"), true, 64);
3112      }      }
# Line 2894  namespace { Line 3182  namespace {
3182  // *************** File ***************  // *************** File ***************
3183  // *  // *
3184    
3185        // File version 2.0, 1998-06-28
3186        const DLS::version_t File::VERSION_2 = {
3187            0, 2, 19980628 & 0xffff, 19980628 >> 16
3188        };
3189    
3190        // File version 3.0, 2003-03-31
3191        const DLS::version_t File::VERSION_3 = {
3192            0, 3, 20030331 & 0xffff, 20030331 >> 16
3193        };
3194    
3195      const DLS::Info::FixedStringLength File::FixedStringLengths[] = {      const DLS::Info::FixedStringLength File::FixedStringLengths[] = {
3196          { CHUNK_ID_IARL, 256 },          { CHUNK_ID_IARL, 256 },
3197          { CHUNK_ID_IART, 128 },          { CHUNK_ID_IART, 128 },
# Line 2916  namespace { Line 3214  namespace {
3214      };      };
3215    
3216      File::File() : DLS::File() {      File::File() : DLS::File() {
3217            *pVersion = VERSION_3;
3218          pGroups = NULL;          pGroups = NULL;
3219          pInfo->FixedStringLengths = FixedStringLengths;          pInfo->FixedStringLengths = FixedStringLengths;
3220          pInfo->ArchivalLocation = String(256, ' ');          pInfo->ArchivalLocation = String(256, ' ');
# Line 2924  namespace { Line 3223  namespace {
3223          // order (INFO chunk will be moved to first position later)          // order (INFO chunk will be moved to first position later)
3224          pRIFF->AddSubChunk(CHUNK_ID_VERS, 8);          pRIFF->AddSubChunk(CHUNK_ID_VERS, 8);
3225          pRIFF->AddSubChunk(CHUNK_ID_COLH, 4);          pRIFF->AddSubChunk(CHUNK_ID_COLH, 4);
3226            pRIFF->AddSubChunk(CHUNK_ID_DLID, 16);
3227    
3228            GenerateDLSID();
3229      }      }
3230    
3231      File::File(RIFF::File* pRIFF) : DLS::File(pRIFF) {      File::File(RIFF::File* pRIFF) : DLS::File(pRIFF) {
# Line 2981  namespace { Line 3283  namespace {
3283    
3284      /** @brief Delete a sample.      /** @brief Delete a sample.
3285       *       *
3286       * This will delete the given Sample object from the gig file. You have       * This will delete the given Sample object from the gig file. Any
3287       * to call Save() to make this persistent to the file.       * references to this sample from Regions and DimensionRegions will be
3288         * removed. You have to call Save() to make this persistent to the file.
3289       *       *
3290       * @param pSample - sample to delete       * @param pSample - sample to delete
3291       * @throws gig::Exception if given sample could not be found       * @throws gig::Exception if given sample could not be found
# Line 2994  namespace { Line 3297  namespace {
3297          if (SamplesIterator != pSamples->end() && *SamplesIterator == pSample) ++SamplesIterator; // avoid iterator invalidation          if (SamplesIterator != pSamples->end() && *SamplesIterator == pSample) ++SamplesIterator; // avoid iterator invalidation
3298          pSamples->erase(iter);          pSamples->erase(iter);
3299          delete pSample;          delete pSample;
3300    
3301            // remove all references to the sample
3302            for (Instrument* instrument = GetFirstInstrument() ; instrument ;
3303                 instrument = GetNextInstrument()) {
3304                for (Region* region = instrument->GetFirstRegion() ; region ;
3305                     region = instrument->GetNextRegion()) {
3306    
3307                    if (region->GetSample() == pSample) region->SetSample(NULL);
3308    
3309                    for (int i = 0 ; i < region->DimensionRegions ; i++) {
3310                        gig::DimensionRegion *d = region->pDimensionRegions[i];
3311                        if (d->pSample == pSample) d->pSample = NULL;
3312                    }
3313                }
3314            }
3315      }      }
3316    
3317      void File::LoadSamples() {      void File::LoadSamples() {
# Line 3120  namespace { Line 3438  namespace {
3438    
3439         // add mandatory chunks to get the chunks in right order         // add mandatory chunks to get the chunks in right order
3440         lstInstr->AddSubList(LIST_TYPE_INFO);         lstInstr->AddSubList(LIST_TYPE_INFO);
3441           lstInstr->AddSubChunk(CHUNK_ID_DLID, 16);
3442    
3443         Instrument* pInstrument = new Instrument(this, lstInstr);         Instrument* pInstrument = new Instrument(this, lstInstr);
3444           pInstrument->GenerateDLSID();
3445    
3446         lstInstr->AddSubChunk(CHUNK_ID_INSH, 12);         lstInstr->AddSubChunk(CHUNK_ID_INSH, 12);
3447    
# Line 3178  namespace { Line 3498  namespace {
3498          }          }
3499      }      }
3500    
3501        /// Updates the 3crc chunk with the checksum of a sample. The
3502        /// update is done directly to disk, as this method is called
3503        /// after File::Save()
3504        void File::SetSampleChecksum(Sample* pSample, uint32_t crc) {
3505            RIFF::Chunk* _3crc = pRIFF->GetSubChunk(CHUNK_ID_3CRC);
3506            if (!_3crc) return;
3507    
3508            // get the index of the sample
3509            int iWaveIndex = -1;
3510            File::SampleList::iterator iter = pSamples->begin();
3511            File::SampleList::iterator end  = pSamples->end();
3512            for (int index = 0; iter != end; ++iter, ++index) {
3513                if (*iter == pSample) {
3514                    iWaveIndex = index;
3515                    break;
3516                }
3517            }
3518            if (iWaveIndex < 0) throw gig::Exception("Could not update crc, could not find sample");
3519    
3520            // write the CRC-32 checksum to disk
3521            _3crc->SetPos(iWaveIndex * 8);
3522            uint32_t tmp = 1;
3523            _3crc->WriteUint32(&tmp); // unknown, always 1?
3524            _3crc->WriteUint32(&crc);
3525        }
3526    
3527      Group* File::GetFirstGroup() {      Group* File::GetFirstGroup() {
3528          if (!pGroups) LoadGroups();          if (!pGroups) LoadGroups();
3529          // there must always be at least one group          // there must always be at least one group
# Line 3270  namespace { Line 3616  namespace {
3616                  RIFF::Chunk* ck = lst3gnl->GetFirstSubChunk();                  RIFF::Chunk* ck = lst3gnl->GetFirstSubChunk();
3617                  while (ck) {                  while (ck) {
3618                      if (ck->GetChunkID() == CHUNK_ID_3GNM) {                      if (ck->GetChunkID() == CHUNK_ID_3GNM) {
3619                            if (pVersion && pVersion->major == 3 &&
3620                                strcmp(static_cast<char*>(ck->LoadChunkData()), "") == 0) break;
3621    
3622                          pGroups->push_back(new Group(this, ck));                          pGroups->push_back(new Group(this, ck));
3623                      }                      }
3624                      ck = lst3gnl->GetNextSubChunk();                      ck = lst3gnl->GetNextSubChunk();
# Line 3295  namespace { Line 3644  namespace {
3644       * @throws Exception - on errors       * @throws Exception - on errors
3645       */       */
3646      void File::UpdateChunks() {      void File::UpdateChunks() {
3647          RIFF::Chunk* info = pRIFF->GetSubList(LIST_TYPE_INFO);          bool newFile = pRIFF->GetSubList(LIST_TYPE_INFO) == NULL;
3648    
3649            b64BitWavePoolOffsets = pVersion && pVersion->major == 3;
3650    
3651          // first update base class's chunks          // first update base class's chunks
3652          DLS::File::UpdateChunks();          DLS::File::UpdateChunks();
3653    
3654          if (!info) {          if (newFile) {
3655              // INFO was added by Resource::UpdateChunks - make sure it              // INFO was added by Resource::UpdateChunks - make sure it
3656              // is placed first in file              // is placed first in file
3657              info = pRIFF->GetSubList(LIST_TYPE_INFO);              RIFF::Chunk* info = pRIFF->GetSubList(LIST_TYPE_INFO);
3658              RIFF::Chunk* first = pRIFF->GetFirstSubChunk();              RIFF::Chunk* first = pRIFF->GetFirstSubChunk();
3659              if (first != info) {              if (first != info) {
3660                  pRIFF->MoveSubChunk(info, first);                  pRIFF->MoveSubChunk(info, first);
# Line 3317  namespace { Line 3668  namespace {
3668              for (; iter != end; ++iter) {              for (; iter != end; ++iter) {
3669                  (*iter)->UpdateChunks();                  (*iter)->UpdateChunks();
3670              }              }
3671    
3672                // v3: make sure the file has 128 3gnm chunks
3673                if (pVersion && pVersion->major == 3) {
3674                    RIFF::List* _3gnl = pRIFF->GetSubList(LIST_TYPE_3GRI)->GetSubList(LIST_TYPE_3GNL);
3675                    RIFF::Chunk* _3gnm = _3gnl->GetFirstSubChunk();
3676                    for (int i = 0 ; i < 128 ; i++) {
3677                        if (i >= pGroups->size()) ::SaveString(CHUNK_ID_3GNM, _3gnm, _3gnl, "", "", true, 64);
3678                        if (_3gnm) _3gnm = _3gnl->GetNextSubChunk();
3679                    }
3680                }
3681            }
3682    
3683            // update einf chunk
3684    
3685            // The einf chunk contains statistics about the gig file, such
3686            // as the number of regions and samples used by each
3687            // instrument. It is divided in equally sized parts, where the
3688            // first part contains information about the whole gig file,
3689            // and the rest of the parts map to each instrument in the
3690            // file.
3691            //
3692            // At the end of each part there is a bit map of each sample
3693            // in the file, where a set bit means that the sample is used
3694            // by the file/instrument.
3695            //
3696            // Note that there are several fields with unknown use. These
3697            // are set to zero.
3698    
3699            int sublen = pSamples->size() / 8 + 49;
3700            int einfSize = (Instruments + 1) * sublen;
3701    
3702            RIFF::Chunk* einf = pRIFF->GetSubChunk(CHUNK_ID_EINF);
3703            if (einf) {
3704                if (einf->GetSize() != einfSize) {
3705                    einf->Resize(einfSize);
3706                    memset(einf->LoadChunkData(), 0, einfSize);
3707                }
3708            } else if (newFile) {
3709                einf = pRIFF->AddSubChunk(CHUNK_ID_EINF, einfSize);
3710            }
3711            if (einf) {
3712                uint8_t* pData = (uint8_t*) einf->LoadChunkData();
3713    
3714                std::map<gig::Sample*,int> sampleMap;
3715                int sampleIdx = 0;
3716                for (Sample* pSample = GetFirstSample(); pSample; pSample = GetNextSample()) {
3717                    sampleMap[pSample] = sampleIdx++;
3718                }
3719    
3720                int totnbusedsamples = 0;
3721                int totnbusedchannels = 0;
3722                int totnbregions = 0;
3723                int totnbdimregions = 0;
3724                int totnbloops = 0;
3725                int instrumentIdx = 0;
3726    
3727                memset(&pData[48], 0, sublen - 48);
3728    
3729                for (Instrument* instrument = GetFirstInstrument() ; instrument ;
3730                     instrument = GetNextInstrument()) {
3731                    int nbusedsamples = 0;
3732                    int nbusedchannels = 0;
3733                    int nbdimregions = 0;
3734                    int nbloops = 0;
3735    
3736                    memset(&pData[(instrumentIdx + 1) * sublen + 48], 0, sublen - 48);
3737    
3738                    for (Region* region = instrument->GetFirstRegion() ; region ;
3739                         region = instrument->GetNextRegion()) {
3740                        for (int i = 0 ; i < region->DimensionRegions ; i++) {
3741                            gig::DimensionRegion *d = region->pDimensionRegions[i];
3742                            if (d->pSample) {
3743                                int sampleIdx = sampleMap[d->pSample];
3744                                int byte = 48 + sampleIdx / 8;
3745                                int bit = 1 << (sampleIdx & 7);
3746                                if ((pData[(instrumentIdx + 1) * sublen + byte] & bit) == 0) {
3747                                    pData[(instrumentIdx + 1) * sublen + byte] |= bit;
3748                                    nbusedsamples++;
3749                                    nbusedchannels += d->pSample->Channels;
3750    
3751                                    if ((pData[byte] & bit) == 0) {
3752                                        pData[byte] |= bit;
3753                                        totnbusedsamples++;
3754                                        totnbusedchannels += d->pSample->Channels;
3755                                    }
3756                                }
3757                            }
3758                            if (d->SampleLoops) nbloops++;
3759                        }
3760                        nbdimregions += region->DimensionRegions;
3761                    }
3762                    // first 4 bytes unknown - sometimes 0, sometimes length of einf part
3763                    // store32(&pData[(instrumentIdx + 1) * sublen], sublen);
3764                    store32(&pData[(instrumentIdx + 1) * sublen + 4], nbusedchannels);
3765                    store32(&pData[(instrumentIdx + 1) * sublen + 8], nbusedsamples);
3766                    store32(&pData[(instrumentIdx + 1) * sublen + 12], 1);
3767                    store32(&pData[(instrumentIdx + 1) * sublen + 16], instrument->Regions);
3768                    store32(&pData[(instrumentIdx + 1) * sublen + 20], nbdimregions);
3769                    store32(&pData[(instrumentIdx + 1) * sublen + 24], nbloops);
3770                    // next 8 bytes unknown
3771                    store32(&pData[(instrumentIdx + 1) * sublen + 36], instrumentIdx);
3772                    store32(&pData[(instrumentIdx + 1) * sublen + 40], pSamples->size());
3773                    // next 4 bytes unknown
3774    
3775                    totnbregions += instrument->Regions;
3776                    totnbdimregions += nbdimregions;
3777                    totnbloops += nbloops;
3778                    instrumentIdx++;
3779                }
3780                // first 4 bytes unknown - sometimes 0, sometimes length of einf part
3781                // store32(&pData[0], sublen);
3782                store32(&pData[4], totnbusedchannels);
3783                store32(&pData[8], totnbusedsamples);
3784                store32(&pData[12], Instruments);
3785                store32(&pData[16], totnbregions);
3786                store32(&pData[20], totnbdimregions);
3787                store32(&pData[24], totnbloops);
3788                // next 8 bytes unknown
3789                // next 4 bytes unknown, not always 0
3790                store32(&pData[40], pSamples->size());
3791                // next 4 bytes unknown
3792            }
3793    
3794            // update 3crc chunk
3795    
3796            // The 3crc chunk contains CRC-32 checksums for the
3797            // samples. The actual checksum values will be filled in
3798            // later, by Sample::Write.
3799    
3800            RIFF::Chunk* _3crc = pRIFF->GetSubChunk(CHUNK_ID_3CRC);
3801            if (_3crc) {
3802                _3crc->Resize(pSamples->size() * 8);
3803            } else if (newFile) {
3804                _3crc = pRIFF->AddSubChunk(CHUNK_ID_3CRC, pSamples->size() * 8);
3805                _3crc->LoadChunkData();
3806    
3807                // the order of einf and 3crc is not the same in v2 and v3
3808                if (einf && pVersion && pVersion->major == 3) pRIFF->MoveSubChunk(_3crc, einf);
3809          }          }
3810      }      }
3811    
Legend:
Removed from v.1195  
changed lines
  Added in v.1358
  ViewVC Help
Powered by ViewVC