/[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 1335 by schoenebeck, Sun Sep 9 21:22:58 2007 UTC revision 1713 by persson, Thu Mar 6 20:42:22 2008 UTC
# Line 25  Line 25 
25    
26  #include "helper.h"  #include "helper.h"
27    
28    #include <algorithm>
29  #include <math.h>  #include <math.h>
30  #include <iostream>  #include <iostream>
31    
# Line 255  namespace { Line 256  namespace {
256    
257    
258    
259    // *************** Internal CRC-32 (Cyclic Redundancy Check) functions  ***************
260    // *
261    
262        static uint32_t* __initCRCTable() {
263            static uint32_t res[256];
264    
265            for (int i = 0 ; i < 256 ; i++) {
266                uint32_t c = i;
267                for (int j = 0 ; j < 8 ; j++) {
268                    c = (c & 1) ? 0xedb88320 ^ (c >> 1) : c >> 1;
269                }
270                res[i] = c;
271            }
272            return res;
273        }
274    
275        static const uint32_t* __CRCTable = __initCRCTable();
276    
277        /**
278         * Initialize a CRC variable.
279         *
280         * @param crc - variable to be initialized
281         */
282        inline static void __resetCRC(uint32_t& crc) {
283            crc = 0xffffffff;
284        }
285    
286        /**
287         * Used to calculate checksums of the sample data in a gig file. The
288         * checksums are stored in the 3crc chunk of the gig file and
289         * automatically updated when a sample is written with Sample::Write().
290         *
291         * One should call __resetCRC() to initialize the CRC variable to be
292         * used before calling this function the first time.
293         *
294         * After initializing the CRC variable one can call this function
295         * arbitrary times, i.e. to split the overall CRC calculation into
296         * steps.
297         *
298         * Once the whole data was processed by __calculateCRC(), one should
299         * call __encodeCRC() to get the final CRC result.
300         *
301         * @param buf     - pointer to data the CRC shall be calculated of
302         * @param bufSize - size of the data to be processed
303         * @param crc     - variable the CRC sum shall be stored to
304         */
305        static void __calculateCRC(unsigned char* buf, int bufSize, uint32_t& crc) {
306            for (int i = 0 ; i < bufSize ; i++) {
307                crc = __CRCTable[(crc ^ buf[i]) & 0xff] ^ (crc >> 8);
308            }
309        }
310    
311        /**
312         * Returns the final CRC result.
313         *
314         * @param crc - variable previously passed to __calculateCRC()
315         */
316        inline static uint32_t __encodeCRC(const uint32_t& crc) {
317            return crc ^ 0xffffffff;
318        }
319    
320    
321    
322  // *************** Other Internal functions  ***************  // *************** Other Internal functions  ***************
323  // *  // *
324    
# Line 278  namespace { Line 342  namespace {
342    
343    
344    
 // *************** CRC ***************  
 // *  
   
     const uint32_t* CRC::table(initTable());  
   
     uint32_t* CRC::initTable() {  
         uint32_t* res = new uint32_t[256];  
   
         for (int i = 0 ; i < 256 ; i++) {  
             uint32_t c = i;  
             for (int j = 0 ; j < 8 ; j++) {  
                 c = (c & 1) ? 0xedb88320 ^ (c >> 1) : c >> 1;  
             }  
             res[i] = c;  
         }  
         return res;  
     }  
   
   
   
345  // *************** Sample ***************  // *************** Sample ***************
346  // *  // *
347    
# Line 323  namespace { Line 367  namespace {
367       *                         is located, 0 otherwise       *                         is located, 0 otherwise
368       */       */
369      Sample::Sample(File* pFile, RIFF::List* waveList, unsigned long WavePoolOffset, unsigned long fileNo) : DLS::Sample((DLS::File*) pFile, waveList, WavePoolOffset) {      Sample::Sample(File* pFile, RIFF::List* waveList, unsigned long WavePoolOffset, unsigned long fileNo) : DLS::Sample((DLS::File*) pFile, waveList, WavePoolOffset) {
370          static const DLS::Info::FixedStringLength fixedStringLengths[] = {          static const DLS::Info::string_length_t fixedStringLengths[] = {
371              { CHUNK_ID_INAM, 64 },              { CHUNK_ID_INAM, 64 },
372              { 0, 0 }              { 0, 0 }
373          };          };
374          pInfo->FixedStringLengths = fixedStringLengths;          pInfo->SetFixedStringLengths(fixedStringLengths);
375          Instances++;          Instances++;
376          FileNo = fileNo;          FileNo = fileNo;
377    
378            __resetCRC(crc);
379    
380          pCk3gix = waveList->GetSubChunk(CHUNK_ID_3GIX);          pCk3gix = waveList->GetSubChunk(CHUNK_ID_3GIX);
381          if (pCk3gix) {          if (pCk3gix) {
382              uint16_t iSampleGroup = pCk3gix->ReadInt16();              uint16_t iSampleGroup = pCk3gix->ReadInt16();
# Line 1168  namespace { Line 1214  namespace {
1214          // if this is the first write in this sample, reset the          // if this is the first write in this sample, reset the
1215          // checksum calculator          // checksum calculator
1216          if (pCkData->GetPos() == 0) {          if (pCkData->GetPos() == 0) {
1217              crc.reset();              __resetCRC(crc);
1218          }          }
1219          if (GetSize() < SampleCount) throw Exception("Could not write sample data, current sample size to small");          if (GetSize() < SampleCount) throw Exception("Could not write sample data, current sample size to small");
1220          unsigned long res;          unsigned long res;
# Line 1178  namespace { Line 1224  namespace {
1224              res = Channels == 2 ? pCkData->Write(pBuffer, SampleCount << 1, 2) >> 1              res = Channels == 2 ? pCkData->Write(pBuffer, SampleCount << 1, 2) >> 1
1225                                  : pCkData->Write(pBuffer, SampleCount, 2);                                  : pCkData->Write(pBuffer, SampleCount, 2);
1226          }          }
1227          crc.update((unsigned char *)pBuffer, SampleCount * FrameSize);          __calculateCRC((unsigned char *)pBuffer, SampleCount * FrameSize, crc);
1228    
1229          // if this is the last write, update the checksum chunk in the          // if this is the last write, update the checksum chunk in the
1230          // file          // file
1231          if (pCkData->GetPos() == pCkData->GetSize()) {          if (pCkData->GetPos() == pCkData->GetSize()) {
1232              File* pFile = static_cast<File*>(GetParent());              File* pFile = static_cast<File*>(GetParent());
1233              pFile->SetSampleChecksum(this, crc.getValue());              pFile->SetSampleChecksum(this, __encodeCRC(crc));
1234          }          }
1235          return res;          return res;
1236      }      }
# Line 1512  namespace { Line 1558  namespace {
1558                                                       VelocityResponseDepth,                                                       VelocityResponseDepth,
1559                                                       VelocityResponseCurveScaling);                                                       VelocityResponseCurveScaling);
1560    
1561          curve_type_t curveType = ReleaseVelocityResponseCurve;          pVelocityReleaseTable = GetReleaseVelocityTable(
1562          uint8_t depth = ReleaseVelocityResponseDepth;                                      ReleaseVelocityResponseCurve,
1563                                        ReleaseVelocityResponseDepth
1564          // this models a strange behaviour or bug in GSt: two of the                                  );
1565          // velocity response curves for release time are not used even  
1566          // if specified, instead another curve is chosen.          pVelocityCutoffTable = GetCutoffVelocityTable(VCFVelocityCurve,
1567          if ((curveType == curve_type_nonlinear && depth == 0) ||                                                        VCFVelocityDynamicRange,
1568              (curveType == curve_type_special   && depth == 4)) {                                                        VCFVelocityScale,
1569              curveType = curve_type_nonlinear;                                                        VCFCutoffController);
             depth = 3;  
         }  
         pVelocityReleaseTable = GetVelocityTable(curveType, depth, 0);  
   
         curveType = VCFVelocityCurve;  
         depth = VCFVelocityDynamicRange;  
   
         // even stranger GSt: two of the velocity response curves for  
         // filter cutoff are not used, instead another special curve  
         // is chosen. This curve is not used anywhere else.  
         if ((curveType == curve_type_nonlinear && depth == 0) ||  
             (curveType == curve_type_special   && depth == 4)) {  
             curveType = curve_type_special;  
             depth = 5;  
         }  
         pVelocityCutoffTable = GetVelocityTable(curveType, depth,  
                                                 VCFCutoffController <= vcf_cutoff_ctrl_none2 ? VCFVelocityScale : 0);  
1570    
1571          SampleAttenuation = pow(10.0, -Gain / (20.0 * 655360));          SampleAttenuation = pow(10.0, -Gain / (20.0 * 655360));
1572          VelocityTable = 0;          VelocityTable = 0;
# Line 1566  namespace { Line 1595  namespace {
1595      }      }
1596    
1597      /**      /**
1598         * Updates the respective member variable and updates @c SampleAttenuation
1599         * which depends on this value.
1600         */
1601        void DimensionRegion::SetGain(int32_t gain) {
1602            DLS::Sampler::SetGain(gain);
1603            SampleAttenuation = pow(10.0, -Gain / (20.0 * 655360));
1604        }
1605    
1606        /**
1607       * Apply dimension region settings to the respective RIFF chunks. You       * Apply dimension region settings to the respective RIFF chunks. You
1608       * have to call File::Save() to make changes persistent.       * have to call File::Save() to make changes persistent.
1609       *       *
# Line 1856  namespace { Line 1894  namespace {
1894          }          }
1895      }      }
1896    
1897        double* DimensionRegion::GetReleaseVelocityTable(curve_type_t releaseVelocityResponseCurve, uint8_t releaseVelocityResponseDepth) {
1898            curve_type_t curveType = releaseVelocityResponseCurve;
1899            uint8_t depth = releaseVelocityResponseDepth;
1900            // this models a strange behaviour or bug in GSt: two of the
1901            // velocity response curves for release time are not used even
1902            // if specified, instead another curve is chosen.
1903            if ((curveType == curve_type_nonlinear && depth == 0) ||
1904                (curveType == curve_type_special   && depth == 4)) {
1905                curveType = curve_type_nonlinear;
1906                depth = 3;
1907            }
1908            return GetVelocityTable(curveType, depth, 0);
1909        }
1910    
1911        double* DimensionRegion::GetCutoffVelocityTable(curve_type_t vcfVelocityCurve,
1912                                                        uint8_t vcfVelocityDynamicRange,
1913                                                        uint8_t vcfVelocityScale,
1914                                                        vcf_cutoff_ctrl_t vcfCutoffController)
1915        {
1916            curve_type_t curveType = vcfVelocityCurve;
1917            uint8_t depth = vcfVelocityDynamicRange;
1918            // even stranger GSt: two of the velocity response curves for
1919            // filter cutoff are not used, instead another special curve
1920            // is chosen. This curve is not used anywhere else.
1921            if ((curveType == curve_type_nonlinear && depth == 0) ||
1922                (curveType == curve_type_special   && depth == 4)) {
1923                curveType = curve_type_special;
1924                depth = 5;
1925            }
1926            return GetVelocityTable(curveType, depth,
1927                                    (vcfCutoffController <= vcf_cutoff_ctrl_none2)
1928                                        ? vcfVelocityScale : 0);
1929        }
1930    
1931      // 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
1932      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)
1933      {      {
# Line 2128  namespace { Line 2200  namespace {
2200          return pVelocityCutoffTable[MIDIKeyVelocity];          return pVelocityCutoffTable[MIDIKeyVelocity];
2201      }      }
2202    
2203        /**
2204         * Updates the respective member variable and the lookup table / cache
2205         * that depends on this value.
2206         */
2207        void DimensionRegion::SetVelocityResponseCurve(curve_type_t curve) {
2208            pVelocityAttenuationTable =
2209                GetVelocityTable(
2210                    curve, VelocityResponseDepth, VelocityResponseCurveScaling
2211                );
2212            VelocityResponseCurve = curve;
2213        }
2214    
2215        /**
2216         * Updates the respective member variable and the lookup table / cache
2217         * that depends on this value.
2218         */
2219        void DimensionRegion::SetVelocityResponseDepth(uint8_t depth) {
2220            pVelocityAttenuationTable =
2221                GetVelocityTable(
2222                    VelocityResponseCurve, depth, VelocityResponseCurveScaling
2223                );
2224            VelocityResponseDepth = depth;
2225        }
2226    
2227        /**
2228         * Updates the respective member variable and the lookup table / cache
2229         * that depends on this value.
2230         */
2231        void DimensionRegion::SetVelocityResponseCurveScaling(uint8_t scaling) {
2232            pVelocityAttenuationTable =
2233                GetVelocityTable(
2234                    VelocityResponseCurve, VelocityResponseDepth, scaling
2235                );
2236            VelocityResponseCurveScaling = scaling;
2237        }
2238    
2239        /**
2240         * Updates the respective member variable and the lookup table / cache
2241         * that depends on this value.
2242         */
2243        void DimensionRegion::SetReleaseVelocityResponseCurve(curve_type_t curve) {
2244            pVelocityReleaseTable = GetReleaseVelocityTable(curve, ReleaseVelocityResponseDepth);
2245            ReleaseVelocityResponseCurve = curve;
2246        }
2247    
2248        /**
2249         * Updates the respective member variable and the lookup table / cache
2250         * that depends on this value.
2251         */
2252        void DimensionRegion::SetReleaseVelocityResponseDepth(uint8_t depth) {
2253            pVelocityReleaseTable = GetReleaseVelocityTable(ReleaseVelocityResponseCurve, depth);
2254            ReleaseVelocityResponseDepth = depth;
2255        }
2256    
2257        /**
2258         * Updates the respective member variable and the lookup table / cache
2259         * that depends on this value.
2260         */
2261        void DimensionRegion::SetVCFCutoffController(vcf_cutoff_ctrl_t controller) {
2262            pVelocityCutoffTable = GetCutoffVelocityTable(VCFVelocityCurve, VCFVelocityDynamicRange, VCFVelocityScale, controller);
2263            VCFCutoffController = controller;
2264        }
2265    
2266        /**
2267         * Updates the respective member variable and the lookup table / cache
2268         * that depends on this value.
2269         */
2270        void DimensionRegion::SetVCFVelocityCurve(curve_type_t curve) {
2271            pVelocityCutoffTable = GetCutoffVelocityTable(curve, VCFVelocityDynamicRange, VCFVelocityScale, VCFCutoffController);
2272            VCFVelocityCurve = curve;
2273        }
2274    
2275        /**
2276         * Updates the respective member variable and the lookup table / cache
2277         * that depends on this value.
2278         */
2279        void DimensionRegion::SetVCFVelocityDynamicRange(uint8_t range) {
2280            pVelocityCutoffTable = GetCutoffVelocityTable(VCFVelocityCurve, range, VCFVelocityScale, VCFCutoffController);
2281            VCFVelocityDynamicRange = range;
2282        }
2283    
2284        /**
2285         * Updates the respective member variable and the lookup table / cache
2286         * that depends on this value.
2287         */
2288        void DimensionRegion::SetVCFVelocityScale(uint8_t scaling) {
2289            pVelocityCutoffTable = GetCutoffVelocityTable(VCFVelocityCurve, VCFVelocityDynamicRange, scaling, VCFCutoffController);
2290            VCFVelocityScale = scaling;
2291        }
2292    
2293      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) {
2294    
2295          // line-segment approximations of the 15 velocity curves          // line-segment approximations of the 15 velocity curves
# Line 2211  namespace { Line 2373  namespace {
2373    
2374          // Actual Loading          // Actual Loading
2375    
2376            if (!file->GetAutoLoad()) return;
2377    
2378          LoadDimensionRegions(rgnList);          LoadDimensionRegions(rgnList);
2379    
2380          RIFF::Chunk* _3lnk = rgnList->GetSubChunk(CHUNK_ID_3LNK);          RIFF::Chunk* _3lnk = rgnList->GetSubChunk(CHUNK_ID_3LNK);
# Line 2254  namespace { Line 2418  namespace {
2418              else              else
2419                  _3lnk->SetPos(44);                  _3lnk->SetPos(44);
2420    
2421              // load sample references              // load sample references (if auto loading is enabled)
2422              for (uint i = 0; i < DimensionRegions; i++) {              if (file->GetAutoLoad()) {
2423                  uint32_t wavepoolindex = _3lnk->ReadUint32();                  for (uint i = 0; i < DimensionRegions; i++) {
2424                  if (file->pWavePoolTable) pDimensionRegions[i]->pSample = GetSampleFromWavePool(wavepoolindex);                      uint32_t wavepoolindex = _3lnk->ReadUint32();
2425                        if (file->pWavePoolTable) pDimensionRegions[i]->pSample = GetSampleFromWavePool(wavepoolindex);
2426                    }
2427                    GetSample(); // load global region sample reference
2428              }              }
             GetSample(); // load global region sample reference  
2429          } else {          } else {
2430              DimensionRegions = 0;              DimensionRegions = 0;
2431              for (int i = 0 ; i < 8 ; i++) {              for (int i = 0 ; i < 8 ; i++) {
# Line 2758  namespace { Line 2924  namespace {
2924      }      }
2925    
2926    
2927    // *************** MidiRule ***************
2928    // *
2929    
2930    MidiRuleCtrlTrigger::MidiRuleCtrlTrigger(RIFF::Chunk* _3ewg) {
2931        _3ewg->SetPos(36);
2932        Triggers = _3ewg->ReadUint8();
2933        _3ewg->SetPos(40);
2934        ControllerNumber = _3ewg->ReadUint8();
2935        _3ewg->SetPos(46);
2936        for (int i = 0 ; i < Triggers ; i++) {
2937            pTriggers[i].TriggerPoint = _3ewg->ReadUint8();
2938            pTriggers[i].Descending = _3ewg->ReadUint8();
2939            pTriggers[i].VelSensitivity = _3ewg->ReadUint8();
2940            pTriggers[i].Key = _3ewg->ReadUint8();
2941            pTriggers[i].NoteOff = _3ewg->ReadUint8();
2942            pTriggers[i].Velocity = _3ewg->ReadUint8();
2943            pTriggers[i].OverridePedal = _3ewg->ReadUint8();
2944            _3ewg->ReadUint8();
2945        }
2946    }
2947    
2948    
2949  // *************** Instrument ***************  // *************** Instrument ***************
2950  // *  // *
2951    
2952      Instrument::Instrument(File* pFile, RIFF::List* insList, progress_t* pProgress) : DLS::Instrument((DLS::File*)pFile, insList) {      Instrument::Instrument(File* pFile, RIFF::List* insList, progress_t* pProgress) : DLS::Instrument((DLS::File*)pFile, insList) {
2953          static const DLS::Info::FixedStringLength fixedStringLengths[] = {          static const DLS::Info::string_length_t fixedStringLengths[] = {
2954              { CHUNK_ID_INAM, 64 },              { CHUNK_ID_INAM, 64 },
2955              { CHUNK_ID_ISFT, 12 },              { CHUNK_ID_ISFT, 12 },
2956              { 0, 0 }              { 0, 0 }
2957          };          };
2958          pInfo->FixedStringLengths = fixedStringLengths;          pInfo->SetFixedStringLengths(fixedStringLengths);
2959    
2960          // Initialization          // Initialization
2961          for (int i = 0; i < 128; i++) RegionKeyTable[i] = NULL;          for (int i = 0; i < 128; i++) RegionKeyTable[i] = NULL;
# Line 2779  namespace { Line 2966  namespace {
2966          PianoReleaseMode = false;          PianoReleaseMode = false;
2967          DimensionKeyRange.low = 0;          DimensionKeyRange.low = 0;
2968          DimensionKeyRange.high = 0;          DimensionKeyRange.high = 0;
2969            pMidiRules = new MidiRule*[3];
2970            pMidiRules[0] = NULL;
2971    
2972          // Loading          // Loading
2973          RIFF::List* lart = insList->GetSubList(LIST_TYPE_LART);          RIFF::List* lart = insList->GetSubList(LIST_TYPE_LART);
# Line 2793  namespace { Line 2982  namespace {
2982                  PianoReleaseMode       = dimkeystart & 0x01;                  PianoReleaseMode       = dimkeystart & 0x01;
2983                  DimensionKeyRange.low  = dimkeystart >> 1;                  DimensionKeyRange.low  = dimkeystart >> 1;
2984                  DimensionKeyRange.high = _3ewg->ReadUint8();                  DimensionKeyRange.high = _3ewg->ReadUint8();
2985    
2986                    if (_3ewg->GetSize() > 32) {
2987                        // read MIDI rules
2988                        int i = 0;
2989                        _3ewg->SetPos(32);
2990                        uint8_t id1 = _3ewg->ReadUint8();
2991                        uint8_t id2 = _3ewg->ReadUint8();
2992    
2993                        if (id1 == 4 && id2 == 16) {
2994                            pMidiRules[i++] = new MidiRuleCtrlTrigger(_3ewg);
2995                        }
2996                        //TODO: all the other types of rules
2997    
2998                        pMidiRules[i] = NULL;
2999                    }
3000              }              }
3001          }          }
3002    
3003          if (!pRegions) pRegions = new RegionList;          if (pFile->GetAutoLoad()) {
3004          RIFF::List* lrgn = insList->GetSubList(LIST_TYPE_LRGN);              if (!pRegions) pRegions = new RegionList;
3005          if (lrgn) {              RIFF::List* lrgn = insList->GetSubList(LIST_TYPE_LRGN);
3006              RIFF::List* rgn = lrgn->GetFirstSubList();              if (lrgn) {
3007              while (rgn) {                  RIFF::List* rgn = lrgn->GetFirstSubList();
3008                  if (rgn->GetListType() == LIST_TYPE_RGN) {                  while (rgn) {
3009                      __notify_progress(pProgress, (float) pRegions->size() / (float) Regions);                      if (rgn->GetListType() == LIST_TYPE_RGN) {
3010                      pRegions->push_back(new Region(this, rgn));                          __notify_progress(pProgress, (float) pRegions->size() / (float) Regions);
3011                            pRegions->push_back(new Region(this, rgn));
3012                        }
3013                        rgn = lrgn->GetNextSubList();
3014                  }                  }
3015                  rgn = lrgn->GetNextSubList();                  // Creating Region Key Table for fast lookup
3016                    UpdateRegionKeyTable();
3017              }              }
             // Creating Region Key Table for fast lookup  
             UpdateRegionKeyTable();  
3018          }          }
3019    
3020          __notify_progress(pProgress, 1.0f); // notify done          __notify_progress(pProgress, 1.0f); // notify done
# Line 2827  namespace { Line 3033  namespace {
3033      }      }
3034    
3035      Instrument::~Instrument() {      Instrument::~Instrument() {
3036            delete[] pMidiRules;
3037      }      }
3038    
3039      /**      /**
# Line 2941  namespace { Line 3148  namespace {
3148          UpdateRegionKeyTable();          UpdateRegionKeyTable();
3149      }      }
3150    
3151        /**
3152         * Returns a MIDI rule of the instrument.
3153         *
3154         * The list of MIDI rules, at least in gig v3, always contains at
3155         * most two rules. The second rule can only be the DEF filter
3156         * (which currently isn't supported by libgig).
3157         *
3158         * @param i - MIDI rule number
3159         * @returns   pointer address to MIDI rule number i or NULL if there is none
3160         */
3161        MidiRule* Instrument::GetMidiRule(int i) {
3162            return pMidiRules[i];
3163        }
3164    
3165    
3166  // *************** Group ***************  // *************** Group ***************
# Line 3066  namespace { Line 3286  namespace {
3286  // *************** File ***************  // *************** File ***************
3287  // *  // *
3288    
3289      // File version 2.0, 1998-06-28      /// Reflects Gigasampler file format version 2.0 (1998-06-28).
3290      const DLS::version_t File::VERSION_2 = {      const DLS::version_t File::VERSION_2 = {
3291          0, 2, 19980628 & 0xffff, 19980628 >> 16          0, 2, 19980628 & 0xffff, 19980628 >> 16
3292      };      };
3293    
3294      // File version 3.0, 2003-03-31      /// Reflects Gigasampler file format version 3.0 (2003-03-31).
3295      const DLS::version_t File::VERSION_3 = {      const DLS::version_t File::VERSION_3 = {
3296          0, 3, 20030331 & 0xffff, 20030331 >> 16          0, 3, 20030331 & 0xffff, 20030331 >> 16
3297      };      };
3298    
3299      const DLS::Info::FixedStringLength File::FixedStringLengths[] = {      static const DLS::Info::string_length_t _FileFixedStringLengths[] = {
3300          { CHUNK_ID_IARL, 256 },          { CHUNK_ID_IARL, 256 },
3301          { CHUNK_ID_IART, 128 },          { CHUNK_ID_IART, 128 },
3302          { CHUNK_ID_ICMS, 128 },          { CHUNK_ID_ICMS, 128 },
# Line 3098  namespace { Line 3318  namespace {
3318      };      };
3319    
3320      File::File() : DLS::File() {      File::File() : DLS::File() {
3321            bAutoLoad = true;
3322          *pVersion = VERSION_3;          *pVersion = VERSION_3;
3323          pGroups = NULL;          pGroups = NULL;
3324          pInfo->FixedStringLengths = FixedStringLengths;          pInfo->SetFixedStringLengths(_FileFixedStringLengths);
3325          pInfo->ArchivalLocation = String(256, ' ');          pInfo->ArchivalLocation = String(256, ' ');
3326    
3327          // add some mandatory chunks to get the file chunks in right          // add some mandatory chunks to get the file chunks in right
# Line 3113  namespace { Line 3334  namespace {
3334      }      }
3335    
3336      File::File(RIFF::File* pRIFF) : DLS::File(pRIFF) {      File::File(RIFF::File* pRIFF) : DLS::File(pRIFF) {
3337            bAutoLoad = true;
3338          pGroups = NULL;          pGroups = NULL;
3339          pInfo->FixedStringLengths = FixedStringLengths;          pInfo->SetFixedStringLengths(_FileFixedStringLengths);
3340      }      }
3341    
3342      File::~File() {      File::~File() {
# Line 3182  namespace { Line 3404  namespace {
3404          pSamples->erase(iter);          pSamples->erase(iter);
3405          delete pSample;          delete pSample;
3406    
3407            SampleList::iterator tmp = SamplesIterator;
3408          // remove all references to the sample          // remove all references to the sample
3409          for (Instrument* instrument = GetFirstInstrument() ; instrument ;          for (Instrument* instrument = GetFirstInstrument() ; instrument ;
3410               instrument = GetNextInstrument()) {               instrument = GetNextInstrument()) {
# Line 3196  namespace { Line 3419  namespace {
3419                  }                  }
3420              }              }
3421          }          }
3422            SamplesIterator = tmp; // restore iterator
3423      }      }
3424    
3425      void File::LoadSamples() {      void File::LoadSamples() {
# Line 3286  namespace { Line 3510  namespace {
3510              progress_t subprogress;              progress_t subprogress;
3511              __divide_progress(pProgress, &subprogress, 3.0f, 0.0f); // randomly schedule 33% for this subtask              __divide_progress(pProgress, &subprogress, 3.0f, 0.0f); // randomly schedule 33% for this subtask
3512              __notify_progress(&subprogress, 0.0f);              __notify_progress(&subprogress, 0.0f);
3513              GetFirstSample(&subprogress); // now force all samples to be loaded              if (GetAutoLoad())
3514                    GetFirstSample(&subprogress); // now force all samples to be loaded
3515              __notify_progress(&subprogress, 1.0f);              __notify_progress(&subprogress, 1.0f);
3516    
3517              // instrument loading subtask              // instrument loading subtask
# Line 3693  namespace { Line 3918  namespace {
3918          }          }
3919      }      }
3920    
3921        /**
3922         * Enable / disable automatic loading. By default this properyt is
3923         * enabled and all informations are loaded automatically. However
3924         * loading all Regions, DimensionRegions and especially samples might
3925         * take a long time for large .gig files, and sometimes one might only
3926         * be interested in retrieving very superficial informations like the
3927         * amount of instruments and their names. In this case one might disable
3928         * automatic loading to avoid very slow response times.
3929         *
3930         * @e CAUTION: by disabling this property many pointers (i.e. sample
3931         * references) and informations will have invalid or even undefined
3932         * data! This feature is currently only intended for retrieving very
3933         * superficial informations in a very fast way. Don't use it to retrieve
3934         * details like synthesis informations or even to modify .gig files!
3935         */
3936        void File::SetAutoLoad(bool b) {
3937            bAutoLoad = b;
3938        }
3939    
3940        /**
3941         * Returns whether automatic loading is enabled.
3942         * @see SetAutoLoad()
3943         */
3944        bool File::GetAutoLoad() {
3945            return bAutoLoad;
3946        }
3947    
3948    
3949    
3950  // *************** Exception ***************  // *************** Exception ***************
Legend:
Removed from v.1335  
changed lines
  Added in v.1713
  ViewVC Help
Powered by ViewVC