/[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 3481 by schoenebeck, Fri Feb 22 12:12:50 2019 UTC revision 3710 by schoenebeck, Fri Jan 10 13:32:34 2020 UTC
# Line 2  Line 2 
2   *                                                                         *   *                                                                         *
3   *   libgig - C++ cross-platform Gigasampler format file access library    *   *   libgig - C++ cross-platform Gigasampler format file access library    *
4   *                                                                         *   *                                                                         *
5   *   Copyright (C) 2003-2019 by Christian Schoenebeck                      *   *   Copyright (C) 2003-2020 by Christian Schoenebeck                      *
6   *                              <cuse@users.sourceforge.net>               *   *                              <cuse@users.sourceforge.net>               *
7   *                                                                         *   *                                                                         *
8   *   This library is free software; you can redistribute it and/or modify  *   *   This library is free software; you can redistribute it and/or modify  *
# Line 1740  namespace { Line 1740  namespace {
1740              VCFType                         = vcf_type_lowpass;              VCFType                         = vcf_type_lowpass;
1741              memset(DimensionUpperLimits, 127, 8);              memset(DimensionUpperLimits, 127, 8);
1742          }          }
1743    
1744          // chunk for own format extensions, these will *NOT* work with Gigasampler/GigaStudio !          // chunk for own format extensions, these will *NOT* work with Gigasampler/GigaStudio !
1745          RIFF::Chunk* lsde = _3ewl->GetSubChunk(CHUNK_ID_LSDE);          RIFF::Chunk* lsde = _3ewl->GetSubChunk(CHUNK_ID_LSDE);
1746          if (lsde) { // format extension for EG behavior options          if (lsde) { // format extension for EG behavior options
# Line 1765  namespace { Line 1766  namespace {
1766              SustainReleaseTrigger   = sust_rel_trg_none;              SustainReleaseTrigger   = sust_rel_trg_none;
1767              NoNoteOffReleaseTrigger = false;              NoNoteOffReleaseTrigger = false;
1768          }          }
1769            // format extension for LFOs' wave form, phase displacement and for
1770            // LFO3's flip phase
1771            if (lsde && lsde->GetSize() > 4) {
1772                lsde->SetPos(4);
1773                LFO1WaveForm = static_cast<lfo_wave_t>( lsde->ReadUint16() );
1774                LFO2WaveForm = static_cast<lfo_wave_t>( lsde->ReadUint16() );
1775                LFO3WaveForm = static_cast<lfo_wave_t>( lsde->ReadUint16() );
1776                lsde->ReadUint16(); // unused 16 bits, reserved for potential future use
1777                LFO1Phase = (double) GIG_EXP_DECODE( lsde->ReadInt32() );
1778                LFO2Phase = (double) GIG_EXP_DECODE( lsde->ReadInt32() );
1779                LFO3Phase = (double) GIG_EXP_DECODE( lsde->ReadInt32() );
1780                const uint32_t flags = lsde->ReadInt32();
1781                LFO3FlipPhase = flags & 1;
1782            } else {
1783                LFO1WaveForm = lfo_wave_sine;
1784                LFO2WaveForm = lfo_wave_sine;
1785                LFO3WaveForm = lfo_wave_sine;
1786                LFO1Phase = 0.0;
1787                LFO2Phase = 0.0;
1788                LFO3Phase = 0.0;
1789                LFO3FlipPhase = false;
1790            }
1791    
1792          pVelocityAttenuationTable = GetVelocityTable(VelocityResponseCurve,          pVelocityAttenuationTable = GetVelocityTable(VelocityResponseCurve,
1793                                                       VelocityResponseDepth,                                                       VelocityResponseDepth,
# Line 1890  namespace { Line 1913  namespace {
1913          SRLZ(EG1ControllerAttackInfluence);          SRLZ(EG1ControllerAttackInfluence);
1914          SRLZ(EG1ControllerDecayInfluence);          SRLZ(EG1ControllerDecayInfluence);
1915          SRLZ(EG1ControllerReleaseInfluence);          SRLZ(EG1ControllerReleaseInfluence);
1916            SRLZ(LFO1WaveForm);
1917          SRLZ(LFO1Frequency);          SRLZ(LFO1Frequency);
1918            SRLZ(LFO1Phase);
1919          SRLZ(LFO1InternalDepth);          SRLZ(LFO1InternalDepth);
1920          SRLZ(LFO1ControlDepth);          SRLZ(LFO1ControlDepth);
1921          SRLZ(LFO1Controller);          SRLZ(LFO1Controller);
# Line 1908  namespace { Line 1933  namespace {
1933          SRLZ(EG2ControllerAttackInfluence);          SRLZ(EG2ControllerAttackInfluence);
1934          SRLZ(EG2ControllerDecayInfluence);          SRLZ(EG2ControllerDecayInfluence);
1935          SRLZ(EG2ControllerReleaseInfluence);          SRLZ(EG2ControllerReleaseInfluence);
1936            SRLZ(LFO2WaveForm);
1937          SRLZ(LFO2Frequency);          SRLZ(LFO2Frequency);
1938            SRLZ(LFO2Phase);
1939          SRLZ(LFO2InternalDepth);          SRLZ(LFO2InternalDepth);
1940          SRLZ(LFO2ControlDepth);          SRLZ(LFO2ControlDepth);
1941          SRLZ(LFO2Controller);          SRLZ(LFO2Controller);
# Line 1916  namespace { Line 1943  namespace {
1943          SRLZ(LFO2Sync);          SRLZ(LFO2Sync);
1944          SRLZ(EG3Attack);          SRLZ(EG3Attack);
1945          SRLZ(EG3Depth);          SRLZ(EG3Depth);
1946            SRLZ(LFO3WaveForm);
1947          SRLZ(LFO3Frequency);          SRLZ(LFO3Frequency);
1948            SRLZ(LFO3Phase);
1949          SRLZ(LFO3InternalDepth);          SRLZ(LFO3InternalDepth);
1950          SRLZ(LFO3ControlDepth);          SRLZ(LFO3ControlDepth);
1951          SRLZ(LFO3Controller);          SRLZ(LFO3Controller);
1952            SRLZ(LFO3FlipPhase);
1953          SRLZ(LFO3Sync);          SRLZ(LFO3Sync);
1954          SRLZ(VCFEnabled);          SRLZ(VCFEnabled);
1955          SRLZ(VCFType);          SRLZ(VCFType);
# Line 2267  namespace { Line 2297  namespace {
2297          // chunk for own format extensions, these will *NOT* work with          // chunk for own format extensions, these will *NOT* work with
2298          // Gigasampler/GigaStudio !          // Gigasampler/GigaStudio !
2299          RIFF::Chunk* lsde = pParentList->GetSubChunk(CHUNK_ID_LSDE);          RIFF::Chunk* lsde = pParentList->GetSubChunk(CHUNK_ID_LSDE);
2300          const int lsdeSize = 4; // NOTE: we reserved the 3rd byte for a potential future EG3 option          const int lsdeSize =
2301          if (!lsde) {              3 /* EG cancel options */ +
2302              // only add this "LSDE" chunk if either EG options or release              1 /* sustain pedal up on release trigger option */ +
2303              // trigger options deviate from their default behaviour              8 /* LFOs' wave forms */ + 12 /* LFOs' phase */ + 4 /* flags (LFO3FlipPhase) */;
2304              eg_opt_t defaultOpt;          if (!lsde && UsesAnyGigFormatExtension()) {
2305              if (memcmp(&EG1Options, &defaultOpt, sizeof(eg_opt_t)) ||              // only add this "LSDE" chunk if there is some (format extension)
2306                  memcmp(&EG2Options, &defaultOpt, sizeof(eg_opt_t)) ||              // setting effective that would require our "LSDE" format extension
2307                  SustainReleaseTrigger || NoNoteOffReleaseTrigger)              // chunk to be stored
2308              {              lsde = pParentList->AddSubChunk(CHUNK_ID_LSDE, lsdeSize);
2309                  lsde = pParentList->AddSubChunk(CHUNK_ID_LSDE, lsdeSize);              // move LSDE chunk to the end of parent list
2310                  // move LSDE chunk to the end of parent list              pParentList->MoveSubChunk(lsde, (RIFF::Chunk*)NULL);
                 pParentList->MoveSubChunk(lsde, (RIFF::Chunk*)NULL);  
             }  
2311          }          }
2312          if (lsde) {          if (lsde) {
2313              if (lsde->GetNewSize() < lsdeSize)              if (lsde->GetNewSize() < lsdeSize)
# Line 2297  namespace { Line 2325  namespace {
2325              }              }
2326              // format extension for release trigger options              // format extension for release trigger options
2327              pData[3] = static_cast<uint8_t>(SustainReleaseTrigger) | (NoNoteOffReleaseTrigger ? (1<<7) : 0);              pData[3] = static_cast<uint8_t>(SustainReleaseTrigger) | (NoNoteOffReleaseTrigger ? (1<<7) : 0);
2328                // format extension for LFOs' wave form, phase displacement and for
2329                // LFO3's flip phase
2330                store16(&pData[4], LFO1WaveForm);
2331                store16(&pData[6], LFO2WaveForm);
2332                store16(&pData[8], LFO3WaveForm);
2333                //NOTE: 16 bits reserved here for potential future use !
2334                const int32_t lfo1Phase = (int32_t) GIG_EXP_ENCODE(LFO1Phase);
2335                const int32_t lfo2Phase = (int32_t) GIG_EXP_ENCODE(LFO2Phase);
2336                const int32_t lfo3Phase = (int32_t) GIG_EXP_ENCODE(LFO3Phase);
2337                store32(&pData[12], lfo1Phase);
2338                store32(&pData[16], lfo2Phase);
2339                store32(&pData[20], lfo3Phase);
2340                const int32_t flags = LFO3FlipPhase ? 1 : 0;
2341                store32(&pData[24], flags);
2342    
2343                // compile time sanity check: is our last store access here
2344                // consistent with the initial lsdeSize value assignment?
2345                static_assert(lsdeSize == 28, "Inconsistency in assumed 'LSDE' RIFF chunk size");
2346          }          }
2347      }      }
2348    
2349        /**
2350         * Returns @c true in case this DimensionRegion object uses any gig format
2351         * extension, that is whether this DimensionRegion object currently has any
2352         * setting effective that would require our "LSDE" RIFF chunk to be stored
2353         * to the gig file.
2354         *
2355         * Right now this is a private method. It is considerable though this method
2356         * to become (in slightly modified form) a public API method in future, i.e.
2357         * to allow instrument editors to visualize and/or warn the user of any
2358         * format extension being used. Right now this method really just serves to
2359         * answer the question whether an LSDE chunk is required, for the public API
2360         * purpose this method would also need to check whether any other setting
2361         * stored to the regular value '3ewa' chunk, is actually a format extension
2362         * as well.
2363         */
2364        bool DimensionRegion::UsesAnyGigFormatExtension() const {
2365            eg_opt_t defaultOpt;
2366            return memcmp(&EG1Options, &defaultOpt, sizeof(eg_opt_t)) ||
2367                   memcmp(&EG2Options, &defaultOpt, sizeof(eg_opt_t)) ||
2368                   SustainReleaseTrigger || NoNoteOffReleaseTrigger ||
2369                   LFO1WaveForm || LFO2WaveForm || LFO3WaveForm ||
2370                   LFO1Phase || LFO2Phase || LFO3Phase ||
2371                   LFO3FlipPhase;
2372        }
2373    
2374      double* DimensionRegion::GetReleaseVelocityTable(curve_type_t releaseVelocityResponseCurve, uint8_t releaseVelocityResponseDepth) {      double* DimensionRegion::GetReleaseVelocityTable(curve_type_t releaseVelocityResponseCurve, uint8_t releaseVelocityResponseDepth) {
2375          curve_type_t curveType = releaseVelocityResponseCurve;          curve_type_t curveType = releaseVelocityResponseCurve;
2376          uint8_t depth = releaseVelocityResponseDepth;          uint8_t depth = releaseVelocityResponseDepth;
# Line 3341  namespace { Line 3412  namespace {
3412          }          }
3413    
3414          File* pFile = (File*) GetParent()->GetParent();          File* pFile = (File*) GetParent()->GetParent();
3415          bool versiongt2 = pFile->pVersion && pFile->pVersion->major > 2;          const bool versiongt2 = pFile->pVersion && pFile->pVersion->major > 2;
3416          const int iMaxDimensions =  versiongt2 ? 8 : 5;          const int iMaxDimensions =  versiongt2 ? 8 : 5;
3417          const int iMaxDimensionRegions = versiongt2 ? 256 : 32;          const int iMaxDimensionRegions = versiongt2 ? 256 : 32;
3418    
# Line 3388  namespace { Line 3459  namespace {
3459              }              }
3460              store32(&pData[iWavePoolOffset + i * 4], iWaveIndex);              store32(&pData[iWavePoolOffset + i * 4], iWaveIndex);
3461          }          }
3462    
3463            // The following chunks are just added for compatibility with the
3464            // GigaStudio software, which would show a warning if these were
3465            // missing. However currently these chunks don't cover any useful
3466            // data. So if this gig file uses any of our own gig format
3467            // extensions which would cause this gig file to be unloadable
3468            // with GSt software anyway, then just skip these GSt compatibility
3469            // chunks here as well.
3470            if (versiongt2 && !UsesAnyGigFormatExtension()) {
3471                // add 3dnm list which always seems to be empty
3472                RIFF::List* _3dnm = pCkRegion->GetSubList(LIST_TYPE_3DNM);
3473                if (!_3dnm) _3dnm = pCkRegion->AddSubList(LIST_TYPE_3DNM);
3474    
3475                // add 3ddp chunk which always seems to have 16 bytes of 0xFF
3476                RIFF::Chunk* _3ddp = pCkRegion->GetSubChunk(CHUNK_ID_3DDP);
3477                if (!_3ddp) _3ddp =  pCkRegion->AddSubChunk(CHUNK_ID_3DDP, 16);
3478                uint8_t* pData = (uint8_t*) _3ddp->LoadChunkData();
3479                for (int i = 0; i < 16; i += 4) {
3480                    store32(&pData[i], 0xFFFFFFFF);
3481                }
3482    
3483                // move 3dnm and 3ddp to the end of the region list
3484                pCkRegion->MoveSubChunk(pCkRegion->GetSubList(LIST_TYPE_3DNM), (RIFF::Chunk*)NULL);
3485                pCkRegion->MoveSubChunk(pCkRegion->GetSubChunk(CHUNK_ID_3DDP), (RIFF::Chunk*)NULL);
3486            } else {
3487                // this is intended for the user switching from GSt >= 3 version
3488                // back to an older format version, delete GSt3 chunks ...
3489                RIFF::List* _3dnm = pCkRegion->GetSubList(LIST_TYPE_3DNM);
3490                if (_3dnm) pCkRegion->DeleteSubChunk(_3dnm);
3491    
3492                RIFF::Chunk* _3ddp = pCkRegion->GetSubChunk(CHUNK_ID_3DDP);
3493                if (_3ddp) pCkRegion->DeleteSubChunk(_3ddp);
3494            }
3495      }      }
3496    
3497      void Region::LoadDimensionRegions(RIFF::List* rgn) {      void Region::LoadDimensionRegions(RIFF::List* rgn) {
# Line 3926  namespace { Line 4030  namespace {
4030          // now tempRegion's dimensions and DimensionRegions basically reflect          // now tempRegion's dimensions and DimensionRegions basically reflect
4031          // what we wanted to get for this actual Region here, so we now just          // what we wanted to get for this actual Region here, so we now just
4032          // delete and recreate the dimension in question with the new amount          // delete and recreate the dimension in question with the new amount
4033          // zones and then copy back from tempRegion                // zones and then copy back from tempRegion. we're actually deleting and
4034          DeleteDimension(oldDef);          // recreating all dimensions here, to avoid altering the precise order
4035          AddDimension(&newDef);          // of the dimensions (which would not be an error per so, but it would
4036            // cause usability issues with instrument editors)
4037            {
4038                std::vector<dimension_def_t> oldDefs;
4039                for (int i = 0; i < Dimensions; ++i)
4040                    oldDefs.push_back(pDimensionDefinitions[i]); // copy, don't reference
4041                for (int i = Dimensions - 1; i >= 0; --i)
4042                    DeleteDimension(&pDimensionDefinitions[i]);
4043                for (int i = 0; i < oldDefs.size(); ++i) {
4044                    dimension_def_t& def = oldDefs[i];
4045                    AddDimension(
4046                        (def.dimension == newDef.dimension) ? &newDef : &def
4047                    );
4048                }
4049            }
4050          for (int iSrc = 0; iSrc < 256; ++iSrc) {          for (int iSrc = 0; iSrc < 256; ++iSrc) {
4051              DimensionRegion* srcDimRgn = tempRgn->pDimensionRegions[iSrc];              DimensionRegion* srcDimRgn = tempRgn->pDimensionRegions[iSrc];
4052              if (!srcDimRgn) continue;              if (!srcDimRgn) continue;
# Line 4252  namespace { Line 4370  namespace {
4370          Layers = orig->Layers;          Layers = orig->Layers;
4371      }      }
4372    
4373        /**
4374         * Returns @c true in case this Region object uses any gig format
4375         * extension, that is e.g. whether any DimensionRegion object currently
4376         * has any setting effective that would require our "LSDE" RIFF chunk to
4377         * be stored to the gig file.
4378         *
4379         * Right now this is a private method. It is considerable though this method
4380         * to become (in slightly modified form) a public API method in future, i.e.
4381         * to allow instrument editors to visualize and/or warn the user of any gig
4382         * format extension being used. See also comments on
4383         * DimensionRegion::UsesAnyGigFormatExtension() for details about such a
4384         * potential public API change in future.
4385         */
4386        bool Region::UsesAnyGigFormatExtension() const {
4387            for (int i = 0; i < 256; i++) {
4388                if (pDimensionRegions[i]) {
4389                    if (pDimensionRegions[i]->UsesAnyGigFormatExtension())
4390                        return true;
4391                }
4392            }
4393            return false;
4394        }
4395    
4396    
4397  // *************** MidiRule ***************  // *************** MidiRule ***************
4398  // *  // *
# Line 4789  namespace { Line 4930  namespace {
4930                  RIFF::List* rgn = lrgn->GetFirstSubList();                  RIFF::List* rgn = lrgn->GetFirstSubList();
4931                  while (rgn) {                  while (rgn) {
4932                      if (rgn->GetListType() == LIST_TYPE_RGN) {                      if (rgn->GetListType() == LIST_TYPE_RGN) {
4933                          __notify_progress(pProgress, (float) pRegions->size() / (float) Regions);                          if (pProgress)
4934                                __notify_progress(pProgress, (float) pRegions->size() / (float) Regions);
4935                          pRegions->push_back(new Region(this, rgn));                          pRegions->push_back(new Region(this, rgn));
4936                      }                      }
4937                      rgn = lrgn->GetNextSubList();                      rgn = lrgn->GetNextSubList();
# Line 4823  namespace { Line 4965  namespace {
4965              }              }
4966          }          }
4967    
4968          __notify_progress(pProgress, 1.0f); // notify done          if (pProgress)
4969                __notify_progress(pProgress, 1.0f); // notify done
4970      }      }
4971    
4972      void Instrument::UpdateRegionKeyTable() {      void Instrument::UpdateRegionKeyTable() {
# Line 5420  namespace { Line 5563  namespace {
5563          UpdateRegionKeyTable();          UpdateRegionKeyTable();
5564      }      }
5565    
5566        /**
5567         * Returns @c true in case this Instrument object uses any gig format
5568         * extension, that is e.g. whether any DimensionRegion object currently
5569         * has any setting effective that would require our "LSDE" RIFF chunk to
5570         * be stored to the gig file.
5571         *
5572         * Right now this is a private method. It is considerable though this method
5573         * to become (in slightly modified form) a public API method in future, i.e.
5574         * to allow instrument editors to visualize and/or warn the user of any gig
5575         * format extension being used. See also comments on
5576         * DimensionRegion::UsesAnyGigFormatExtension() for details about such a
5577         * potential public API change in future.
5578         */
5579        bool Instrument::UsesAnyGigFormatExtension() const {
5580            if (!pRegions) return false;
5581            RegionList::const_iterator iter = pRegions->begin();
5582            RegionList::const_iterator end  = pRegions->end();
5583            for (; iter != end; ++iter) {
5584                gig::Region* rgn = static_cast<gig::Region*>(*iter);
5585                if (rgn->UsesAnyGigFormatExtension())
5586                    return true;
5587            }
5588            return false;
5589        }
5590    
5591    
5592  // *************** Group ***************  // *************** Group ***************
5593  // *  // *
# Line 5841  namespace { Line 6009  namespace {
6009                  while (wave) {                  while (wave) {
6010                      if (wave->GetListType() == LIST_TYPE_WAVE) {                      if (wave->GetListType() == LIST_TYPE_WAVE) {
6011                          // notify current progress                          // notify current progress
6012                          const float subprogress = (float) iSampleIndex / (float) iTotalSamples;                          if (pProgress) {
6013                          __notify_progress(pProgress, subprogress);                              const float subprogress = (float) iSampleIndex / (float) iTotalSamples;
6014                                __notify_progress(pProgress, subprogress);
6015                            }
6016    
6017                          file_offset_t waveFileOffset = wave->GetFilePos();                          file_offset_t waveFileOffset = wave->GetFilePos();
6018                          pSamples->push_back(new Sample(this, wave, waveFileOffset - wvplFileOffset, i, iSampleIndex));                          pSamples->push_back(new Sample(this, wave, waveFileOffset - wvplFileOffset, i, iSampleIndex));
# Line 5854  namespace { Line 6024  namespace {
6024              }              }
6025          }          }
6026    
6027          __notify_progress(pProgress, 1.0); // notify done          if (pProgress)
6028                __notify_progress(pProgress, 1.0); // notify done
6029      }      }
6030    
6031      Instrument* File::GetFirstInstrument() {      Instrument* File::GetFirstInstrument() {
# Line 5895  namespace { Line 6066  namespace {
6066          if (!pInstruments) {          if (!pInstruments) {
6067              // TODO: hack - we simply load ALL samples here, it would have been done in the Region constructor anyway (ATM)              // TODO: hack - we simply load ALL samples here, it would have been done in the Region constructor anyway (ATM)
6068    
6069              // sample loading subtask              if (pProgress) {
6070              progress_t subprogress;                  // sample loading subtask
6071              __divide_progress(pProgress, &subprogress, 3.0f, 0.0f); // randomly schedule 33% for this subtask                  progress_t subprogress;
6072              __notify_progress(&subprogress, 0.0f);                  __divide_progress(pProgress, &subprogress, 3.0f, 0.0f); // randomly schedule 33% for this subtask
6073              if (GetAutoLoad())                  __notify_progress(&subprogress, 0.0f);
6074                  GetFirstSample(&subprogress); // now force all samples to be loaded                  if (GetAutoLoad())
6075              __notify_progress(&subprogress, 1.0f);                      GetFirstSample(&subprogress); // now force all samples to be loaded
6076                    __notify_progress(&subprogress, 1.0f);
6077              // instrument loading subtask  
6078              if (pProgress && pProgress->callback) {                  // instrument loading subtask
6079                  subprogress.__range_min = subprogress.__range_max;                  if (pProgress->callback) {
6080                  subprogress.__range_max = pProgress->__range_max; // schedule remaining percentage for this subtask                      subprogress.__range_min = subprogress.__range_max;
6081              }                      subprogress.__range_max = pProgress->__range_max; // schedule remaining percentage for this subtask
6082              __notify_progress(&subprogress, 0.0f);                  }
6083              LoadInstruments(&subprogress);                  __notify_progress(&subprogress, 0.0f);
6084              __notify_progress(&subprogress, 1.0f);                  LoadInstruments(&subprogress);
6085                    __notify_progress(&subprogress, 1.0f);
6086                } else {
6087                    // sample loading subtask
6088                    if (GetAutoLoad())
6089                        GetFirstSample(); // now force all samples to be loaded
6090    
6091                    // instrument loading subtask
6092                    LoadInstruments();
6093                }
6094          }          }
6095          if (!pInstruments) return NULL;          if (!pInstruments) return NULL;
6096          InstrumentsIterator = pInstruments->begin();          InstrumentsIterator = pInstruments->begin();
# Line 6075  namespace { Line 6255  namespace {
6255              RIFF::List* lstInstr = lstInstruments->GetFirstSubList();              RIFF::List* lstInstr = lstInstruments->GetFirstSubList();
6256              while (lstInstr) {              while (lstInstr) {
6257                  if (lstInstr->GetListType() == LIST_TYPE_INS) {                  if (lstInstr->GetListType() == LIST_TYPE_INS) {
6258                      // notify current progress                      if (pProgress) {
6259                      const float localProgress = (float) iInstrumentIndex / (float) Instruments;                          // notify current progress
6260                      __notify_progress(pProgress, localProgress);                          const float localProgress = (float) iInstrumentIndex / (float) Instruments;
6261                            __notify_progress(pProgress, localProgress);
                     // divide local progress into subprogress for loading current Instrument  
                     progress_t subprogress;  
                     __divide_progress(pProgress, &subprogress, Instruments, iInstrumentIndex);  
6262    
6263                      pInstruments->push_back(new Instrument(this, lstInstr, &subprogress));                          // divide local progress into subprogress for loading current Instrument
6264                            progress_t subprogress;
6265                            __divide_progress(pProgress, &subprogress, Instruments, iInstrumentIndex);
6266    
6267                            pInstruments->push_back(new Instrument(this, lstInstr, &subprogress));
6268                        } else {
6269                            pInstruments->push_back(new Instrument(this, lstInstr));
6270                        }
6271    
6272                      iInstrumentIndex++;                      iInstrumentIndex++;
6273                  }                  }
6274                  lstInstr = lstInstruments->GetNextSubList();                  lstInstr = lstInstruments->GetNextSubList();
6275              }              }
6276              __notify_progress(pProgress, 1.0); // notify done              if (pProgress)
6277                    __notify_progress(pProgress, 1.0); // notify done
6278          }          }
6279      }      }
6280    
# Line 6535  namespace { Line 6720  namespace {
6720              if (pVersion && pVersion->major > 2) {              if (pVersion && pVersion->major > 2) {
6721                  RIFF::Chunk* _3gnm = _3gnl->GetFirstSubChunk();                  RIFF::Chunk* _3gnm = _3gnl->GetFirstSubChunk();
6722                  for (int i = 0 ; i < 128 ; i++) {                  for (int i = 0 ; i < 128 ; i++) {
6723                      if (i >= pGroups->size()) ::SaveString(CHUNK_ID_3GNM, _3gnm, _3gnl, "", "", true, 64);                      // create 128 empty placeholder strings which will either
6724                        // be filled by Group::UpdateChunks below or left empty.
6725                        ::SaveString(CHUNK_ID_3GNM, _3gnm, _3gnl, "", "", true, 64);
6726                      if (_3gnm) _3gnm = _3gnl->GetNextSubChunk();                      if (_3gnm) _3gnm = _3gnl->GetNextSubChunk();
6727                  }                  }
6728              }              }
# Line 6731  namespace { Line 6918  namespace {
6918          return bAutoLoad;          return bAutoLoad;
6919      }      }
6920    
6921        /**
6922         * Returns @c true in case this gig File object uses any gig format
6923         * extension, that is e.g. whether any DimensionRegion object currently
6924         * has any setting effective that would require our "LSDE" RIFF chunk to
6925         * be stored to the gig file.
6926         *
6927         * Right now this is a private method. It is considerable though this method
6928         * to become (in slightly modified form) a public API method in future, i.e.
6929         * to allow instrument editors to visualize and/or warn the user of any gig
6930         * format extension being used. See also comments on
6931         * DimensionRegion::UsesAnyGigFormatExtension() for details about such a
6932         * potential public API change in future.
6933         */
6934        bool File::UsesAnyGigFormatExtension() const {
6935            if (!pInstruments) return false;
6936            InstrumentList::iterator iter = pInstruments->begin();
6937            InstrumentList::iterator end  = pInstruments->end();
6938            for (; iter != end; ++iter) {
6939                Instrument* pInstrument = static_cast<gig::Instrument*>(*iter);
6940                if (pInstrument->UsesAnyGigFormatExtension())
6941                    return true;
6942            }
6943            return false;
6944        }
6945    
6946    
6947  // *************** Exception ***************  // *************** Exception ***************
Legend:
Removed from v.3481  
changed lines
  Added in v.3710
  ViewVC Help
Powered by ViewVC