--- libgig/trunk/src/gig.cpp 2014/05/16 23:08:42 2555 +++ libgig/trunk/src/gig.cpp 2015/01/13 00:32:30 2702 @@ -2,7 +2,7 @@ * * * libgig - C++ cross-platform Gigasampler format file access library * * * - * Copyright (C) 2003-2014 by Christian Schoenebeck * + * Copyright (C) 2003-2015 by Christian Schoenebeck * * * * * * This library is free software; you can redistribute it and/or modify * @@ -53,38 +53,6 @@ namespace gig { -// *************** 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; - } - } - - // *************** Internal functions for sample decompression *************** // * @@ -528,13 +496,14 @@ * Usually there is absolutely no need to call this method explicitly. * It will be called automatically when File::Save() was called. * + * @param pProgress - callback function for progress notification * @throws DLS::Exception if FormatTag != DLS_WAVE_FORMAT_PCM or no sample data * was provided yet * @throws gig::Exception if there is any invalid sample setting */ - void Sample::UpdateChunks() { + void Sample::UpdateChunks(progress_t* pProgress) { // first update base class's chunks - DLS::Sample::UpdateChunks(); + DLS::Sample::UpdateChunks(pProgress); // make sure 'smpl' chunk exists pCkSmpl = pWaveList->GetSubChunk(CHUNK_ID_SMPL); @@ -1752,10 +1721,12 @@ * * Usually there is absolutely no need to call this method explicitly. * It will be called automatically when File::Save() was called. + * + * @param pProgress - callback function for progress notification */ - void DimensionRegion::UpdateChunks() { + void DimensionRegion::UpdateChunks(progress_t* pProgress) { // first update base class's chunk - DLS::Sampler::UpdateChunks(); + DLS::Sampler::UpdateChunks(pProgress); RIFF::Chunk* wsmp = pParentList->GetSubChunk(CHUNK_ID_WSMP); uint8_t* pData = (uint8_t*) wsmp->LoadChunkData(); @@ -3026,9 +2997,10 @@ * Usually there is absolutely no need to call this method explicitly. * It will be called automatically when File::Save() was called. * + * @param pProgress - callback function for progress notification * @throws gig::Exception if samples cannot be dereferenced */ - void Region::UpdateChunks() { + void Region::UpdateChunks(progress_t* pProgress) { // in the gig format we don't care about the Region's sample reference // but we still have to provide some existing one to not corrupt the // file, so to avoid the latter we simply always assign the sample of @@ -3036,11 +3008,11 @@ pSample = pDimensionRegions[0]->pSample; // first update base class's chunks - DLS::Region::UpdateChunks(); + DLS::Region::UpdateChunks(pProgress); // update dimension region's chunks for (int i = 0; i < DimensionRegions; i++) { - pDimensionRegions[i]->UpdateChunks(); + pDimensionRegions[i]->UpdateChunks(pProgress); } File* pFile = (File*) GetParent()->GetParent(); @@ -3056,7 +3028,7 @@ memset(_3lnk->LoadChunkData(), 0, _3lnkChunkSize); // move 3prg to last position - pCkRegion->MoveSubChunk(pCkRegion->GetSubList(LIST_TYPE_3PRG), 0); + pCkRegion->MoveSubChunk(pCkRegion->GetSubList(LIST_TYPE_3PRG), (RIFF::Chunk*)NULL); } // update dimension definitions in '3lnk' chunk @@ -3509,6 +3481,8 @@ // delete temporary region delete tempRgn; + + UpdateVelocityTable(); } /** @brief Divide split zone of a dimension in two (increment zone amount). @@ -3646,6 +3620,35 @@ // delete temporary region delete tempRgn; + + UpdateVelocityTable(); + } + + /** @brief Change type of an existing dimension. + * + * Alters the dimension type of a dimension already existing on this + * region. If there is currently no dimension on this Region with type + * @a oldType, then this call with throw an Exception. Likewise there are + * cases where the requested dimension type cannot be performed. For example + * if the new dimension type shall be gig::dimension_samplechannel, and the + * current dimension has more than 2 zones. In such cases an Exception is + * thrown as well. + * + * @param oldType - identifies the existing dimension to be changed + * @param newType - to which dimension type it should be changed to + * @throws gig::Exception if requested change cannot be performed + */ + void Region::SetDimensionType(dimension_t oldType, dimension_t newType) { + if (oldType == newType) return; + dimension_def_t* def = GetDimensionDefinition(oldType); + if (!def) + throw gig::Exception("No dimension with provided old dimension type exists on this region"); + if (newType == dimension_samplechannel && def->zones != 2) + throw gig::Exception("Cannot change to dimension type 'sample channel', because existing dimension does not have 2 zones"); + if (GetDimensionDefinition(newType)) + throw gig::Exception("There is already a dimension with requested new dimension type on this region"); + def->dimension = newType; + def->split_type = __resolveSplitType(newType); } DimensionRegion* Region::GetDimensionRegionByBit(const std::map& DimCase) { @@ -3739,20 +3742,72 @@ } bitpos += pDimensionDefinitions[i].bits; } - DimensionRegion* dimreg = pDimensionRegions[dimregidx]; + DimensionRegion* dimreg = pDimensionRegions[dimregidx & 255]; + if (!dimreg) return NULL; if (veldim != -1) { // (dimreg is now the dimension region for the lowest velocity) if (dimreg->VelocityTable) // custom defined zone ranges - bits = dimreg->VelocityTable[DimValues[veldim]]; + bits = dimreg->VelocityTable[DimValues[veldim] & 127]; else // normal split type - bits = uint8_t(DimValues[veldim] / pDimensionDefinitions[veldim].zone_size); + bits = uint8_t((DimValues[veldim] & 127) / pDimensionDefinitions[veldim].zone_size); - dimregidx |= bits << velbitpos; - dimreg = pDimensionRegions[dimregidx]; + const uint8_t limiter_mask = (1 << pDimensionDefinitions[veldim].bits) - 1; + dimregidx |= (bits & limiter_mask) << velbitpos; + dimreg = pDimensionRegions[dimregidx & 255]; } return dimreg; } + int Region::GetDimensionRegionIndexByValue(const uint DimValues[8]) { + uint8_t bits; + int veldim = -1; + int velbitpos; + int bitpos = 0; + int dimregidx = 0; + for (uint i = 0; i < Dimensions; i++) { + if (pDimensionDefinitions[i].dimension == dimension_velocity) { + // the velocity dimension must be handled after the other dimensions + veldim = i; + velbitpos = bitpos; + } else { + switch (pDimensionDefinitions[i].split_type) { + case split_type_normal: + if (pDimensionRegions[0]->DimensionUpperLimits[i]) { + // gig3: all normal dimensions (not just the velocity dimension) have custom zone ranges + for (bits = 0 ; bits < pDimensionDefinitions[i].zones ; bits++) { + if (DimValues[i] <= pDimensionRegions[bits << bitpos]->DimensionUpperLimits[i]) break; + } + } else { + // gig2: evenly sized zones + bits = uint8_t(DimValues[i] / pDimensionDefinitions[i].zone_size); + } + break; + case split_type_bit: // the value is already the sought dimension bit number + const uint8_t limiter_mask = (0xff << pDimensionDefinitions[i].bits) ^ 0xff; + bits = DimValues[i] & limiter_mask; // just make sure the value doesn't use more bits than allowed + break; + } + dimregidx |= bits << bitpos; + } + bitpos += pDimensionDefinitions[i].bits; + } + dimregidx &= 255; + DimensionRegion* dimreg = pDimensionRegions[dimregidx]; + if (!dimreg) return -1; + if (veldim != -1) { + // (dimreg is now the dimension region for the lowest velocity) + if (dimreg->VelocityTable) // custom defined zone ranges + bits = dimreg->VelocityTable[DimValues[veldim] & 127]; + else // normal split type + bits = uint8_t((DimValues[veldim] & 127) / pDimensionDefinitions[veldim].zone_size); + + const uint8_t limiter_mask = (1 << pDimensionDefinitions[veldim].bits) - 1; + dimregidx |= (bits & limiter_mask) << velbitpos; + dimregidx &= 255; + } + return dimregidx; + } + /** * Returns the appropriate DimensionRegion for the given dimension bit * numbers (zone index). You usually use GetDimensionRegionByValue @@ -4019,6 +4074,259 @@ } } +// *************** Script *************** +// * + + Script::Script(ScriptGroup* group, RIFF::Chunk* ckScri) { + pGroup = group; + pChunk = ckScri; + if (ckScri) { // object is loaded from file ... + // read header + uint32_t headerSize = ckScri->ReadUint32(); + Compression = (Compression_t) ckScri->ReadUint32(); + Encoding = (Encoding_t) ckScri->ReadUint32(); + Language = (Language_t) ckScri->ReadUint32(); + Bypass = (Language_t) ckScri->ReadUint32() & 1; + crc = ckScri->ReadUint32(); + uint32_t nameSize = ckScri->ReadUint32(); + Name.resize(nameSize, ' '); + for (int i = 0; i < nameSize; ++i) + Name[i] = ckScri->ReadUint8(); + // to handle potential future extensions of the header + ckScri->SetPos(sizeof(int32_t) + headerSize); + // read actual script data + uint32_t scriptSize = ckScri->GetSize() - ckScri->GetPos(); + data.resize(scriptSize); + for (int i = 0; i < scriptSize; ++i) + data[i] = ckScri->ReadUint8(); + } else { // this is a new script object, so just initialize it as such ... + Compression = COMPRESSION_NONE; + Encoding = ENCODING_ASCII; + Language = LANGUAGE_NKSP; + Bypass = false; + crc = 0; + Name = "Unnamed Script"; + } + } + + Script::~Script() { + } + + /** + * Returns the current script (i.e. as source code) in text format. + */ + String Script::GetScriptAsText() { + String s; + s.resize(data.size(), ' '); + memcpy(&s[0], &data[0], data.size()); + return s; + } + + /** + * Replaces the current script with the new script source code text given + * by @a text. + * + * @param text - new script source code + */ + void Script::SetScriptAsText(const String& text) { + data.resize(text.size()); + memcpy(&data[0], &text[0], text.size()); + } + + /** + * Apply this script to the respective RIFF chunks. You have to call + * File::Save() to make changes persistent. + * + * Usually there is absolutely no need to call this method explicitly. + * It will be called automatically when File::Save() was called. + * + * @param pProgress - callback function for progress notification + */ + void Script::UpdateChunks(progress_t* pProgress) { + // recalculate CRC32 check sum + __resetCRC(crc); + __calculateCRC(&data[0], data.size(), crc); + __encodeCRC(crc); + // make sure chunk exists and has the required size + const int chunkSize = 7*sizeof(int32_t) + Name.size() + data.size(); + if (!pChunk) pChunk = pGroup->pList->AddSubChunk(CHUNK_ID_SCRI, chunkSize); + else pChunk->Resize(chunkSize); + // fill the chunk data to be written to disk + uint8_t* pData = (uint8_t*) pChunk->LoadChunkData(); + int pos = 0; + store32(&pData[pos], 6*sizeof(int32_t) + Name.size()); // total header size + pos += sizeof(int32_t); + store32(&pData[pos], Compression); + pos += sizeof(int32_t); + store32(&pData[pos], Encoding); + pos += sizeof(int32_t); + store32(&pData[pos], Language); + pos += sizeof(int32_t); + store32(&pData[pos], Bypass ? 1 : 0); + pos += sizeof(int32_t); + store32(&pData[pos], crc); + pos += sizeof(int32_t); + store32(&pData[pos], Name.size()); + pos += sizeof(int32_t); + for (int i = 0; i < Name.size(); ++i, ++pos) + pData[pos] = Name[i]; + for (int i = 0; i < data.size(); ++i, ++pos) + pData[pos] = data[i]; + } + + /** + * Move this script from its current ScriptGroup to another ScriptGroup + * given by @a pGroup. + * + * @param pGroup - script's new group + */ + void Script::SetGroup(ScriptGroup* pGroup) { + if (this->pGroup = pGroup) return; + if (pChunk) + pChunk->GetParent()->MoveSubChunk(pChunk, pGroup->pList); + this->pGroup = pGroup; + } + + /** + * Returns the script group this script currently belongs to. Each script + * is a member of exactly one ScriptGroup. + * + * @returns current script group + */ + ScriptGroup* Script::GetGroup() const { + return pGroup; + } + + void Script::RemoveAllScriptReferences() { + File* pFile = pGroup->pFile; + for (int i = 0; pFile->GetInstrument(i); ++i) { + Instrument* instr = pFile->GetInstrument(i); + instr->RemoveScript(this); + } + } + +// *************** ScriptGroup *************** +// * + + ScriptGroup::ScriptGroup(File* file, RIFF::List* lstRTIS) { + pFile = file; + pList = lstRTIS; + pScripts = NULL; + if (lstRTIS) { + RIFF::Chunk* ckName = lstRTIS->GetSubChunk(CHUNK_ID_LSNM); + ::LoadString(ckName, Name); + } else { + Name = "Default Group"; + } + } + + ScriptGroup::~ScriptGroup() { + if (pScripts) { + std::list::iterator iter = pScripts->begin(); + std::list::iterator end = pScripts->end(); + while (iter != end) { + delete *iter; + ++iter; + } + delete pScripts; + } + } + + /** + * Apply this script group to the respective RIFF chunks. You have to call + * File::Save() to make changes persistent. + * + * Usually there is absolutely no need to call this method explicitly. + * It will be called automatically when File::Save() was called. + * + * @param pProgress - callback function for progress notification + */ + void ScriptGroup::UpdateChunks(progress_t* pProgress) { + if (pScripts) { + if (!pList) + pList = pFile->pRIFF->GetSubList(LIST_TYPE_3LS)->AddSubList(LIST_TYPE_RTIS); + + // now store the name of this group as chunk as subchunk of the list chunk + ::SaveString(CHUNK_ID_LSNM, NULL, pList, Name, String("Unnamed Group"), true, 64); + + for (std::list::iterator it = pScripts->begin(); + it != pScripts->end(); ++it) + { + (*it)->UpdateChunks(pProgress); + } + } + } + + /** @brief Get instrument script. + * + * Returns the real-time instrument script with the given index. + * + * @param index - number of the sought script (0..n) + * @returns sought script or NULL if there's no such script + */ + Script* ScriptGroup::GetScript(uint index) { + if (!pScripts) LoadScripts(); + std::list::iterator it = pScripts->begin(); + for (uint i = 0; it != pScripts->end(); ++i, ++it) + if (i == index) return *it; + return NULL; + } + + /** @brief Add new instrument script. + * + * Adds a new real-time instrument script to the file. The script is not + * actually used / executed unless it is referenced by an instrument to be + * used. This is similar to samples, which you can add to a file, without + * an instrument necessarily actually using it. + * + * You have to call Save() to make this persistent to the file. + * + * @return new empty script object + */ + Script* ScriptGroup::AddScript() { + if (!pScripts) LoadScripts(); + Script* pScript = new Script(this, NULL); + pScripts->push_back(pScript); + return pScript; + } + + /** @brief Delete an instrument script. + * + * This will delete the given real-time instrument script. References of + * instruments that are using that script will be removed accordingly. + * + * You have to call Save() to make this persistent to the file. + * + * @param pScript - script to delete + * @throws gig::Exception if given script could not be found + */ + void ScriptGroup::DeleteScript(Script* pScript) { + if (!pScripts) LoadScripts(); + std::list::iterator iter = + find(pScripts->begin(), pScripts->end(), pScript); + if (iter == pScripts->end()) + throw gig::Exception("Could not delete script, could not find given script"); + pScripts->erase(iter); + pScript->RemoveAllScriptReferences(); + if (pScript->pChunk) + pScript->pChunk->GetParent()->DeleteSubChunk(pScript->pChunk); + delete pScript; + } + + void ScriptGroup::LoadScripts() { + if (pScripts) return; + pScripts = new std::list; + if (!pList) return; + + for (RIFF::Chunk* ck = pList->GetFirstSubChunk(); ck; + ck = pList->GetNextSubChunk()) + { + if (ck->GetChunkID() == CHUNK_ID_SCRI) { + pScripts->push_back(new Script(this, ck)); + } + } + } + // *************** Instrument *************** // * @@ -4041,6 +4349,7 @@ DimensionKeyRange.high = 0; pMidiRules = new MidiRule*[3]; pMidiRules[0] = NULL; + pScriptRefs = NULL; // Loading RIFF::List* lart = insList->GetSubList(LIST_TYPE_LART); @@ -4101,6 +4410,28 @@ } } + // own gig format extensions + RIFF::List* lst3LS = insList->GetSubList(LIST_TYPE_3LS); + if (lst3LS) { + RIFF::Chunk* ckSCSL = lst3LS->GetSubChunk(CHUNK_ID_SCSL); + if (ckSCSL) { + int headerSize = ckSCSL->ReadUint32(); + int slotCount = ckSCSL->ReadUint32(); + if (slotCount) { + int slotSize = ckSCSL->ReadUint32(); + ckSCSL->SetPos(headerSize); // in case of future header extensions + int unknownSpace = slotSize - 2*sizeof(uint32_t); // in case of future slot extensions + for (int i = 0; i < slotCount; ++i) { + _ScriptPooolEntry e; + e.fileOffset = ckSCSL->ReadUint32(); + e.bypass = ckSCSL->ReadUint32() & 1; + if (unknownSpace) ckSCSL->SetPos(unknownSpace, RIFF::stream_curpos); // in case of future extensions + scriptPoolFileOffsets.push_back(e); + } + } + } + } + __notify_progress(pProgress, 1.0f); // notify done } @@ -4121,6 +4452,7 @@ delete pMidiRules[i]; } delete[] pMidiRules; + if (pScriptRefs) delete pScriptRefs; } /** @@ -4130,18 +4462,19 @@ * Usually there is absolutely no need to call this method explicitly. * It will be called automatically when File::Save() was called. * + * @param pProgress - callback function for progress notification * @throws gig::Exception if samples cannot be dereferenced */ - void Instrument::UpdateChunks() { + void Instrument::UpdateChunks(progress_t* pProgress) { // first update base classes' chunks - DLS::Instrument::UpdateChunks(); + DLS::Instrument::UpdateChunks(pProgress); // update Regions' chunks { RegionList::iterator iter = pRegions->begin(); RegionList::iterator end = pRegions->end(); for (; iter != end; ++iter) - (*iter)->UpdateChunks(); + (*iter)->UpdateChunks(pProgress); } // make sure 'lart' RIFF list chunk exists @@ -4176,6 +4509,64 @@ pMidiRules[i]->UpdateChunks(pData); } } + + // own gig format extensions + if (ScriptSlotCount()) { + // make sure we have converted the original loaded script file + // offsets into valid Script object pointers + LoadScripts(); + + RIFF::List* lst3LS = pCkInstrument->GetSubList(LIST_TYPE_3LS); + if (!lst3LS) lst3LS = pCkInstrument->AddSubList(LIST_TYPE_3LS); + const int slotCount = pScriptRefs->size(); + const int headerSize = 3 * sizeof(uint32_t); + const int slotSize = 2 * sizeof(uint32_t); + const int totalChunkSize = headerSize + slotCount * slotSize; + RIFF::Chunk* ckSCSL = lst3LS->GetSubChunk(CHUNK_ID_SCSL); + if (!ckSCSL) ckSCSL = lst3LS->AddSubChunk(CHUNK_ID_SCSL, totalChunkSize); + else ckSCSL->Resize(totalChunkSize); + uint8_t* pData = (uint8_t*) ckSCSL->LoadChunkData(); + int pos = 0; + store32(&pData[pos], headerSize); + pos += sizeof(uint32_t); + store32(&pData[pos], slotCount); + pos += sizeof(uint32_t); + store32(&pData[pos], slotSize); + pos += sizeof(uint32_t); + for (int i = 0; i < slotCount; ++i) { + // arbitrary value, the actual file offset will be updated in + // UpdateScriptFileOffsets() after the file has been resized + int bogusFileOffset = 0; + store32(&pData[pos], bogusFileOffset); + pos += sizeof(uint32_t); + store32(&pData[pos], (*pScriptRefs)[i].bypass ? 1 : 0); + pos += sizeof(uint32_t); + } + } else { + // no script slots, so get rid of any LS custom RIFF chunks (if any) + RIFF::List* lst3LS = pCkInstrument->GetSubList(LIST_TYPE_3LS); + if (lst3LS) pCkInstrument->DeleteSubChunk(lst3LS); + } + } + + void Instrument::UpdateScriptFileOffsets() { + // own gig format extensions + if (pScriptRefs && pScriptRefs->size() > 0) { + RIFF::List* lst3LS = pCkInstrument->GetSubList(LIST_TYPE_3LS); + RIFF::Chunk* ckSCSL = lst3LS->GetSubChunk(CHUNK_ID_SCSL); + const int slotCount = pScriptRefs->size(); + const int headerSize = 3 * sizeof(uint32_t); + ckSCSL->SetPos(headerSize); + for (int i = 0; i < slotCount; ++i) { + uint32_t fileOffset = + (*pScriptRefs)[i].script->pChunk->GetFilePos() - + (*pScriptRefs)[i].script->pChunk->GetPos() - + CHUNK_HEADER_SIZE; + ckSCSL->WriteUint32(&fileOffset); + // jump over flags entry (containing the bypass flag) + ckSCSL->SetPos(sizeof(uint32_t), RIFF::stream_curpos); + } + } } /** @@ -4245,6 +4636,63 @@ } /** + * Move this instrument at the position before @arg dst. + * + * This method can be used to reorder the sequence of instruments in a + * .gig file. This might be helpful especially on large .gig files which + * contain a large number of instruments within the same .gig file. So + * grouping such instruments to similar ones, can help to keep track of them + * when working with such complex .gig files. + * + * When calling this method, this instrument will be removed from in its + * current position in the instruments list and moved to the requested + * target position provided by @param dst. You may also pass NULL as + * argument to this method, in that case this intrument will be moved to the + * very end of the .gig file's instrument list. + * + * You have to call Save() to make the order change persistent to the .gig + * file. + * + * Currently this method is limited to moving the instrument within the same + * .gig file. Trying to move it to another .gig file by calling this method + * will throw an exception. + * + * @param dst - destination instrument at which this instrument will be + * moved to, or pass NULL for moving to end of list + * @throw gig::Exception if this instrument and target instrument are not + * part of the same file + */ + void Instrument::MoveTo(Instrument* dst) { + if (dst && GetParent() != dst->GetParent()) + throw Exception( + "gig::Instrument::MoveTo() can only be used for moving within " + "the same gig file." + ); + + File* pFile = (File*) GetParent(); + + // move this instrument within the instrument list + { + DLS::File::InstrumentList& list = *pFile->pInstruments; + + DLS::File::InstrumentList::iterator itFrom = + std::find(list.begin(), list.end(), static_cast(this)); + + DLS::File::InstrumentList::iterator itTo = + std::find(list.begin(), list.end(), static_cast(dst)); + + list.splice(itTo, list, itFrom); + } + + // move the instrument's actual list RIFF chunk appropriately + RIFF::List* lstCkInstruments = pFile->pRIFF->GetSubList(LIST_TYPE_LINS); + lstCkInstruments->MoveSubChunk( + this->pCkInstrument, + (RIFF::Chunk*) ((dst) ? dst->pCkInstrument : NULL) + ); + } + + /** * Returns a MIDI rule of the instrument. * * The list of MIDI rules, at least in gig v3, always contains at @@ -4307,6 +4755,214 @@ pMidiRules[i] = 0; } + void Instrument::LoadScripts() { + if (pScriptRefs) return; + pScriptRefs = new std::vector<_ScriptPooolRef>; + if (scriptPoolFileOffsets.empty()) return; + File* pFile = (File*) GetParent(); + for (uint k = 0; k < scriptPoolFileOffsets.size(); ++k) { + uint32_t soughtOffset = scriptPoolFileOffsets[k].fileOffset; + for (uint i = 0; pFile->GetScriptGroup(i); ++i) { + ScriptGroup* group = pFile->GetScriptGroup(i); + for (uint s = 0; group->GetScript(s); ++s) { + Script* script = group->GetScript(s); + if (script->pChunk) { + uint32_t offset = script->pChunk->GetFilePos() - + script->pChunk->GetPos() - + CHUNK_HEADER_SIZE; + if (offset == soughtOffset) + { + _ScriptPooolRef ref; + ref.script = script; + ref.bypass = scriptPoolFileOffsets[k].bypass; + pScriptRefs->push_back(ref); + break; + } + } + } + } + } + // we don't need that anymore + scriptPoolFileOffsets.clear(); + } + + /** @brief Get instrument script (gig format extension). + * + * Returns the real-time instrument script of instrument script slot + * @a index. + * + * @note This is an own format extension which did not exist i.e. in the + * GigaStudio 4 software. It will currently only work with LinuxSampler and + * gigedit. + * + * @param index - instrument script slot index + * @returns script or NULL if index is out of bounds + */ + Script* Instrument::GetScriptOfSlot(uint index) { + LoadScripts(); + if (index >= pScriptRefs->size()) return NULL; + return pScriptRefs->at(index).script; + } + + /** @brief Add new instrument script slot (gig format extension). + * + * Add the given real-time instrument script reference to this instrument, + * which shall be executed by the sampler for for this instrument. The + * script will be added to the end of the script list of this instrument. + * The positions of the scripts in the Instrument's Script list are + * relevant, because they define in which order they shall be executed by + * the sampler. For this reason it is also legal to add the same script + * twice to an instrument, for example you might have a script called + * "MyFilter" which performs an event filter task, and you might have + * another script called "MyNoteTrigger" which triggers new notes, then you + * might for example have the following list of scripts on the instrument: + * + * 1. Script "MyFilter" + * 2. Script "MyNoteTrigger" + * 3. Script "MyFilter" + * + * Which would make sense, because the 2nd script launched new events, which + * you might need to filter as well. + * + * There are two ways to disable / "bypass" scripts. You can either disable + * a script locally for the respective script slot on an instrument (i.e. by + * passing @c false to the 2nd argument of this method, or by calling + * SetScriptBypassed()). Or you can disable a script globally for all slots + * and all instruments by setting Script::Bypass. + * + * @note This is an own format extension which did not exist i.e. in the + * GigaStudio 4 software. It will currently only work with LinuxSampler and + * gigedit. + * + * @param pScript - script that shall be executed for this instrument + * @param bypass - if enabled, the sampler shall skip executing this + * script (in the respective list position) + * @see SetScriptBypassed() + */ + void Instrument::AddScriptSlot(Script* pScript, bool bypass) { + LoadScripts(); + _ScriptPooolRef ref = { pScript, bypass }; + pScriptRefs->push_back(ref); + } + + /** @brief Flip two script slots with each other (gig format extension). + * + * Swaps the position of the two given scripts in the Instrument's Script + * list. The positions of the scripts in the Instrument's Script list are + * relevant, because they define in which order they shall be executed by + * the sampler. + * + * @note This is an own format extension which did not exist i.e. in the + * GigaStudio 4 software. It will currently only work with LinuxSampler and + * gigedit. + * + * @param index1 - index of the first script slot to swap + * @param index2 - index of the second script slot to swap + */ + void Instrument::SwapScriptSlots(uint index1, uint index2) { + LoadScripts(); + if (index1 >= pScriptRefs->size() || index2 >= pScriptRefs->size()) + return; + _ScriptPooolRef tmp = (*pScriptRefs)[index1]; + (*pScriptRefs)[index1] = (*pScriptRefs)[index2]; + (*pScriptRefs)[index2] = tmp; + } + + /** @brief Remove script slot. + * + * Removes the script slot with the given slot index. + * + * @param index - index of script slot to remove + */ + void Instrument::RemoveScriptSlot(uint index) { + LoadScripts(); + if (index >= pScriptRefs->size()) return; + pScriptRefs->erase( pScriptRefs->begin() + index ); + } + + /** @brief Remove reference to given Script (gig format extension). + * + * This will remove all script slots on the instrument which are referencing + * the given script. + * + * @note This is an own format extension which did not exist i.e. in the + * GigaStudio 4 software. It will currently only work with LinuxSampler and + * gigedit. + * + * @param pScript - script reference to remove from this instrument + * @see RemoveScriptSlot() + */ + void Instrument::RemoveScript(Script* pScript) { + LoadScripts(); + for (int i = pScriptRefs->size() - 1; i >= 0; --i) { + if ((*pScriptRefs)[i].script == pScript) { + pScriptRefs->erase( pScriptRefs->begin() + i ); + } + } + } + + /** @brief Instrument's amount of script slots. + * + * This method returns the amount of script slots this instrument currently + * uses. + * + * A script slot is a reference of a real-time instrument script to be + * executed by the sampler. The scripts will be executed by the sampler in + * sequence of the slots. One (same) script may be referenced multiple + * times in different slots. + * + * @note This is an own format extension which did not exist i.e. in the + * GigaStudio 4 software. It will currently only work with LinuxSampler and + * gigedit. + */ + uint Instrument::ScriptSlotCount() const { + return pScriptRefs ? pScriptRefs->size() : scriptPoolFileOffsets.size(); + } + + /** @brief Whether script execution shall be skipped. + * + * Defines locally for the Script reference slot in the Instrument's Script + * list, whether the script shall be skipped by the sampler regarding + * execution. + * + * It is also possible to ignore exeuction of the script globally, for all + * slots and for all instruments by setting Script::Bypass. + * + * @note This is an own format extension which did not exist i.e. in the + * GigaStudio 4 software. It will currently only work with LinuxSampler and + * gigedit. + * + * @param index - index of the script slot on this instrument + * @see Script::Bypass + */ + bool Instrument::IsScriptSlotBypassed(uint index) { + if (index >= ScriptSlotCount()) return false; + return pScriptRefs ? pScriptRefs->at(index).bypass + : scriptPoolFileOffsets.at(index).bypass; + + } + + /** @brief Defines whether execution shall be skipped. + * + * You can call this method to define locally whether or whether not the + * given script slot shall be executed by the sampler. + * + * @note This is an own format extension which did not exist i.e. in the + * GigaStudio 4 software. It will currently only work with LinuxSampler and + * gigedit. + * + * @param index - script slot index on this instrument + * @param bBypass - if true, the script slot will be skipped by the sampler + * @see Script::Bypass + */ + void Instrument::SetScriptSlotBypassed(uint index, bool bBypass) { + if (index >= ScriptSlotCount()) return; + if (pScriptRefs) + pScriptRefs->at(index).bypass = bBypass; + else + scriptPoolFileOffsets.at(index).bypass = bBypass; + } + /** * Make a (semi) deep copy of the Instrument object given by @a orig * and assign it to this object. @@ -4340,6 +4996,8 @@ PitchbendRange = orig->PitchbendRange; PianoReleaseMode = orig->PianoReleaseMode; DimensionKeyRange = orig->DimensionKeyRange; + scriptPoolFileOffsets = orig->scriptPoolFileOffsets; + pScriptRefs = orig->pScriptRefs; // free old midi rules for (int i = 0 ; pMidiRules[i] ; i++) { @@ -4394,8 +5052,10 @@ * * Usually there is absolutely no need to call this method explicitly. * It will be called automatically when File::Save() was called. + * + * @param pProgress - callback function for progress notification */ - void Group::UpdateChunks() { + void Group::UpdateChunks(progress_t* pProgress) { // make sure <3gri> and <3gnl> list chunks exist RIFF::List* _3gri = pFile->pRIFF->GetSubList(LIST_TYPE_3GRI); if (!_3gri) { @@ -4525,6 +5185,7 @@ bAutoLoad = true; *pVersion = VERSION_3; pGroups = NULL; + pScriptGroups = NULL; pInfo->SetFixedStringLengths(_FileFixedStringLengths); pInfo->ArchivalLocation = String(256, ' '); @@ -4540,6 +5201,7 @@ File::File(RIFF::File* pRIFF) : DLS::File(pRIFF) { bAutoLoad = true; pGroups = NULL; + pScriptGroups = NULL; pInfo->SetFixedStringLengths(_FileFixedStringLengths); } @@ -4553,6 +5215,15 @@ } delete pGroups; } + if (pScriptGroups) { + std::list::iterator iter = pScriptGroups->begin(); + std::list::iterator end = pScriptGroups->end(); + while (iter != end) { + delete *iter; + ++iter; + } + delete pScriptGroups; + } } Sample* File::GetFirstSample(progress_t* pProgress) { @@ -5065,6 +5736,93 @@ } } + /** @brief Get instrument script group (by index). + * + * Returns the real-time instrument script group with the given index. + * + * @param index - number of the sought group (0..n) + * @returns sought script group or NULL if there's no such group + */ + ScriptGroup* File::GetScriptGroup(uint index) { + if (!pScriptGroups) LoadScriptGroups(); + std::list::iterator it = pScriptGroups->begin(); + for (uint i = 0; it != pScriptGroups->end(); ++i, ++it) + if (i == index) return *it; + return NULL; + } + + /** @brief Get instrument script group (by name). + * + * Returns the first real-time instrument script group found with the given + * group name. Note that group names may not necessarily be unique. + * + * @param name - name of the sought script group + * @returns sought script group or NULL if there's no such group + */ + ScriptGroup* File::GetScriptGroup(const String& name) { + if (!pScriptGroups) LoadScriptGroups(); + std::list::iterator it = pScriptGroups->begin(); + for (uint i = 0; it != pScriptGroups->end(); ++i, ++it) + if ((*it)->Name == name) return *it; + return NULL; + } + + /** @brief Add new instrument script group. + * + * Adds a new, empty real-time instrument script group to the file. + * + * You have to call Save() to make this persistent to the file. + * + * @return new empty script group + */ + ScriptGroup* File::AddScriptGroup() { + if (!pScriptGroups) LoadScriptGroups(); + ScriptGroup* pScriptGroup = new ScriptGroup(this, NULL); + pScriptGroups->push_back(pScriptGroup); + return pScriptGroup; + } + + /** @brief Delete an instrument script group. + * + * This will delete the given real-time instrument script group and all its + * instrument scripts it contains. References inside instruments that are + * using the deleted scripts will be removed from the respective instruments + * accordingly. + * + * You have to call Save() to make this persistent to the file. + * + * @param pScriptGroup - script group to delete + * @throws gig::Exception if given script group could not be found + */ + void File::DeleteScriptGroup(ScriptGroup* pScriptGroup) { + if (!pScriptGroups) LoadScriptGroups(); + std::list::iterator iter = + find(pScriptGroups->begin(), pScriptGroups->end(), pScriptGroup); + if (iter == pScriptGroups->end()) + throw gig::Exception("Could not delete script group, could not find given script group"); + pScriptGroups->erase(iter); + for (int i = 0; pScriptGroup->GetScript(i); ++i) + pScriptGroup->DeleteScript(pScriptGroup->GetScript(i)); + if (pScriptGroup->pList) + pScriptGroup->pList->GetParent()->DeleteSubChunk(pScriptGroup->pList); + delete pScriptGroup; + } + + void File::LoadScriptGroups() { + if (pScriptGroups) return; + pScriptGroups = new std::list; + RIFF::List* lstLS = pRIFF->GetSubList(LIST_TYPE_3LS); + if (lstLS) { + for (RIFF::List* lst = lstLS->GetFirstSubList(); lst; + lst = lstLS->GetNextSubList()) + { + if (lst->GetListType() == LIST_TYPE_RTIS) { + pScriptGroups->push_back(new ScriptGroup(this, lst)); + } + } + } + } + /** * Apply all the gig file's current instruments, samples, groups and settings * to the respective RIFF chunks. You have to call Save() to make changes @@ -5073,15 +5831,39 @@ * Usually there is absolutely no need to call this method explicitly. * It will be called automatically when File::Save() was called. * + * @param pProgress - callback function for progress notification * @throws Exception - on errors */ - void File::UpdateChunks() { + void File::UpdateChunks(progress_t* pProgress) { bool newFile = pRIFF->GetSubList(LIST_TYPE_INFO) == NULL; b64BitWavePoolOffsets = pVersion && pVersion->major == 3; + // update own gig format extension chunks + // (not part of the GigaStudio 4 format) + // + // This must be performed before writing the chunks for instruments, + // because the instruments' script slots will write the file offsets + // of the respective instrument script chunk as reference. + if (pScriptGroups) { + RIFF::List* lst3LS = pRIFF->GetSubList(LIST_TYPE_3LS); + if (pScriptGroups->empty()) { + if (lst3LS) pRIFF->DeleteSubChunk(lst3LS); + } else { + if (!lst3LS) lst3LS = pRIFF->AddSubList(LIST_TYPE_3LS); + + // Update instrument script (group) chunks. + + for (std::list::iterator it = pScriptGroups->begin(); + it != pScriptGroups->end(); ++it) + { + (*it)->UpdateChunks(pProgress); + } + } + } + // first update base class's chunks - DLS::File::UpdateChunks(); + DLS::File::UpdateChunks(pProgress); if (newFile) { // INFO was added by Resource::UpdateChunks - make sure it @@ -5118,7 +5900,7 @@ std::list::iterator iter = pGroups->begin(); std::list::iterator end = pGroups->end(); for (; iter != end; ++iter) { - (*iter)->UpdateChunks(); + (*iter)->UpdateChunks(pProgress); } } @@ -5250,6 +6032,16 @@ if (einf && pVersion && pVersion->major == 3) pRIFF->MoveSubChunk(_3crc, einf); } } + + void File::UpdateFileOffsets() { + DLS::File::UpdateFileOffsets(); + + for (Instrument* instrument = GetFirstInstrument(); instrument; + instrument = GetNextInstrument()) + { + instrument->UpdateScriptFileOffsets(); + } + } /** * Enable / disable automatic loading. By default this properyt is