/[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 3730 by schoenebeck, Wed Jan 22 15:48:32 2020 UTC revision 3731 by schoenebeck, Sat Feb 1 15:35:07 2020 UTC
# Line 4994  namespace { Line 4994  namespace {
4994          // own gig format extensions          // own gig format extensions
4995          RIFF::List* lst3LS = insList->GetSubList(LIST_TYPE_3LS);          RIFF::List* lst3LS = insList->GetSubList(LIST_TYPE_3LS);
4996          if (lst3LS) {          if (lst3LS) {
4997                // script slots (that is references to instrument scripts)
4998              RIFF::Chunk* ckSCSL = lst3LS->GetSubChunk(CHUNK_ID_SCSL);              RIFF::Chunk* ckSCSL = lst3LS->GetSubChunk(CHUNK_ID_SCSL);
4999              if (ckSCSL) {              if (ckSCSL) {
5000                  ckSCSL->SetPos(0);                  ckSCSL->SetPos(0);
# Line 5013  namespace { Line 5014  namespace {
5014                      }                      }
5015                  }                  }
5016              }              }
5017    
5018                // overridden script 'patch' variables
5019                RIFF::Chunk* ckSCPV = lst3LS->GetSubChunk(CHUNK_ID_SCPV);
5020                if (ckSCPV) {
5021                    ckSCPV->SetPos(0);
5022    
5023                    int nScripts = ckSCPV->ReadUint32();
5024                    for (int iScript = 0; iScript < nScripts; ++iScript) {
5025                        _UUID uuid;
5026                        for (int i = 0; i < 16; ++i)
5027                            uuid[i] = ckSCPV->ReadUint8();
5028                        uint slot = ckSCPV->ReadUint32();
5029                        ckSCPV->ReadUint32(); // unused, reserved 32 bit
5030                        int nVars = ckSCPV->ReadUint32();
5031                        for (int iVar = 0; iVar < nVars; ++iVar) {
5032                            uint8_t type = ckSCPV->ReadUint8();
5033                            ckSCPV->ReadUint8();  // unused, reserved byte
5034                            int blobSize = ckSCPV->ReadUint16();
5035                            RIFF::file_offset_t pos = ckSCPV->GetPos();
5036                            // assuming 1st bit is set in 'type', otherwise blob not
5037                            // supported for decoding
5038                            if (type & 1) {
5039                                String name, value;
5040                                int len = ckSCPV->ReadUint16();
5041                                for (int i = 0; i < len; ++i)
5042                                    name += (char) ckSCPV->ReadUint8();
5043                                len = ckSCPV->ReadUint16();
5044                                for (int i = 0; i < len; ++i)
5045                                    value += (char) ckSCPV->ReadUint8();
5046                                if (!name.empty()) // 'name' should never be empty, but just to be sure
5047                                    scriptVars[uuid][slot][name] = value;
5048                            }
5049                            // also for potential future extensions: seek forward
5050                            // according to blob size
5051                            ckSCPV->SetPos(pos + blobSize);
5052                        }
5053                    }
5054                }
5055          }          }
5056    
5057          if (pProgress)          if (pProgress)
# Line 5104  namespace { Line 5143  namespace {
5143    
5144             RIFF::List* lst3LS = pCkInstrument->GetSubList(LIST_TYPE_3LS);             RIFF::List* lst3LS = pCkInstrument->GetSubList(LIST_TYPE_3LS);
5145             if (!lst3LS) lst3LS = pCkInstrument->AddSubList(LIST_TYPE_3LS);             if (!lst3LS) lst3LS = pCkInstrument->AddSubList(LIST_TYPE_3LS);
5146    
5147               // save script slots (that is references to instrument scripts)
5148             const int slotCount = (int) pScriptRefs->size();             const int slotCount = (int) pScriptRefs->size();
5149             const int headerSize = 3 * sizeof(uint32_t);             const int headerSize = 3 * sizeof(uint32_t);
5150             const int slotSize  = 2 * sizeof(uint32_t);             const int slotSize  = 2 * sizeof(uint32_t);
# Line 5128  namespace { Line 5169  namespace {
5169                 store32(&pData[pos], (*pScriptRefs)[i].bypass ? 1 : 0);                 store32(&pData[pos], (*pScriptRefs)[i].bypass ? 1 : 0);
5170                 pos += sizeof(uint32_t);                 pos += sizeof(uint32_t);
5171             }             }
5172    
5173               // save overridden script 'patch' variables ...
5174    
5175               // the actual 'scriptVars' member variable might contain variables of
5176               // scripts which are currently no longer assigned to any script slot
5177               // of this instrument, we need to get rid of these variables here to
5178               // prevent saving those persistently, however instead of touching the
5179               // member variable 'scriptVars' directly, rather strip a separate
5180               // copy such that the overridden values are not lost during an
5181               // instrument editor session (i.e. if script might be re-assigned)
5182               _VarsByScript vars = stripScriptVars();
5183               if (!vars.empty()) {
5184                   // determine total size required for 'SCPV' RIFF chunk, and the
5185                   // total amount of scripts being overridden (the latter is
5186                   // required because a script might be used on several script
5187                   // slots, hence vars.size() could then not be used here instead)
5188                   size_t totalChunkSize = 4;
5189                   size_t totalScriptsOverridden = 0;
5190                   for (const auto& script : vars) {
5191                       for (const auto& slot : script.second) {
5192                           totalScriptsOverridden++;
5193                           totalChunkSize += 16 + 4 + 4 + 4;
5194                           for (const auto& var : slot.second) {
5195                               totalChunkSize += 4 + 2 + var.first.length() +
5196                                                     2 + var.second.length();
5197                           }
5198                       }
5199                   }
5200    
5201                   // ensure 'SCPV' RIFF chunk exists (with required size)
5202                   RIFF::Chunk* ckSCPV = lst3LS->GetSubChunk(CHUNK_ID_SCPV);
5203                   if (!ckSCPV) ckSCPV = lst3LS->AddSubChunk(CHUNK_ID_SCPV, totalChunkSize);
5204                   else ckSCPV->Resize(totalChunkSize);
5205    
5206                   // store the actual data to 'SCPV' RIFF chunk
5207                   uint8_t* pData = (uint8_t*) ckSCPV->LoadChunkData();
5208                   int pos = 0;
5209                   store32(&pData[pos], (uint32_t) totalScriptsOverridden); // scripts count
5210                   pos += 4;
5211                   for (const auto& script : vars) {
5212                       for (const auto& slot : script.second) {
5213                           for (int i = 0; i < 16; ++i)
5214                               pData[pos+i] = script.first[i]; // uuid
5215                           pos += 16;
5216                           store32(&pData[pos], (uint32_t) slot.first); // slot index
5217                           pos += 4;
5218                           store32(&pData[pos], (uint32_t) 0); // unused, reserved 32 bit
5219                           pos += 4;
5220                           store32(&pData[pos], (uint32_t) slot.second.size()); // variables count
5221                           pos += 4;
5222                           for (const auto& var : slot.second) {
5223                               pData[pos++] = 1; // type
5224                               pData[pos++] = 0; // reserved byte
5225                               store16(&pData[pos], 2 + var.first.size() + 2 + var.second.size()); // blob size
5226                               pos += 2;
5227                               store16(&pData[pos], var.first.size()); // variable name length
5228                               pos += 2;
5229                               for (int i = 0; i < var.first.size(); ++i)
5230                                   pData[pos++] = var.first[i];
5231                               store16(&pData[pos], var.second.size()); // variable value length
5232                               pos += 2;
5233                               for (int i = 0; i < var.second.size(); ++i)
5234                                   pData[pos++] = var.second[i];
5235                           }
5236                       }
5237                   }
5238               } else {
5239                   // no script variable overridden by this instrument, so get rid
5240                   // of 'SCPV' RIFF chunk (if any)
5241                   RIFF::Chunk* ckSCPV = lst3LS->GetSubChunk(CHUNK_ID_SCPV);
5242                   if (ckSCPV) lst3LS->DeleteSubChunk(ckSCPV);
5243               }
5244         } else {         } else {
5245             // no script slots, so get rid of any LS custom RIFF chunks (if any)             // no script slots, so get rid of any LS custom RIFF chunks (if any)
5246             RIFF::List* lst3LS = pCkInstrument->GetSubList(LIST_TYPE_3LS);             RIFF::List* lst3LS = pCkInstrument->GetSubList(LIST_TYPE_3LS);
# Line 5552  namespace { Line 5665  namespace {
5665              scriptPoolFileOffsets.at(index).bypass = bBypass;              scriptPoolFileOffsets.at(index).bypass = bBypass;
5666      }      }
5667    
5668        /// type cast (by copy) uint8_t[16] -> std::array<uint8_t,16>
5669        inline std::array<uint8_t,16> _UUIDFromCArray(const uint8_t* pData) {
5670            std::array<uint8_t,16> uuid;
5671            memcpy(&uuid[0], pData, 16);
5672            return uuid;
5673        }
5674    
5675        /**
5676         * Returns true if this @c Instrument has any script slot which references
5677         * the @c Script identified by passed @p uuid.
5678         */
5679        bool Instrument::ReferencesScriptWithUuid(const _UUID& uuid) {
5680            const uint nSlots = ScriptSlotCount();
5681            for (uint iSlot = 0; iSlot < nSlots; ++iSlot)
5682                if (_UUIDFromCArray(&GetScriptOfSlot(iSlot)->Uuid[0]) == uuid)
5683                    return true;
5684            return false;
5685        }
5686    
5687        /** @brief Checks whether a certain script 'patch' variable value is set.
5688         *
5689         * Returns @c true if the initial value for the requested script variable is
5690         * currently overridden by this instrument.
5691         *
5692         * @remarks Real-time instrument scripts allow to declare special 'patch'
5693         * variables, which essentially behave like regular variables of their data
5694         * type, however their initial value may optionally be overridden on a per
5695         * instrument basis. That allows to share scripts between instruments while
5696         * still being able to fine tune certain aspects of the script for each
5697         * instrument individually.
5698         *
5699         * @param slot - script slot index of the variable to be retrieved
5700         * @param variable - name of the 'patch' variable in that script
5701         */
5702        bool Instrument::IsScriptPatchVariableSet(int slot, String variable) {
5703            if (variable.empty()) return false;
5704            Script* script = GetScriptOfSlot(slot);
5705            if (!script) return false;
5706            const _UUID uuid = _UUIDFromCArray(&script->Uuid[0]);
5707            if (!scriptVars.count(uuid)) return false;
5708            const _VarsBySlot& slots = scriptVars.find(uuid)->second;
5709            if (slots.empty()) return false;
5710            if (slots.count(slot))
5711                return slots.find(slot)->second.count(variable);
5712            else
5713                return slots.begin()->second.count(variable);
5714        }
5715    
5716        /** @brief Get all overridden script 'patch' variables.
5717         *
5718         * Returns map of key-value pairs reflecting all patch variables currently
5719         * being overridden by this instrument for the given script @p slot, where
5720         * key is the variable name and value is the hereby currently overridden
5721         * value for that variable.
5722         *
5723         * @remarks Real-time instrument scripts allow to declare special 'patch'
5724         * variables, which essentially behave like regular variables of their data
5725         * type, however their initial value may optionally be overridden on a per
5726         * instrument basis. That allows to share scripts between instruments while
5727         * still being able to fine tune certain aspects of the script for each
5728         * instrument individually.
5729         *
5730         * @param slot - script slot index of the variable to be retrieved
5731         */
5732        std::map<String,String> Instrument::GetScriptPatchVariables(int slot) {
5733            Script* script = GetScriptOfSlot(slot);
5734            if (!script) return std::map<String,String>();
5735            const _UUID uuid = _UUIDFromCArray(&script->Uuid[0]);
5736            if (!scriptVars.count(uuid)) return std::map<String,String>();
5737            const _VarsBySlot& slots = scriptVars.find(uuid)->second;
5738            if (slots.empty()) return std::map<String,String>();
5739            const _PatchVars& vars =
5740                (slots.count(slot)) ?
5741                    slots.find(slot)->second : slots.begin()->second;
5742            return vars;
5743        }
5744    
5745        /** @brief Get overridden initial value for 'patch' variable.
5746         *
5747         * Returns current initial value for the requested script variable being
5748         * overridden by this instrument.
5749         *
5750         * @remarks Real-time instrument scripts allow to declare special 'patch'
5751         * variables, which essentially behave like regular variables of their data
5752         * type, however their initial value may optionally be overridden on a per
5753         * instrument basis. That allows to share scripts between instruments while
5754         * still being able to fine tune certain aspects of the script for each
5755         * instrument individually.
5756         *
5757         * @param slot - script slot index of the variable to be retrieved
5758         * @param variable - name of the 'patch' variable in that script
5759         */
5760        String Instrument::GetScriptPatchVariable(int slot, String variable) {
5761            std::map<String,String> vars = GetScriptPatchVariables(slot);
5762            return (vars.count(variable)) ? vars.find(variable)->second : "";
5763        }
5764    
5765        /** @brief Override initial value for 'patch' variable.
5766         *
5767         * Overrides initial value for the requested script variable for this
5768         * instrument with the passed value.
5769         *
5770         * @remarks Real-time instrument scripts allow to declare special 'patch'
5771         * variables, which essentially behave like regular variables of their data
5772         * type, however their initial value may optionally be overridden on a per
5773         * instrument basis. That allows to share scripts between instruments while
5774         * still being able to fine tune certain aspects of the script for each
5775         * instrument individually.
5776         *
5777         * @param slot - script slot index of the variable to be set
5778         * @param variable - name of the 'patch' variable in that script
5779         * @param value - overridden initial value for that script variable
5780         * @throws gig::Exception if given script @p slot index is invalid or given
5781         *         @p variable name is empty
5782         */
5783        void Instrument::SetScriptPatchVariable(int slot, String variable, String value) {
5784            if (variable.empty())
5785                throw Exception("Variable name must not be empty");
5786            Script* script = GetScriptOfSlot(slot);
5787            if (!script)
5788                throw Exception("No script slot with index " + ToString(slot));
5789            const _UUID uuid = _UUIDFromCArray(&script->Uuid[0]);
5790            scriptVars[uuid][slot][variable] = value;
5791        }
5792    
5793        /** @brief Drop overridden initial value(s) for 'patch' variable(s).
5794         *
5795         * Reverts initial value(s) for requested script variable(s) back to their
5796         * default initial value(s) defined in the script itself.
5797         *
5798         * Both arguments of this method are optional. The most obvious use case of
5799         * this method would be passing a valid script @p slot index and a
5800         * (non-emtpy string as) @p variable name to this method, which would cause
5801         * that single variable to be unset for that specific script slot (on this
5802         * @c Instrument level).
5803         *
5804         * Not passing a value (or @c -1 for @p slot and/or empty string for
5805         * @p variable) means 'wildcard'. So accordingly absence of argument(s) will
5806         * cause all variables and/or for all script slots being unset. Hence this
5807         * method serves 2^2 = 4 possible use cases in total and accordingly covers
5808         * 4 different behaviours in one method.
5809         *
5810         * @remarks Real-time instrument scripts allow to declare special 'patch'
5811         * variables, which essentially behave like regular variables of their data
5812         * type, however their initial value may optionally be overridden on a per
5813         * instrument basis. That allows to share scripts between instruments while
5814         * still being able to fine tune certain aspects of the script for each
5815         * instrument individually.
5816         *
5817         * @param slot - script slot index of the variable to be unset
5818         * @param variable - name of the 'patch' variable in that script
5819         */
5820        void Instrument::UnsetScriptPatchVariable(int slot, String variable) {
5821            Script* script = GetScriptOfSlot(slot);
5822    
5823            // option 1: unset a particular variable of one particular script slot
5824            if (slot != -1 && !variable.empty()) {
5825                if (!script) return;
5826                const _UUID uuid = _UUIDFromCArray(&script->Uuid[0]);
5827                if (!scriptVars.count(uuid)) return;
5828                if (!scriptVars[uuid].count(slot)) return;
5829                if (scriptVars[uuid][slot].count(variable))
5830                    scriptVars[uuid][slot].erase(
5831                        scriptVars[uuid][slot].find(variable)
5832                    );
5833                if (scriptVars[uuid][slot].empty())
5834                    scriptVars[uuid].erase( scriptVars[uuid].find(slot) );
5835                if (scriptVars[uuid].empty())
5836                    scriptVars.erase( scriptVars.find(uuid) );
5837                return;
5838            }
5839    
5840            // option 2: unset all variables of all script slots
5841            if (slot == -1 && variable.empty()) {
5842                scriptVars.clear();
5843                return;
5844            }
5845    
5846            // option 3: unset all variables of one particular script slot only
5847            if (slot != -1) {
5848                if (!script) return;
5849                const _UUID uuid = _UUIDFromCArray(&script->Uuid[0]);
5850                if (scriptVars.count(uuid))
5851                    scriptVars.erase( scriptVars.find(uuid) );
5852                return;
5853            }
5854    
5855            // option 4: unset a particular variable of all script slots
5856            _VarsByScript::iterator itScript = scriptVars.begin();
5857            _VarsByScript::iterator endScript = scriptVars.end();
5858            while (itScript != endScript) {
5859                _VarsBySlot& slots = itScript->second;
5860                _VarsBySlot::iterator itSlot = slots.begin();
5861                _VarsBySlot::iterator endSlot = slots.end();
5862                while (itSlot != endSlot) {
5863                    _PatchVars& vars = itSlot->second;
5864                    if (vars.count(variable))
5865                        vars.erase( vars.find(variable) );
5866                    if (vars.empty())
5867                        slots.erase(itSlot++); // postfix increment to avoid iterator invalidation
5868                    else
5869                        ++itSlot;
5870                }
5871                if (slots.empty())
5872                    scriptVars.erase(itScript++); // postfix increment to avoid iterator invalidation
5873                else
5874                    ++itScript;
5875            }
5876        }
5877    
5878        /**
5879         * Returns stripped version of member variable @c scriptVars, where scripts
5880         * no longer referenced by this @c Instrument are filtered out, and so are
5881         * variables of meanwhile obsolete slots (i.e. a script still being
5882         * referenced, but previously overridden on a script slot which either no
5883         * longer exists or is hosting another script now).
5884         */
5885        Instrument::_VarsByScript Instrument::stripScriptVars() {
5886            _VarsByScript vars;
5887            _VarsByScript::const_iterator itScript = scriptVars.begin();
5888            _VarsByScript::const_iterator endScript = scriptVars.end();
5889            for (; itScript != endScript; ++itScript) {
5890                const _UUID& uuid = itScript->first;
5891                if (!ReferencesScriptWithUuid(uuid))
5892                    continue;
5893                const _VarsBySlot& slots = itScript->second;
5894                _VarsBySlot::const_iterator itSlot = slots.begin();
5895                _VarsBySlot::const_iterator endSlot = slots.end();
5896                for (; itSlot != endSlot; ++itSlot) {
5897                    Script* script = GetScriptOfSlot(itSlot->first);
5898                    if (!script) continue;
5899                    if (_UUIDFromCArray(&script->Uuid[0]) != uuid) continue;
5900                    if (itSlot->second.empty()) continue;
5901                    vars[uuid][itSlot->first] = itSlot->second;
5902                }
5903            }
5904            return vars;
5905        }
5906    
5907      /**      /**
5908       * 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
5909       * and assign it to this object.       * and assign it to this object.
# Line 5587  namespace { Line 5939  namespace {
5939          DimensionKeyRange = orig->DimensionKeyRange;          DimensionKeyRange = orig->DimensionKeyRange;
5940          scriptPoolFileOffsets = orig->scriptPoolFileOffsets;          scriptPoolFileOffsets = orig->scriptPoolFileOffsets;
5941          pScriptRefs = orig->pScriptRefs;          pScriptRefs = orig->pScriptRefs;
5942            scriptVars = orig->scriptVars;
5943                    
5944          // free old midi rules          // free old midi rules
5945          for (int i = 0 ; pMidiRules[i] ; i++) {          for (int i = 0 ; pMidiRules[i] ; i++) {
# Line 5628  namespace { Line 5981  namespace {
5981       */       */
5982      bool Instrument::UsesAnyGigFormatExtension() const {      bool Instrument::UsesAnyGigFormatExtension() const {
5983          if (!pRegions) return false;          if (!pRegions) return false;
5984            if (!scriptVars.empty()) return true;
5985          RegionList::const_iterator iter = pRegions->begin();          RegionList::const_iterator iter = pRegions->begin();
5986          RegionList::const_iterator end  = pRegions->end();          RegionList::const_iterator end  = pRegions->end();
5987          for (; iter != end; ++iter) {          for (; iter != end; ++iter) {

Legend:
Removed from v.3730  
changed lines
  Added in v.3731

  ViewVC Help
Powered by ViewVC