/[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 2555 by schoenebeck, Fri May 16 23:08:42 2014 UTC revision 2682 by schoenebeck, Mon Dec 29 16:25:51 2014 UTC
# Line 53  Line 53 
53    
54  namespace gig {  namespace gig {
55    
 // *************** progress_t ***************  
 // *  
   
     progress_t::progress_t() {  
         callback    = NULL;  
         custom      = NULL;  
         __range_min = 0.0f;  
         __range_max = 1.0f;  
     }  
   
     // private helper function to convert progress of a subprocess into the global progress  
     static void __notify_progress(progress_t* pProgress, float subprogress) {  
         if (pProgress && pProgress->callback) {  
             const float totalrange    = pProgress->__range_max - pProgress->__range_min;  
             const float totalprogress = pProgress->__range_min + subprogress * totalrange;  
             pProgress->factor         = totalprogress;  
             pProgress->callback(pProgress); // now actually notify about the progress  
         }  
     }  
   
     // private helper function to divide a progress into subprogresses  
     static void __divide_progress(progress_t* pParentProgress, progress_t* pSubProgress, float totalTasks, float currentTask) {  
         if (pParentProgress && pParentProgress->callback) {  
             const float totalrange    = pParentProgress->__range_max - pParentProgress->__range_min;  
             pSubProgress->callback    = pParentProgress->callback;  
             pSubProgress->custom      = pParentProgress->custom;  
             pSubProgress->__range_min = pParentProgress->__range_min + totalrange * currentTask / totalTasks;  
             pSubProgress->__range_max = pSubProgress->__range_min + totalrange / totalTasks;  
         }  
     }  
   
   
56  // *************** Internal functions for sample decompression ***************  // *************** Internal functions for sample decompression ***************
57  // *  // *
58    
# Line 528  namespace { Line 496  namespace {
496       * Usually there is absolutely no need to call this method explicitly.       * Usually there is absolutely no need to call this method explicitly.
497       * It will be called automatically when File::Save() was called.       * It will be called automatically when File::Save() was called.
498       *       *
499         * @param pProgress - callback function for progress notification
500       * @throws DLS::Exception if FormatTag != DLS_WAVE_FORMAT_PCM or no sample data       * @throws DLS::Exception if FormatTag != DLS_WAVE_FORMAT_PCM or no sample data
501       *                        was provided yet       *                        was provided yet
502       * @throws gig::Exception if there is any invalid sample setting       * @throws gig::Exception if there is any invalid sample setting
503       */       */
504      void Sample::UpdateChunks() {      void Sample::UpdateChunks(progress_t* pProgress) {
505          // first update base class's chunks          // first update base class's chunks
506          DLS::Sample::UpdateChunks();          DLS::Sample::UpdateChunks(pProgress);
507    
508          // make sure 'smpl' chunk exists          // make sure 'smpl' chunk exists
509          pCkSmpl = pWaveList->GetSubChunk(CHUNK_ID_SMPL);          pCkSmpl = pWaveList->GetSubChunk(CHUNK_ID_SMPL);
# Line 1752  namespace { Line 1721  namespace {
1721       *       *
1722       * Usually there is absolutely no need to call this method explicitly.       * Usually there is absolutely no need to call this method explicitly.
1723       * It will be called automatically when File::Save() was called.       * It will be called automatically when File::Save() was called.
1724         *
1725         * @param pProgress - callback function for progress notification
1726       */       */
1727      void DimensionRegion::UpdateChunks() {      void DimensionRegion::UpdateChunks(progress_t* pProgress) {
1728          // first update base class's chunk          // first update base class's chunk
1729          DLS::Sampler::UpdateChunks();          DLS::Sampler::UpdateChunks(pProgress);
1730    
1731          RIFF::Chunk* wsmp = pParentList->GetSubChunk(CHUNK_ID_WSMP);          RIFF::Chunk* wsmp = pParentList->GetSubChunk(CHUNK_ID_WSMP);
1732          uint8_t* pData = (uint8_t*) wsmp->LoadChunkData();          uint8_t* pData = (uint8_t*) wsmp->LoadChunkData();
# Line 3026  namespace { Line 2997  namespace {
2997       * Usually there is absolutely no need to call this method explicitly.       * Usually there is absolutely no need to call this method explicitly.
2998       * It will be called automatically when File::Save() was called.       * It will be called automatically when File::Save() was called.
2999       *       *
3000         * @param pProgress - callback function for progress notification
3001       * @throws gig::Exception if samples cannot be dereferenced       * @throws gig::Exception if samples cannot be dereferenced
3002       */       */
3003      void Region::UpdateChunks() {      void Region::UpdateChunks(progress_t* pProgress) {
3004          // in the gig format we don't care about the Region's sample reference          // in the gig format we don't care about the Region's sample reference
3005          // but we still have to provide some existing one to not corrupt the          // but we still have to provide some existing one to not corrupt the
3006          // file, so to avoid the latter we simply always assign the sample of          // file, so to avoid the latter we simply always assign the sample of
# Line 3036  namespace { Line 3008  namespace {
3008          pSample = pDimensionRegions[0]->pSample;          pSample = pDimensionRegions[0]->pSample;
3009    
3010          // first update base class's chunks          // first update base class's chunks
3011          DLS::Region::UpdateChunks();          DLS::Region::UpdateChunks(pProgress);
3012    
3013          // update dimension region's chunks          // update dimension region's chunks
3014          for (int i = 0; i < DimensionRegions; i++) {          for (int i = 0; i < DimensionRegions; i++) {
3015              pDimensionRegions[i]->UpdateChunks();              pDimensionRegions[i]->UpdateChunks(pProgress);
3016          }          }
3017    
3018          File* pFile = (File*) GetParent()->GetParent();          File* pFile = (File*) GetParent()->GetParent();
# Line 3056  namespace { Line 3028  namespace {
3028              memset(_3lnk->LoadChunkData(), 0, _3lnkChunkSize);              memset(_3lnk->LoadChunkData(), 0, _3lnkChunkSize);
3029    
3030              // move 3prg to last position              // move 3prg to last position
3031              pCkRegion->MoveSubChunk(pCkRegion->GetSubList(LIST_TYPE_3PRG), 0);              pCkRegion->MoveSubChunk(pCkRegion->GetSubList(LIST_TYPE_3PRG), (RIFF::Chunk*)NULL);
3032          }          }
3033    
3034          // update dimension definitions in '3lnk' chunk          // update dimension definitions in '3lnk' chunk
# Line 3509  namespace { Line 3481  namespace {
3481    
3482          // delete temporary region          // delete temporary region
3483          delete tempRgn;          delete tempRgn;
3484    
3485            UpdateVelocityTable();
3486      }      }
3487    
3488      /** @brief Divide split zone of a dimension in two (increment zone amount).      /** @brief Divide split zone of a dimension in two (increment zone amount).
# Line 3646  namespace { Line 3620  namespace {
3620    
3621          // delete temporary region          // delete temporary region
3622          delete tempRgn;          delete tempRgn;
3623    
3624            UpdateVelocityTable();
3625        }
3626    
3627        /** @brief Change type of an existing dimension.
3628         *
3629         * Alters the dimension type of a dimension already existing on this
3630         * region. If there is currently no dimension on this Region with type
3631         * @a oldType, then this call with throw an Exception. Likewise there are
3632         * cases where the requested dimension type cannot be performed. For example
3633         * if the new dimension type shall be gig::dimension_samplechannel, and the
3634         * current dimension has more than 2 zones. In such cases an Exception is
3635         * thrown as well.
3636         *
3637         * @param oldType - identifies the existing dimension to be changed
3638         * @param newType - to which dimension type it should be changed to
3639         * @throws gig::Exception if requested change cannot be performed
3640         */
3641        void Region::SetDimensionType(dimension_t oldType, dimension_t newType) {
3642            if (oldType == newType) return;
3643            dimension_def_t* def = GetDimensionDefinition(oldType);
3644            if (!def)
3645                throw gig::Exception("No dimension with provided old dimension type exists on this region");
3646            if (newType == dimension_samplechannel && def->zones != 2)
3647                throw gig::Exception("Cannot change to dimension type 'sample channel', because existing dimension does not have 2 zones");
3648            if (GetDimensionDefinition(newType))
3649                throw gig::Exception("There is already a dimension with requested new dimension type on this region");
3650            def->dimension  = newType;
3651            def->split_type = __resolveSplitType(newType);
3652      }      }
3653    
3654      DimensionRegion* Region::GetDimensionRegionByBit(const std::map<dimension_t,int>& DimCase) {      DimensionRegion* Region::GetDimensionRegionByBit(const std::map<dimension_t,int>& DimCase) {
# Line 3739  namespace { Line 3742  namespace {
3742              }              }
3743              bitpos += pDimensionDefinitions[i].bits;              bitpos += pDimensionDefinitions[i].bits;
3744          }          }
3745          DimensionRegion* dimreg = pDimensionRegions[dimregidx];          DimensionRegion* dimreg = pDimensionRegions[dimregidx & 255];
3746            if (!dimreg) return NULL;
3747          if (veldim != -1) {          if (veldim != -1) {
3748              // (dimreg is now the dimension region for the lowest velocity)              // (dimreg is now the dimension region for the lowest velocity)
3749              if (dimreg->VelocityTable) // custom defined zone ranges              if (dimreg->VelocityTable) // custom defined zone ranges
3750                  bits = dimreg->VelocityTable[DimValues[veldim]];                  bits = dimreg->VelocityTable[DimValues[veldim] & 127];
3751              else // normal split type              else // normal split type
3752                  bits = uint8_t(DimValues[veldim] / pDimensionDefinitions[veldim].zone_size);                  bits = uint8_t((DimValues[veldim] & 127) / pDimensionDefinitions[veldim].zone_size);
3753    
3754              dimregidx |= bits << velbitpos;              const uint8_t limiter_mask = (1 << pDimensionDefinitions[veldim].bits) - 1;
3755              dimreg = pDimensionRegions[dimregidx];              dimregidx |= (bits & limiter_mask) << velbitpos;
3756                dimreg = pDimensionRegions[dimregidx & 255];
3757          }          }
3758          return dimreg;          return dimreg;
3759      }      }
3760    
3761        int Region::GetDimensionRegionIndexByValue(const uint DimValues[8]) {
3762            uint8_t bits;
3763            int veldim = -1;
3764            int velbitpos;
3765            int bitpos = 0;
3766            int dimregidx = 0;
3767            for (uint i = 0; i < Dimensions; i++) {
3768                if (pDimensionDefinitions[i].dimension == dimension_velocity) {
3769                    // the velocity dimension must be handled after the other dimensions
3770                    veldim = i;
3771                    velbitpos = bitpos;
3772                } else {
3773                    switch (pDimensionDefinitions[i].split_type) {
3774                        case split_type_normal:
3775                            if (pDimensionRegions[0]->DimensionUpperLimits[i]) {
3776                                // gig3: all normal dimensions (not just the velocity dimension) have custom zone ranges
3777                                for (bits = 0 ; bits < pDimensionDefinitions[i].zones ; bits++) {
3778                                    if (DimValues[i] <= pDimensionRegions[bits << bitpos]->DimensionUpperLimits[i]) break;
3779                                }
3780                            } else {
3781                                // gig2: evenly sized zones
3782                                bits = uint8_t(DimValues[i] / pDimensionDefinitions[i].zone_size);
3783                            }
3784                            break;
3785                        case split_type_bit: // the value is already the sought dimension bit number
3786                            const uint8_t limiter_mask = (0xff << pDimensionDefinitions[i].bits) ^ 0xff;
3787                            bits = DimValues[i] & limiter_mask; // just make sure the value doesn't use more bits than allowed
3788                            break;
3789                    }
3790                    dimregidx |= bits << bitpos;
3791                }
3792                bitpos += pDimensionDefinitions[i].bits;
3793            }
3794            dimregidx &= 255;
3795            DimensionRegion* dimreg = pDimensionRegions[dimregidx];
3796            if (!dimreg) return -1;
3797            if (veldim != -1) {
3798                // (dimreg is now the dimension region for the lowest velocity)
3799                if (dimreg->VelocityTable) // custom defined zone ranges
3800                    bits = dimreg->VelocityTable[DimValues[veldim] & 127];
3801                else // normal split type
3802                    bits = uint8_t((DimValues[veldim] & 127) / pDimensionDefinitions[veldim].zone_size);
3803    
3804                const uint8_t limiter_mask = (1 << pDimensionDefinitions[veldim].bits) - 1;
3805                dimregidx |= (bits & limiter_mask) << velbitpos;
3806                dimregidx &= 255;
3807            }
3808            return dimregidx;
3809        }
3810    
3811      /**      /**
3812       * Returns the appropriate DimensionRegion for the given dimension bit       * Returns the appropriate DimensionRegion for the given dimension bit
3813       * numbers (zone index). You usually use <i>GetDimensionRegionByValue</i>       * numbers (zone index). You usually use <i>GetDimensionRegionByValue</i>
# Line 4019  namespace { Line 4074  namespace {
4074          }          }
4075      }      }
4076    
4077    // *************** Script ***************
4078    // *
4079    
4080        Script::Script(ScriptGroup* group, RIFF::Chunk* ckScri) {
4081            pGroup = group;
4082            pChunk = ckScri;
4083            if (ckScri) { // object is loaded from file ...
4084                // read header
4085                uint32_t headerSize = ckScri->ReadUint32();
4086                Compression = (Compression_t) ckScri->ReadUint32();
4087                Encoding    = (Encoding_t) ckScri->ReadUint32();
4088                Language    = (Language_t) ckScri->ReadUint32();
4089                Bypass      = (Language_t) ckScri->ReadUint32() & 1;
4090                crc         = ckScri->ReadUint32();
4091                uint32_t nameSize = ckScri->ReadUint32();
4092                Name.resize(nameSize, ' ');
4093                for (int i = 0; i < nameSize; ++i)
4094                    Name[i] = ckScri->ReadUint8();
4095                // to handle potential future extensions of the header
4096                ckScri->SetPos(sizeof(int32_t) + headerSize);
4097                // read actual script data
4098                uint32_t scriptSize = ckScri->GetSize() - ckScri->GetPos();
4099                data.resize(scriptSize);
4100                for (int i = 0; i < scriptSize; ++i)
4101                    data[i] = ckScri->ReadUint8();
4102            } else { // this is a new script object, so just initialize it as such ...
4103                Compression = COMPRESSION_NONE;
4104                Encoding = ENCODING_ASCII;
4105                Language = LANGUAGE_NKSP;
4106                Bypass   = false;
4107                crc      = 0;
4108                Name     = "Unnamed Script";
4109            }
4110        }
4111    
4112        Script::~Script() {
4113        }
4114    
4115        /**
4116         * Returns the current script (i.e. as source code) in text format.
4117         */
4118        String Script::GetScriptAsText() {
4119            String s;
4120            s.resize(data.size(), ' ');
4121            memcpy(&s[0], &data[0], data.size());
4122            return s;
4123        }
4124    
4125        /**
4126         * Replaces the current script with the new script source code text given
4127         * by @a text.
4128         *
4129         * @param text - new script source code
4130         */
4131        void Script::SetScriptAsText(const String& text) {
4132            data.resize(text.size());
4133            memcpy(&data[0], &text[0], text.size());
4134        }
4135    
4136        /**
4137         * Apply this script to the respective RIFF chunks. You have to call
4138         * File::Save() to make changes persistent.
4139         *
4140         * Usually there is absolutely no need to call this method explicitly.
4141         * It will be called automatically when File::Save() was called.
4142         *
4143         * @param pProgress - callback function for progress notification
4144         */
4145        void Script::UpdateChunks(progress_t* pProgress) {
4146            // recalculate CRC32 check sum
4147            __resetCRC(crc);
4148            __calculateCRC(&data[0], data.size(), crc);
4149            __encodeCRC(crc);
4150            // make sure chunk exists and has the required size
4151            const int chunkSize = 7*sizeof(int32_t) + Name.size() + data.size();
4152            if (!pChunk) pChunk = pGroup->pList->AddSubChunk(CHUNK_ID_SCRI, chunkSize);
4153            else pChunk->Resize(chunkSize);
4154            // fill the chunk data to be written to disk
4155            uint8_t* pData = (uint8_t*) pChunk->LoadChunkData();
4156            int pos = 0;
4157            store32(&pData[pos], 6*sizeof(int32_t) + Name.size()); // total header size
4158            pos += sizeof(int32_t);
4159            store32(&pData[pos], Compression);
4160            pos += sizeof(int32_t);
4161            store32(&pData[pos], Encoding);
4162            pos += sizeof(int32_t);
4163            store32(&pData[pos], Language);
4164            pos += sizeof(int32_t);
4165            store32(&pData[pos], Bypass ? 1 : 0);
4166            pos += sizeof(int32_t);
4167            store32(&pData[pos], crc);
4168            pos += sizeof(int32_t);
4169            store32(&pData[pos], Name.size());
4170            pos += sizeof(int32_t);
4171            for (int i = 0; i < Name.size(); ++i, ++pos)
4172                pData[pos] = Name[i];
4173            for (int i = 0; i < data.size(); ++i, ++pos)
4174                pData[pos] = data[i];
4175        }
4176    
4177        /**
4178         * Move this script from its current ScriptGroup to another ScriptGroup
4179         * given by @a pGroup.
4180         *
4181         * @param pGroup - script's new group
4182         */
4183        void Script::SetGroup(ScriptGroup* pGroup) {
4184            if (this->pGroup = pGroup) return;
4185            if (pChunk)
4186                pChunk->GetParent()->MoveSubChunk(pChunk, pGroup->pList);
4187            this->pGroup = pGroup;
4188        }
4189    
4190        /**
4191         * Returns the script group this script currently belongs to. Each script
4192         * is a member of exactly one ScriptGroup.
4193         *
4194         * @returns current script group
4195         */
4196        ScriptGroup* Script::GetGroup() const {
4197            return pGroup;
4198        }
4199    
4200        void Script::RemoveAllScriptReferences() {
4201            File* pFile = pGroup->pFile;
4202            for (int i = 0; pFile->GetInstrument(i); ++i) {
4203                Instrument* instr = pFile->GetInstrument(i);
4204                instr->RemoveScript(this);
4205            }
4206        }
4207    
4208    // *************** ScriptGroup ***************
4209    // *
4210    
4211        ScriptGroup::ScriptGroup(File* file, RIFF::List* lstRTIS) {
4212            pFile = file;
4213            pList = lstRTIS;
4214            pScripts = NULL;
4215            if (lstRTIS) {
4216                RIFF::Chunk* ckName = lstRTIS->GetSubChunk(CHUNK_ID_LSNM);
4217                ::LoadString(ckName, Name);
4218            } else {
4219                Name = "Default Group";
4220            }
4221        }
4222    
4223        ScriptGroup::~ScriptGroup() {
4224            if (pScripts) {
4225                std::list<Script*>::iterator iter = pScripts->begin();
4226                std::list<Script*>::iterator end  = pScripts->end();
4227                while (iter != end) {
4228                    delete *iter;
4229                    ++iter;
4230                }
4231                delete pScripts;
4232            }
4233        }
4234    
4235        /**
4236         * Apply this script group to the respective RIFF chunks. You have to call
4237         * File::Save() to make changes persistent.
4238         *
4239         * Usually there is absolutely no need to call this method explicitly.
4240         * It will be called automatically when File::Save() was called.
4241         *
4242         * @param pProgress - callback function for progress notification
4243         */
4244        void ScriptGroup::UpdateChunks(progress_t* pProgress) {
4245            if (pScripts) {
4246                if (!pList)
4247                    pList = pFile->pRIFF->GetSubList(LIST_TYPE_3LS)->AddSubList(LIST_TYPE_RTIS);
4248    
4249                // now store the name of this group as <LSNM> chunk as subchunk of the <RTIS> list chunk
4250                ::SaveString(CHUNK_ID_LSNM, NULL, pList, Name, String("Unnamed Group"), true, 64);
4251    
4252                for (std::list<Script*>::iterator it = pScripts->begin();
4253                     it != pScripts->end(); ++it)
4254                {
4255                    (*it)->UpdateChunks(pProgress);
4256                }
4257            }
4258        }
4259    
4260        /** @brief Get instrument script.
4261         *
4262         * Returns the real-time instrument script with the given index.
4263         *
4264         * @param index - number of the sought script (0..n)
4265         * @returns sought script or NULL if there's no such script
4266         */
4267        Script* ScriptGroup::GetScript(uint index) {
4268            if (!pScripts) LoadScripts();
4269            std::list<Script*>::iterator it = pScripts->begin();
4270            for (uint i = 0; it != pScripts->end(); ++i, ++it)
4271                if (i == index) return *it;
4272            return NULL;
4273        }
4274    
4275        /** @brief Add new instrument script.
4276         *
4277         * Adds a new real-time instrument script to the file. The script is not
4278         * actually used / executed unless it is referenced by an instrument to be
4279         * used. This is similar to samples, which you can add to a file, without
4280         * an instrument necessarily actually using it.
4281         *
4282         * You have to call Save() to make this persistent to the file.
4283         *
4284         * @return new empty script object
4285         */
4286        Script* ScriptGroup::AddScript() {
4287            if (!pScripts) LoadScripts();
4288            Script* pScript = new Script(this, NULL);
4289            pScripts->push_back(pScript);
4290            return pScript;
4291        }
4292    
4293        /** @brief Delete an instrument script.
4294         *
4295         * This will delete the given real-time instrument script. References of
4296         * instruments that are using that script will be removed accordingly.
4297         *
4298         * You have to call Save() to make this persistent to the file.
4299         *
4300         * @param pScript - script to delete
4301         * @throws gig::Exception if given script could not be found
4302         */
4303        void ScriptGroup::DeleteScript(Script* pScript) {
4304            if (!pScripts) LoadScripts();
4305            std::list<Script*>::iterator iter =
4306                find(pScripts->begin(), pScripts->end(), pScript);
4307            if (iter == pScripts->end())
4308                throw gig::Exception("Could not delete script, could not find given script");
4309            pScripts->erase(iter);
4310            pScript->RemoveAllScriptReferences();
4311            if (pScript->pChunk)
4312                pScript->pChunk->GetParent()->DeleteSubChunk(pScript->pChunk);
4313            delete pScript;
4314        }
4315    
4316        void ScriptGroup::LoadScripts() {
4317            if (pScripts) return;
4318            pScripts = new std::list<Script*>;
4319            if (!pList) return;
4320    
4321            for (RIFF::Chunk* ck = pList->GetFirstSubChunk(); ck;
4322                 ck = pList->GetNextSubChunk())
4323            {
4324                if (ck->GetChunkID() == CHUNK_ID_SCRI) {
4325                    pScripts->push_back(new Script(this, ck));
4326                }
4327            }
4328        }
4329    
4330  // *************** Instrument ***************  // *************** Instrument ***************
4331  // *  // *
4332    
# Line 4041  namespace { Line 4349  namespace {
4349          DimensionKeyRange.high = 0;          DimensionKeyRange.high = 0;
4350          pMidiRules = new MidiRule*[3];          pMidiRules = new MidiRule*[3];
4351          pMidiRules[0] = NULL;          pMidiRules[0] = NULL;
4352            pScriptRefs = NULL;
4353    
4354          // Loading          // Loading
4355          RIFF::List* lart = insList->GetSubList(LIST_TYPE_LART);          RIFF::List* lart = insList->GetSubList(LIST_TYPE_LART);
# Line 4101  namespace { Line 4410  namespace {
4410              }              }
4411          }          }
4412    
4413            // own gig format extensions
4414            RIFF::List* lst3LS = insList->GetSubList(LIST_TYPE_3LS);
4415            if (lst3LS) {
4416                RIFF::Chunk* ckSCSL = lst3LS->GetSubChunk(CHUNK_ID_SCSL);
4417                if (ckSCSL) {
4418                    int headerSize = ckSCSL->ReadUint32();
4419                    int slotCount  = ckSCSL->ReadUint32();
4420                    if (slotCount) {
4421                        int slotSize  = ckSCSL->ReadUint32();
4422                        ckSCSL->SetPos(headerSize); // in case of future header extensions
4423                        int unknownSpace = slotSize - 2*sizeof(uint32_t); // in case of future slot extensions
4424                        for (int i = 0; i < slotCount; ++i) {
4425                            _ScriptPooolEntry e;
4426                            e.fileOffset = ckSCSL->ReadUint32();
4427                            e.bypass     = ckSCSL->ReadUint32() & 1;
4428                            if (unknownSpace) ckSCSL->SetPos(unknownSpace, RIFF::stream_curpos); // in case of future extensions
4429                            scriptPoolFileOffsets.push_back(e);
4430                        }
4431                    }
4432                }
4433            }
4434    
4435          __notify_progress(pProgress, 1.0f); // notify done          __notify_progress(pProgress, 1.0f); // notify done
4436      }      }
4437    
# Line 4121  namespace { Line 4452  namespace {
4452              delete pMidiRules[i];              delete pMidiRules[i];
4453          }          }
4454          delete[] pMidiRules;          delete[] pMidiRules;
4455            if (pScriptRefs) delete pScriptRefs;
4456      }      }
4457    
4458      /**      /**
# Line 4130  namespace { Line 4462  namespace {
4462       * Usually there is absolutely no need to call this method explicitly.       * Usually there is absolutely no need to call this method explicitly.
4463       * It will be called automatically when File::Save() was called.       * It will be called automatically when File::Save() was called.
4464       *       *
4465         * @param pProgress - callback function for progress notification
4466       * @throws gig::Exception if samples cannot be dereferenced       * @throws gig::Exception if samples cannot be dereferenced
4467       */       */
4468      void Instrument::UpdateChunks() {      void Instrument::UpdateChunks(progress_t* pProgress) {
4469          // first update base classes' chunks          // first update base classes' chunks
4470          DLS::Instrument::UpdateChunks();          DLS::Instrument::UpdateChunks(pProgress);
4471    
4472          // update Regions' chunks          // update Regions' chunks
4473          {          {
4474              RegionList::iterator iter = pRegions->begin();              RegionList::iterator iter = pRegions->begin();
4475              RegionList::iterator end  = pRegions->end();              RegionList::iterator end  = pRegions->end();
4476              for (; iter != end; ++iter)              for (; iter != end; ++iter)
4477                  (*iter)->UpdateChunks();                  (*iter)->UpdateChunks(pProgress);
4478          }          }
4479    
4480          // make sure 'lart' RIFF list chunk exists          // make sure 'lart' RIFF list chunk exists
# Line 4176  namespace { Line 4509  namespace {
4509                  pMidiRules[i]->UpdateChunks(pData);                  pMidiRules[i]->UpdateChunks(pData);
4510              }              }
4511          }          }
4512    
4513            // own gig format extensions
4514           if (ScriptSlotCount()) {
4515               // make sure we have converted the original loaded script file
4516               // offsets into valid Script object pointers
4517               LoadScripts();
4518    
4519               RIFF::List* lst3LS = pCkInstrument->GetSubList(LIST_TYPE_3LS);
4520               if (!lst3LS) lst3LS = pCkInstrument->AddSubList(LIST_TYPE_3LS);
4521               const int slotCount = pScriptRefs->size();
4522               const int headerSize = 3 * sizeof(uint32_t);
4523               const int slotSize  = 2 * sizeof(uint32_t);
4524               const int totalChunkSize = headerSize + slotCount * slotSize;
4525               RIFF::Chunk* ckSCSL = lst3LS->GetSubChunk(CHUNK_ID_SCSL);
4526               if (!ckSCSL) ckSCSL = lst3LS->AddSubChunk(CHUNK_ID_SCSL, totalChunkSize);
4527               else ckSCSL->Resize(totalChunkSize);
4528               uint8_t* pData = (uint8_t*) ckSCSL->LoadChunkData();
4529               int pos = 0;
4530               store32(&pData[pos], headerSize);
4531               pos += sizeof(uint32_t);
4532               store32(&pData[pos], slotCount);
4533               pos += sizeof(uint32_t);
4534               store32(&pData[pos], slotSize);
4535               pos += sizeof(uint32_t);
4536               for (int i = 0; i < slotCount; ++i) {
4537                   // arbitrary value, the actual file offset will be updated in
4538                   // UpdateScriptFileOffsets() after the file has been resized
4539                   int bogusFileOffset = 0;
4540                   store32(&pData[pos], bogusFileOffset);
4541                   pos += sizeof(uint32_t);
4542                   store32(&pData[pos], (*pScriptRefs)[i].bypass ? 1 : 0);
4543                   pos += sizeof(uint32_t);
4544               }
4545           } else {
4546               // no script slots, so get rid of any LS custom RIFF chunks (if any)
4547               RIFF::List* lst3LS = pCkInstrument->GetSubList(LIST_TYPE_3LS);
4548               if (lst3LS) pCkInstrument->DeleteSubChunk(lst3LS);
4549           }
4550        }
4551    
4552        void Instrument::UpdateScriptFileOffsets() {
4553           // own gig format extensions
4554           if (pScriptRefs && pScriptRefs->size() > 0) {
4555               RIFF::List* lst3LS = pCkInstrument->GetSubList(LIST_TYPE_3LS);
4556               RIFF::Chunk* ckSCSL = lst3LS->GetSubChunk(CHUNK_ID_SCSL);
4557               const int slotCount = pScriptRefs->size();
4558               const int headerSize = 3 * sizeof(uint32_t);
4559               ckSCSL->SetPos(headerSize);
4560               for (int i = 0; i < slotCount; ++i) {
4561                   uint32_t fileOffset =
4562                        (*pScriptRefs)[i].script->pChunk->GetFilePos() -
4563                        (*pScriptRefs)[i].script->pChunk->GetPos() -
4564                        CHUNK_HEADER_SIZE;
4565                   ckSCSL->WriteUint32(&fileOffset);
4566                   // jump over flags entry (containing the bypass flag)
4567                   ckSCSL->SetPos(sizeof(uint32_t), RIFF::stream_curpos);
4568               }
4569           }        
4570      }      }
4571    
4572      /**      /**
# Line 4307  namespace { Line 4698  namespace {
4698          pMidiRules[i] = 0;          pMidiRules[i] = 0;
4699      }      }
4700    
4701        void Instrument::LoadScripts() {
4702            if (pScriptRefs) return;
4703            pScriptRefs = new std::vector<_ScriptPooolRef>;
4704            if (scriptPoolFileOffsets.empty()) return;
4705            File* pFile = (File*) GetParent();
4706            for (uint k = 0; k < scriptPoolFileOffsets.size(); ++k) {
4707                uint32_t soughtOffset = scriptPoolFileOffsets[k].fileOffset;
4708                for (uint i = 0; pFile->GetScriptGroup(i); ++i) {
4709                    ScriptGroup* group = pFile->GetScriptGroup(i);
4710                    for (uint s = 0; group->GetScript(s); ++s) {
4711                        Script* script = group->GetScript(s);
4712                        if (script->pChunk) {
4713                            uint32_t offset = script->pChunk->GetFilePos() -
4714                                              script->pChunk->GetPos() -
4715                                              CHUNK_HEADER_SIZE;
4716                            if (offset == soughtOffset)
4717                            {
4718                                _ScriptPooolRef ref;
4719                                ref.script = script;
4720                                ref.bypass = scriptPoolFileOffsets[k].bypass;
4721                                pScriptRefs->push_back(ref);
4722                                break;
4723                            }
4724                        }
4725                    }
4726                }
4727            }
4728            // we don't need that anymore
4729            scriptPoolFileOffsets.clear();
4730        }
4731    
4732        /** @brief Get instrument script (gig format extension).
4733         *
4734         * Returns the real-time instrument script of instrument script slot
4735         * @a index.
4736         *
4737         * @note This is an own format extension which did not exist i.e. in the
4738         * GigaStudio 4 software. It will currently only work with LinuxSampler and
4739         * gigedit.
4740         *
4741         * @param index - instrument script slot index
4742         * @returns script or NULL if index is out of bounds
4743         */
4744        Script* Instrument::GetScriptOfSlot(uint index) {
4745            LoadScripts();
4746            if (index >= pScriptRefs->size()) return NULL;
4747            return pScriptRefs->at(index).script;
4748        }
4749    
4750        /** @brief Add new instrument script slot (gig format extension).
4751         *
4752         * Add the given real-time instrument script reference to this instrument,
4753         * which shall be executed by the sampler for for this instrument. The
4754         * script will be added to the end of the script list of this instrument.
4755         * The positions of the scripts in the Instrument's Script list are
4756         * relevant, because they define in which order they shall be executed by
4757         * the sampler. For this reason it is also legal to add the same script
4758         * twice to an instrument, for example you might have a script called
4759         * "MyFilter" which performs an event filter task, and you might have
4760         * another script called "MyNoteTrigger" which triggers new notes, then you
4761         * might for example have the following list of scripts on the instrument:
4762         *
4763         * 1. Script "MyFilter"
4764         * 2. Script "MyNoteTrigger"
4765         * 3. Script "MyFilter"
4766         *
4767         * Which would make sense, because the 2nd script launched new events, which
4768         * you might need to filter as well.
4769         *
4770         * There are two ways to disable / "bypass" scripts. You can either disable
4771         * a script locally for the respective script slot on an instrument (i.e. by
4772         * passing @c false to the 2nd argument of this method, or by calling
4773         * SetScriptBypassed()). Or you can disable a script globally for all slots
4774         * and all instruments by setting Script::Bypass.
4775         *
4776         * @note This is an own format extension which did not exist i.e. in the
4777         * GigaStudio 4 software. It will currently only work with LinuxSampler and
4778         * gigedit.
4779         *
4780         * @param pScript - script that shall be executed for this instrument
4781         * @param bypass  - if enabled, the sampler shall skip executing this
4782         *                  script (in the respective list position)
4783         * @see SetScriptBypassed()
4784         */
4785        void Instrument::AddScriptSlot(Script* pScript, bool bypass) {
4786            LoadScripts();
4787            _ScriptPooolRef ref = { pScript, bypass };
4788            pScriptRefs->push_back(ref);
4789        }
4790    
4791        /** @brief Flip two script slots with each other (gig format extension).
4792         *
4793         * Swaps the position of the two given scripts in the Instrument's Script
4794         * list. The positions of the scripts in the Instrument's Script list are
4795         * relevant, because they define in which order they shall be executed by
4796         * the sampler.
4797         *
4798         * @note This is an own format extension which did not exist i.e. in the
4799         * GigaStudio 4 software. It will currently only work with LinuxSampler and
4800         * gigedit.
4801         *
4802         * @param index1 - index of the first script slot to swap
4803         * @param index2 - index of the second script slot to swap
4804         */
4805        void Instrument::SwapScriptSlots(uint index1, uint index2) {
4806            LoadScripts();
4807            if (index1 >= pScriptRefs->size() || index2 >= pScriptRefs->size())
4808                return;
4809            _ScriptPooolRef tmp = (*pScriptRefs)[index1];
4810            (*pScriptRefs)[index1] = (*pScriptRefs)[index2];
4811            (*pScriptRefs)[index2] = tmp;
4812        }
4813    
4814        /** @brief Remove script slot.
4815         *
4816         * Removes the script slot with the given slot index.
4817         *
4818         * @param index - index of script slot to remove
4819         */
4820        void Instrument::RemoveScriptSlot(uint index) {
4821            LoadScripts();
4822            if (index >= pScriptRefs->size()) return;
4823            pScriptRefs->erase( pScriptRefs->begin() + index );
4824        }
4825    
4826        /** @brief Remove reference to given Script (gig format extension).
4827         *
4828         * This will remove all script slots on the instrument which are referencing
4829         * the given script.
4830         *
4831         * @note This is an own format extension which did not exist i.e. in the
4832         * GigaStudio 4 software. It will currently only work with LinuxSampler and
4833         * gigedit.
4834         *
4835         * @param pScript - script reference to remove from this instrument
4836         * @see RemoveScriptSlot()
4837         */
4838        void Instrument::RemoveScript(Script* pScript) {
4839            LoadScripts();
4840            for (int i = pScriptRefs->size() - 1; i >= 0; --i) {
4841                if ((*pScriptRefs)[i].script == pScript) {
4842                    pScriptRefs->erase( pScriptRefs->begin() + i );
4843                }
4844            }
4845        }
4846    
4847        /** @brief Instrument's amount of script slots.
4848         *
4849         * This method returns the amount of script slots this instrument currently
4850         * uses.
4851         *
4852         * A script slot is a reference of a real-time instrument script to be
4853         * executed by the sampler. The scripts will be executed by the sampler in
4854         * sequence of the slots. One (same) script may be referenced multiple
4855         * times in different slots.
4856         *
4857         * @note This is an own format extension which did not exist i.e. in the
4858         * GigaStudio 4 software. It will currently only work with LinuxSampler and
4859         * gigedit.
4860         */
4861        uint Instrument::ScriptSlotCount() const {
4862            return pScriptRefs ? pScriptRefs->size() : scriptPoolFileOffsets.size();
4863        }
4864    
4865        /** @brief Whether script execution shall be skipped.
4866         *
4867         * Defines locally for the Script reference slot in the Instrument's Script
4868         * list, whether the script shall be skipped by the sampler regarding
4869         * execution.
4870         *
4871         * It is also possible to ignore exeuction of the script globally, for all
4872         * slots and for all instruments by setting Script::Bypass.
4873         *
4874         * @note This is an own format extension which did not exist i.e. in the
4875         * GigaStudio 4 software. It will currently only work with LinuxSampler and
4876         * gigedit.
4877         *
4878         * @param index - index of the script slot on this instrument
4879         * @see Script::Bypass
4880         */
4881        bool Instrument::IsScriptSlotBypassed(uint index) {
4882            if (index >= ScriptSlotCount()) return false;
4883            return pScriptRefs ? pScriptRefs->at(index).bypass
4884                               : scriptPoolFileOffsets.at(index).bypass;
4885            
4886        }
4887    
4888        /** @brief Defines whether execution shall be skipped.
4889         *
4890         * You can call this method to define locally whether or whether not the
4891         * given script slot shall be executed by the sampler.
4892         *
4893         * @note This is an own format extension which did not exist i.e. in the
4894         * GigaStudio 4 software. It will currently only work with LinuxSampler and
4895         * gigedit.
4896         *
4897         * @param index - script slot index on this instrument
4898         * @param bBypass - if true, the script slot will be skipped by the sampler
4899         * @see Script::Bypass
4900         */
4901        void Instrument::SetScriptSlotBypassed(uint index, bool bBypass) {
4902            if (index >= ScriptSlotCount()) return;
4903            if (pScriptRefs)
4904                pScriptRefs->at(index).bypass = bBypass;
4905            else
4906                scriptPoolFileOffsets.at(index).bypass = bBypass;
4907        }
4908    
4909      /**      /**
4910       * Make a (semi) deep copy of the Instrument object given by @a orig       * Make a (semi) deep copy of the Instrument object given by @a orig
4911       * and assign it to this object.       * and assign it to this object.
# Line 4340  namespace { Line 4939  namespace {
4939          PitchbendRange = orig->PitchbendRange;          PitchbendRange = orig->PitchbendRange;
4940          PianoReleaseMode = orig->PianoReleaseMode;          PianoReleaseMode = orig->PianoReleaseMode;
4941          DimensionKeyRange = orig->DimensionKeyRange;          DimensionKeyRange = orig->DimensionKeyRange;
4942            scriptPoolFileOffsets = orig->scriptPoolFileOffsets;
4943            pScriptRefs = orig->pScriptRefs;
4944                    
4945          // free old midi rules          // free old midi rules
4946          for (int i = 0 ; pMidiRules[i] ; i++) {          for (int i = 0 ; pMidiRules[i] ; i++) {
# Line 4394  namespace { Line 4995  namespace {
4995       *       *
4996       * Usually there is absolutely no need to call this method explicitly.       * Usually there is absolutely no need to call this method explicitly.
4997       * It will be called automatically when File::Save() was called.       * It will be called automatically when File::Save() was called.
4998         *
4999         * @param pProgress - callback function for progress notification
5000       */       */
5001      void Group::UpdateChunks() {      void Group::UpdateChunks(progress_t* pProgress) {
5002          // make sure <3gri> and <3gnl> list chunks exist          // make sure <3gri> and <3gnl> list chunks exist
5003          RIFF::List* _3gri = pFile->pRIFF->GetSubList(LIST_TYPE_3GRI);          RIFF::List* _3gri = pFile->pRIFF->GetSubList(LIST_TYPE_3GRI);
5004          if (!_3gri) {          if (!_3gri) {
# Line 4525  namespace { Line 5128  namespace {
5128          bAutoLoad = true;          bAutoLoad = true;
5129          *pVersion = VERSION_3;          *pVersion = VERSION_3;
5130          pGroups = NULL;          pGroups = NULL;
5131            pScriptGroups = NULL;
5132          pInfo->SetFixedStringLengths(_FileFixedStringLengths);          pInfo->SetFixedStringLengths(_FileFixedStringLengths);
5133          pInfo->ArchivalLocation = String(256, ' ');          pInfo->ArchivalLocation = String(256, ' ');
5134    
# Line 4540  namespace { Line 5144  namespace {
5144      File::File(RIFF::File* pRIFF) : DLS::File(pRIFF) {      File::File(RIFF::File* pRIFF) : DLS::File(pRIFF) {
5145          bAutoLoad = true;          bAutoLoad = true;
5146          pGroups = NULL;          pGroups = NULL;
5147            pScriptGroups = NULL;
5148          pInfo->SetFixedStringLengths(_FileFixedStringLengths);          pInfo->SetFixedStringLengths(_FileFixedStringLengths);
5149      }      }
5150    
# Line 4553  namespace { Line 5158  namespace {
5158              }              }
5159              delete pGroups;              delete pGroups;
5160          }          }
5161            if (pScriptGroups) {
5162                std::list<ScriptGroup*>::iterator iter = pScriptGroups->begin();
5163                std::list<ScriptGroup*>::iterator end  = pScriptGroups->end();
5164                while (iter != end) {
5165                    delete *iter;
5166                    ++iter;
5167                }
5168                delete pScriptGroups;
5169            }
5170      }      }
5171    
5172      Sample* File::GetFirstSample(progress_t* pProgress) {      Sample* File::GetFirstSample(progress_t* pProgress) {
# Line 5065  namespace { Line 5679  namespace {
5679          }          }
5680      }      }
5681    
5682        /** @brief Get instrument script group (by index).
5683         *
5684         * Returns the real-time instrument script group with the given index.
5685         *
5686         * @param index - number of the sought group (0..n)
5687         * @returns sought script group or NULL if there's no such group
5688         */
5689        ScriptGroup* File::GetScriptGroup(uint index) {
5690            if (!pScriptGroups) LoadScriptGroups();
5691            std::list<ScriptGroup*>::iterator it = pScriptGroups->begin();
5692            for (uint i = 0; it != pScriptGroups->end(); ++i, ++it)
5693                if (i == index) return *it;
5694            return NULL;
5695        }
5696    
5697        /** @brief Get instrument script group (by name).
5698         *
5699         * Returns the first real-time instrument script group found with the given
5700         * group name. Note that group names may not necessarily be unique.
5701         *
5702         * @param name - name of the sought script group
5703         * @returns sought script group or NULL if there's no such group
5704         */
5705        ScriptGroup* File::GetScriptGroup(const String& name) {
5706            if (!pScriptGroups) LoadScriptGroups();
5707            std::list<ScriptGroup*>::iterator it = pScriptGroups->begin();
5708            for (uint i = 0; it != pScriptGroups->end(); ++i, ++it)
5709                if ((*it)->Name == name) return *it;
5710            return NULL;
5711        }
5712    
5713        /** @brief Add new instrument script group.
5714         *
5715         * Adds a new, empty real-time instrument script group to the file.
5716         *
5717         * You have to call Save() to make this persistent to the file.
5718         *
5719         * @return new empty script group
5720         */
5721        ScriptGroup* File::AddScriptGroup() {
5722            if (!pScriptGroups) LoadScriptGroups();
5723            ScriptGroup* pScriptGroup = new ScriptGroup(this, NULL);
5724            pScriptGroups->push_back(pScriptGroup);
5725            return pScriptGroup;
5726        }
5727    
5728        /** @brief Delete an instrument script group.
5729         *
5730         * This will delete the given real-time instrument script group and all its
5731         * instrument scripts it contains. References inside instruments that are
5732         * using the deleted scripts will be removed from the respective instruments
5733         * accordingly.
5734         *
5735         * You have to call Save() to make this persistent to the file.
5736         *
5737         * @param pScriptGroup - script group to delete
5738         * @throws gig::Exception if given script group could not be found
5739         */
5740        void File::DeleteScriptGroup(ScriptGroup* pScriptGroup) {
5741            if (!pScriptGroups) LoadScriptGroups();
5742            std::list<ScriptGroup*>::iterator iter =
5743                find(pScriptGroups->begin(), pScriptGroups->end(), pScriptGroup);
5744            if (iter == pScriptGroups->end())
5745                throw gig::Exception("Could not delete script group, could not find given script group");
5746            pScriptGroups->erase(iter);
5747            for (int i = 0; pScriptGroup->GetScript(i); ++i)
5748                pScriptGroup->DeleteScript(pScriptGroup->GetScript(i));
5749            if (pScriptGroup->pList)
5750                pScriptGroup->pList->GetParent()->DeleteSubChunk(pScriptGroup->pList);
5751            delete pScriptGroup;
5752        }
5753    
5754        void File::LoadScriptGroups() {
5755            if (pScriptGroups) return;
5756            pScriptGroups = new std::list<ScriptGroup*>;
5757            RIFF::List* lstLS = pRIFF->GetSubList(LIST_TYPE_3LS);
5758            if (lstLS) {
5759                for (RIFF::List* lst = lstLS->GetFirstSubList(); lst;
5760                     lst = lstLS->GetNextSubList())
5761                {
5762                    if (lst->GetListType() == LIST_TYPE_RTIS) {
5763                        pScriptGroups->push_back(new ScriptGroup(this, lst));
5764                    }
5765                }
5766            }
5767        }
5768    
5769      /**      /**
5770       * Apply all the gig file's current instruments, samples, groups and settings       * Apply all the gig file's current instruments, samples, groups and settings
5771       * to the respective RIFF chunks. You have to call Save() to make changes       * to the respective RIFF chunks. You have to call Save() to make changes
# Line 5073  namespace { Line 5774  namespace {
5774       * Usually there is absolutely no need to call this method explicitly.       * Usually there is absolutely no need to call this method explicitly.
5775       * It will be called automatically when File::Save() was called.       * It will be called automatically when File::Save() was called.
5776       *       *
5777         * @param pProgress - callback function for progress notification
5778       * @throws Exception - on errors       * @throws Exception - on errors
5779       */       */
5780      void File::UpdateChunks() {      void File::UpdateChunks(progress_t* pProgress) {
5781          bool newFile = pRIFF->GetSubList(LIST_TYPE_INFO) == NULL;          bool newFile = pRIFF->GetSubList(LIST_TYPE_INFO) == NULL;
5782    
5783          b64BitWavePoolOffsets = pVersion && pVersion->major == 3;          b64BitWavePoolOffsets = pVersion && pVersion->major == 3;
5784    
5785            // update own gig format extension chunks
5786            // (not part of the GigaStudio 4 format)
5787            //
5788            // This must be performed before writing the chunks for instruments,
5789            // because the instruments' script slots will write the file offsets
5790            // of the respective instrument script chunk as reference.
5791            if (pScriptGroups) {
5792                RIFF::List* lst3LS = pRIFF->GetSubList(LIST_TYPE_3LS);
5793                if (pScriptGroups->empty()) {
5794                    if (lst3LS) pRIFF->DeleteSubChunk(lst3LS);
5795                } else {
5796                    if (!lst3LS) lst3LS = pRIFF->AddSubList(LIST_TYPE_3LS);
5797    
5798                    // Update instrument script (group) chunks.
5799    
5800                    for (std::list<ScriptGroup*>::iterator it = pScriptGroups->begin();
5801                         it != pScriptGroups->end(); ++it)
5802                    {
5803                        (*it)->UpdateChunks(pProgress);
5804                    }
5805                }
5806            }
5807    
5808          // first update base class's chunks          // first update base class's chunks
5809          DLS::File::UpdateChunks();          DLS::File::UpdateChunks(pProgress);
5810    
5811          if (newFile) {          if (newFile) {
5812              // INFO was added by Resource::UpdateChunks - make sure it              // INFO was added by Resource::UpdateChunks - make sure it
# Line 5118  namespace { Line 5843  namespace {
5843              std::list<Group*>::iterator iter = pGroups->begin();              std::list<Group*>::iterator iter = pGroups->begin();
5844              std::list<Group*>::iterator end  = pGroups->end();              std::list<Group*>::iterator end  = pGroups->end();
5845              for (; iter != end; ++iter) {              for (; iter != end; ++iter) {
5846                  (*iter)->UpdateChunks();                  (*iter)->UpdateChunks(pProgress);
5847              }              }
5848          }          }
5849    
# Line 5250  namespace { Line 5975  namespace {
5975              if (einf && pVersion && pVersion->major == 3) pRIFF->MoveSubChunk(_3crc, einf);              if (einf && pVersion && pVersion->major == 3) pRIFF->MoveSubChunk(_3crc, einf);
5976          }          }
5977      }      }
5978        
5979        void File::UpdateFileOffsets() {
5980            DLS::File::UpdateFileOffsets();
5981    
5982            for (Instrument* instrument = GetFirstInstrument(); instrument;
5983                 instrument = GetNextInstrument())
5984            {
5985                instrument->UpdateScriptFileOffsets();
5986            }
5987        }
5988    
5989      /**      /**
5990       * Enable / disable automatic loading. By default this properyt is       * Enable / disable automatic loading. By default this properyt is
Legend:
Removed from v.2555  
changed lines
  Added in v.2682
  ViewVC Help
Powered by ViewVC