--- libgig/trunk/src/gig.cpp 2013/01/19 08:19:14 2402 +++ libgig/trunk/src/gig.cpp 2014/05/13 11:17:24 2547 @@ -2,7 +2,7 @@ * * * libgig - C++ cross-platform Gigasampler format file access library * * * - * Copyright (C) 2003-2013 by Christian Schoenebeck * + * Copyright (C) 2003-2014 by Christian Schoenebeck * * * * * * This library is free software; you can redistribute it and/or modify * @@ -454,6 +454,73 @@ } /** + * Make a (semi) deep copy of the Sample object given by @a orig (without + * the actual waveform data) and assign it to this object. + * + * Discussion: copying .gig samples is a bit tricky. It requires three + * steps: + * 1. Copy sample's meta informations (done by CopyAssignMeta()) including + * its new sample waveform data size. + * 2. Saving the file (done by File::Save()) so that it gains correct size + * and layout for writing the actual wave form data directly to disc + * in next step. + * 3. Copy the waveform data with disk streaming (done by CopyAssignWave()). + * + * @param orig - original Sample object to be copied from + */ + void Sample::CopyAssignMeta(const Sample* orig) { + // handle base classes + DLS::Sample::CopyAssignCore(orig); + + // handle actual own attributes of this class + Manufacturer = orig->Manufacturer; + Product = orig->Product; + SamplePeriod = orig->SamplePeriod; + MIDIUnityNote = orig->MIDIUnityNote; + FineTune = orig->FineTune; + SMPTEFormat = orig->SMPTEFormat; + SMPTEOffset = orig->SMPTEOffset; + Loops = orig->Loops; + LoopID = orig->LoopID; + LoopType = orig->LoopType; + LoopStart = orig->LoopStart; + LoopEnd = orig->LoopEnd; + LoopSize = orig->LoopSize; + LoopFraction = orig->LoopFraction; + LoopPlayCount = orig->LoopPlayCount; + + // schedule resizing this sample to the given sample's size + Resize(orig->GetSize()); + } + + /** + * Should be called after CopyAssignMeta() and File::Save() sequence. + * Read more about it in the discussion of CopyAssignMeta(). This method + * copies the actual waveform data by disk streaming. + * + * @e CAUTION: this method is currently not thread safe! During this + * operation the sample must not be used for other purposes by other + * threads! + * + * @param orig - original Sample object to be copied from + */ + void Sample::CopyAssignWave(const Sample* orig) { + const int iReadAtOnce = 32*1024; + char* buf = new char[iReadAtOnce * orig->FrameSize]; + Sample* pOrig = (Sample*) orig; //HACK: remove constness for now + unsigned long restorePos = pOrig->GetPos(); + pOrig->SetPos(0); + SetPos(0); + for (unsigned long n = pOrig->Read(buf, iReadAtOnce); n; + n = pOrig->Read(buf, iReadAtOnce)) + { + Write(buf, n); + } + pOrig->SetPos(restorePos); + delete [] buf; + } + + /** * Apply sample and its settings to the respective RIFF chunks. You have * to call File::Save() to make changes persistent. * @@ -514,6 +581,14 @@ // update '3gix' chunk pData = (uint8_t*) pCk3gix->LoadChunkData(); store16(&pData[0], iSampleGroup); + + // if the library user toggled the "Compressed" attribute from true to + // false, then the EWAV chunk associated with compressed samples needs + // to be deleted + RIFF::Chunk* ewav = pWaveList->GetSubChunk(CHUNK_ID_EWAV); + if (ewav && !Compressed) { + pWaveList->DeleteSubChunk(ewav); + } } /// Scans compressed samples for mandatory informations (e.g. actual number of total sample points). @@ -808,7 +883,7 @@ /** * Returns the current position in the sample (in sample points). */ - unsigned long Sample::GetPos() { + unsigned long Sample::GetPos() const { if (Compressed) return SamplePos; else return pCkData->GetPos() / FrameSize; } @@ -1608,6 +1683,18 @@ * @param orig - original DimensionRegion object to be copied from */ void DimensionRegion::CopyAssign(const DimensionRegion* orig) { + CopyAssign(orig, NULL); + } + + /** + * Make a (semi) deep copy of the DimensionRegion object given by @a orig + * and assign it to this object. + * + * @param orig - original DimensionRegion object to be copied from + * @param mSamples - crosslink map between the foreign file's samples and + * this file's samples + */ + void DimensionRegion::CopyAssign(const DimensionRegion* orig, const std::map* mSamples) { // delete all allocated data first if (VelocityTable) delete [] VelocityTable; if (pSampleLoops) delete [] pSampleLoops; @@ -1615,10 +1702,26 @@ // backup parent list pointer RIFF::List* p = pParentList; + gig::Sample* pOriginalSample = pSample; + gig::Region* pOriginalRegion = pRegion; + //NOTE: copy code copied from assignment constructor above, see comment there as well *this = *orig; // default memberwise shallow copy of all parameters + + // restore members that shall not be altered pParentList = p; // restore the chunk pointer + pRegion = pOriginalRegion; + + // only take the raw sample reference reference if the + // two DimensionRegion objects are part of the same file + if (pOriginalRegion->GetParent()->GetParent() != orig->pRegion->GetParent()->GetParent()) { + pSample = pOriginalSample; + } + + if (mSamples && mSamples->count(orig->pSample)) { + pSample = mSamples->find(orig->pSample)->second; + } // deep copy of owned structures if (orig->VelocityTable) { @@ -1986,6 +2089,12 @@ return pRegion; } +// show error if some _lev_ctrl_* enum entry is not listed in the following function +// (commented out for now, because "diagnostic push" not supported prior GCC 4.6) +// TODO: uncomment and add a GCC version check (see also commented "#pragma GCC diagnostic pop" below) +//#pragma GCC diagnostic push +//#pragma GCC diagnostic error "-Wswitch" + leverage_ctrl_t DimensionRegion::DecodeLeverageController(_lev_ctrl_t EncodedController) { leverage_ctrl_t decodedcontroller; switch (EncodedController) { @@ -2097,12 +2206,255 @@ decodedcontroller.controller_number = 95; break; + // format extension (these controllers are so far only supported by + // LinuxSampler & gigedit) they will *NOT* work with + // Gigasampler/GigaStudio ! + case _lev_ctrl_CC3_EXT: + decodedcontroller.type = leverage_ctrl_t::type_controlchange; + decodedcontroller.controller_number = 3; + break; + case _lev_ctrl_CC6_EXT: + decodedcontroller.type = leverage_ctrl_t::type_controlchange; + decodedcontroller.controller_number = 6; + break; + case _lev_ctrl_CC7_EXT: + decodedcontroller.type = leverage_ctrl_t::type_controlchange; + decodedcontroller.controller_number = 7; + break; + case _lev_ctrl_CC8_EXT: + decodedcontroller.type = leverage_ctrl_t::type_controlchange; + decodedcontroller.controller_number = 8; + break; + case _lev_ctrl_CC9_EXT: + decodedcontroller.type = leverage_ctrl_t::type_controlchange; + decodedcontroller.controller_number = 9; + break; + case _lev_ctrl_CC10_EXT: + decodedcontroller.type = leverage_ctrl_t::type_controlchange; + decodedcontroller.controller_number = 10; + break; + case _lev_ctrl_CC11_EXT: + decodedcontroller.type = leverage_ctrl_t::type_controlchange; + decodedcontroller.controller_number = 11; + break; + case _lev_ctrl_CC14_EXT: + decodedcontroller.type = leverage_ctrl_t::type_controlchange; + decodedcontroller.controller_number = 14; + break; + case _lev_ctrl_CC15_EXT: + decodedcontroller.type = leverage_ctrl_t::type_controlchange; + decodedcontroller.controller_number = 15; + break; + case _lev_ctrl_CC20_EXT: + decodedcontroller.type = leverage_ctrl_t::type_controlchange; + decodedcontroller.controller_number = 20; + break; + case _lev_ctrl_CC21_EXT: + decodedcontroller.type = leverage_ctrl_t::type_controlchange; + decodedcontroller.controller_number = 21; + break; + case _lev_ctrl_CC22_EXT: + decodedcontroller.type = leverage_ctrl_t::type_controlchange; + decodedcontroller.controller_number = 22; + break; + case _lev_ctrl_CC23_EXT: + decodedcontroller.type = leverage_ctrl_t::type_controlchange; + decodedcontroller.controller_number = 23; + break; + case _lev_ctrl_CC24_EXT: + decodedcontroller.type = leverage_ctrl_t::type_controlchange; + decodedcontroller.controller_number = 24; + break; + case _lev_ctrl_CC25_EXT: + decodedcontroller.type = leverage_ctrl_t::type_controlchange; + decodedcontroller.controller_number = 25; + break; + case _lev_ctrl_CC26_EXT: + decodedcontroller.type = leverage_ctrl_t::type_controlchange; + decodedcontroller.controller_number = 26; + break; + case _lev_ctrl_CC27_EXT: + decodedcontroller.type = leverage_ctrl_t::type_controlchange; + decodedcontroller.controller_number = 27; + break; + case _lev_ctrl_CC28_EXT: + decodedcontroller.type = leverage_ctrl_t::type_controlchange; + decodedcontroller.controller_number = 28; + break; + case _lev_ctrl_CC29_EXT: + decodedcontroller.type = leverage_ctrl_t::type_controlchange; + decodedcontroller.controller_number = 29; + break; + case _lev_ctrl_CC30_EXT: + decodedcontroller.type = leverage_ctrl_t::type_controlchange; + decodedcontroller.controller_number = 30; + break; + case _lev_ctrl_CC31_EXT: + decodedcontroller.type = leverage_ctrl_t::type_controlchange; + decodedcontroller.controller_number = 31; + break; + case _lev_ctrl_CC68_EXT: + decodedcontroller.type = leverage_ctrl_t::type_controlchange; + decodedcontroller.controller_number = 68; + break; + case _lev_ctrl_CC69_EXT: + decodedcontroller.type = leverage_ctrl_t::type_controlchange; + decodedcontroller.controller_number = 69; + break; + case _lev_ctrl_CC70_EXT: + decodedcontroller.type = leverage_ctrl_t::type_controlchange; + decodedcontroller.controller_number = 70; + break; + case _lev_ctrl_CC71_EXT: + decodedcontroller.type = leverage_ctrl_t::type_controlchange; + decodedcontroller.controller_number = 71; + break; + case _lev_ctrl_CC72_EXT: + decodedcontroller.type = leverage_ctrl_t::type_controlchange; + decodedcontroller.controller_number = 72; + break; + case _lev_ctrl_CC73_EXT: + decodedcontroller.type = leverage_ctrl_t::type_controlchange; + decodedcontroller.controller_number = 73; + break; + case _lev_ctrl_CC74_EXT: + decodedcontroller.type = leverage_ctrl_t::type_controlchange; + decodedcontroller.controller_number = 74; + break; + case _lev_ctrl_CC75_EXT: + decodedcontroller.type = leverage_ctrl_t::type_controlchange; + decodedcontroller.controller_number = 75; + break; + case _lev_ctrl_CC76_EXT: + decodedcontroller.type = leverage_ctrl_t::type_controlchange; + decodedcontroller.controller_number = 76; + break; + case _lev_ctrl_CC77_EXT: + decodedcontroller.type = leverage_ctrl_t::type_controlchange; + decodedcontroller.controller_number = 77; + break; + case _lev_ctrl_CC78_EXT: + decodedcontroller.type = leverage_ctrl_t::type_controlchange; + decodedcontroller.controller_number = 78; + break; + case _lev_ctrl_CC79_EXT: + decodedcontroller.type = leverage_ctrl_t::type_controlchange; + decodedcontroller.controller_number = 79; + break; + case _lev_ctrl_CC84_EXT: + decodedcontroller.type = leverage_ctrl_t::type_controlchange; + decodedcontroller.controller_number = 84; + break; + case _lev_ctrl_CC85_EXT: + decodedcontroller.type = leverage_ctrl_t::type_controlchange; + decodedcontroller.controller_number = 85; + break; + case _lev_ctrl_CC86_EXT: + decodedcontroller.type = leverage_ctrl_t::type_controlchange; + decodedcontroller.controller_number = 86; + break; + case _lev_ctrl_CC87_EXT: + decodedcontroller.type = leverage_ctrl_t::type_controlchange; + decodedcontroller.controller_number = 87; + break; + case _lev_ctrl_CC89_EXT: + decodedcontroller.type = leverage_ctrl_t::type_controlchange; + decodedcontroller.controller_number = 89; + break; + case _lev_ctrl_CC90_EXT: + decodedcontroller.type = leverage_ctrl_t::type_controlchange; + decodedcontroller.controller_number = 90; + break; + case _lev_ctrl_CC96_EXT: + decodedcontroller.type = leverage_ctrl_t::type_controlchange; + decodedcontroller.controller_number = 96; + break; + case _lev_ctrl_CC97_EXT: + decodedcontroller.type = leverage_ctrl_t::type_controlchange; + decodedcontroller.controller_number = 97; + break; + case _lev_ctrl_CC102_EXT: + decodedcontroller.type = leverage_ctrl_t::type_controlchange; + decodedcontroller.controller_number = 102; + break; + case _lev_ctrl_CC103_EXT: + decodedcontroller.type = leverage_ctrl_t::type_controlchange; + decodedcontroller.controller_number = 103; + break; + case _lev_ctrl_CC104_EXT: + decodedcontroller.type = leverage_ctrl_t::type_controlchange; + decodedcontroller.controller_number = 104; + break; + case _lev_ctrl_CC105_EXT: + decodedcontroller.type = leverage_ctrl_t::type_controlchange; + decodedcontroller.controller_number = 105; + break; + case _lev_ctrl_CC106_EXT: + decodedcontroller.type = leverage_ctrl_t::type_controlchange; + decodedcontroller.controller_number = 106; + break; + case _lev_ctrl_CC107_EXT: + decodedcontroller.type = leverage_ctrl_t::type_controlchange; + decodedcontroller.controller_number = 107; + break; + case _lev_ctrl_CC108_EXT: + decodedcontroller.type = leverage_ctrl_t::type_controlchange; + decodedcontroller.controller_number = 108; + break; + case _lev_ctrl_CC109_EXT: + decodedcontroller.type = leverage_ctrl_t::type_controlchange; + decodedcontroller.controller_number = 109; + break; + case _lev_ctrl_CC110_EXT: + decodedcontroller.type = leverage_ctrl_t::type_controlchange; + decodedcontroller.controller_number = 110; + break; + case _lev_ctrl_CC111_EXT: + decodedcontroller.type = leverage_ctrl_t::type_controlchange; + decodedcontroller.controller_number = 111; + break; + case _lev_ctrl_CC112_EXT: + decodedcontroller.type = leverage_ctrl_t::type_controlchange; + decodedcontroller.controller_number = 112; + break; + case _lev_ctrl_CC113_EXT: + decodedcontroller.type = leverage_ctrl_t::type_controlchange; + decodedcontroller.controller_number = 113; + break; + case _lev_ctrl_CC114_EXT: + decodedcontroller.type = leverage_ctrl_t::type_controlchange; + decodedcontroller.controller_number = 114; + break; + case _lev_ctrl_CC115_EXT: + decodedcontroller.type = leverage_ctrl_t::type_controlchange; + decodedcontroller.controller_number = 115; + break; + case _lev_ctrl_CC116_EXT: + decodedcontroller.type = leverage_ctrl_t::type_controlchange; + decodedcontroller.controller_number = 116; + break; + case _lev_ctrl_CC117_EXT: + decodedcontroller.type = leverage_ctrl_t::type_controlchange; + decodedcontroller.controller_number = 117; + break; + case _lev_ctrl_CC118_EXT: + decodedcontroller.type = leverage_ctrl_t::type_controlchange; + decodedcontroller.controller_number = 118; + break; + case _lev_ctrl_CC119_EXT: + decodedcontroller.type = leverage_ctrl_t::type_controlchange; + decodedcontroller.controller_number = 119; + break; + // unknown controller type default: throw gig::Exception("Unknown leverage controller type."); } return decodedcontroller; } + +// see above (diagnostic push not supported prior GCC 4.6) +//#pragma GCC diagnostic pop DimensionRegion::_lev_ctrl_t DimensionRegion::EncodeLeverageController(leverage_ctrl_t DecodedController) { _lev_ctrl_t encodedcontroller; @@ -2190,6 +2542,188 @@ case 95: encodedcontroller = _lev_ctrl_effect5depth; break; + + // format extension (these controllers are so far only + // supported by LinuxSampler & gigedit) they will *NOT* + // work with Gigasampler/GigaStudio ! + case 3: + encodedcontroller = _lev_ctrl_CC3_EXT; + break; + case 6: + encodedcontroller = _lev_ctrl_CC6_EXT; + break; + case 7: + encodedcontroller = _lev_ctrl_CC7_EXT; + break; + case 8: + encodedcontroller = _lev_ctrl_CC8_EXT; + break; + case 9: + encodedcontroller = _lev_ctrl_CC9_EXT; + break; + case 10: + encodedcontroller = _lev_ctrl_CC10_EXT; + break; + case 11: + encodedcontroller = _lev_ctrl_CC11_EXT; + break; + case 14: + encodedcontroller = _lev_ctrl_CC14_EXT; + break; + case 15: + encodedcontroller = _lev_ctrl_CC15_EXT; + break; + case 20: + encodedcontroller = _lev_ctrl_CC20_EXT; + break; + case 21: + encodedcontroller = _lev_ctrl_CC21_EXT; + break; + case 22: + encodedcontroller = _lev_ctrl_CC22_EXT; + break; + case 23: + encodedcontroller = _lev_ctrl_CC23_EXT; + break; + case 24: + encodedcontroller = _lev_ctrl_CC24_EXT; + break; + case 25: + encodedcontroller = _lev_ctrl_CC25_EXT; + break; + case 26: + encodedcontroller = _lev_ctrl_CC26_EXT; + break; + case 27: + encodedcontroller = _lev_ctrl_CC27_EXT; + break; + case 28: + encodedcontroller = _lev_ctrl_CC28_EXT; + break; + case 29: + encodedcontroller = _lev_ctrl_CC29_EXT; + break; + case 30: + encodedcontroller = _lev_ctrl_CC30_EXT; + break; + case 31: + encodedcontroller = _lev_ctrl_CC31_EXT; + break; + case 68: + encodedcontroller = _lev_ctrl_CC68_EXT; + break; + case 69: + encodedcontroller = _lev_ctrl_CC69_EXT; + break; + case 70: + encodedcontroller = _lev_ctrl_CC70_EXT; + break; + case 71: + encodedcontroller = _lev_ctrl_CC71_EXT; + break; + case 72: + encodedcontroller = _lev_ctrl_CC72_EXT; + break; + case 73: + encodedcontroller = _lev_ctrl_CC73_EXT; + break; + case 74: + encodedcontroller = _lev_ctrl_CC74_EXT; + break; + case 75: + encodedcontroller = _lev_ctrl_CC75_EXT; + break; + case 76: + encodedcontroller = _lev_ctrl_CC76_EXT; + break; + case 77: + encodedcontroller = _lev_ctrl_CC77_EXT; + break; + case 78: + encodedcontroller = _lev_ctrl_CC78_EXT; + break; + case 79: + encodedcontroller = _lev_ctrl_CC79_EXT; + break; + case 84: + encodedcontroller = _lev_ctrl_CC84_EXT; + break; + case 85: + encodedcontroller = _lev_ctrl_CC85_EXT; + break; + case 86: + encodedcontroller = _lev_ctrl_CC86_EXT; + break; + case 87: + encodedcontroller = _lev_ctrl_CC87_EXT; + break; + case 89: + encodedcontroller = _lev_ctrl_CC89_EXT; + break; + case 90: + encodedcontroller = _lev_ctrl_CC90_EXT; + break; + case 96: + encodedcontroller = _lev_ctrl_CC96_EXT; + break; + case 97: + encodedcontroller = _lev_ctrl_CC97_EXT; + break; + case 102: + encodedcontroller = _lev_ctrl_CC102_EXT; + break; + case 103: + encodedcontroller = _lev_ctrl_CC103_EXT; + break; + case 104: + encodedcontroller = _lev_ctrl_CC104_EXT; + break; + case 105: + encodedcontroller = _lev_ctrl_CC105_EXT; + break; + case 106: + encodedcontroller = _lev_ctrl_CC106_EXT; + break; + case 107: + encodedcontroller = _lev_ctrl_CC107_EXT; + break; + case 108: + encodedcontroller = _lev_ctrl_CC108_EXT; + break; + case 109: + encodedcontroller = _lev_ctrl_CC109_EXT; + break; + case 110: + encodedcontroller = _lev_ctrl_CC110_EXT; + break; + case 111: + encodedcontroller = _lev_ctrl_CC111_EXT; + break; + case 112: + encodedcontroller = _lev_ctrl_CC112_EXT; + break; + case 113: + encodedcontroller = _lev_ctrl_CC113_EXT; + break; + case 114: + encodedcontroller = _lev_ctrl_CC114_EXT; + break; + case 115: + encodedcontroller = _lev_ctrl_CC115_EXT; + break; + case 116: + encodedcontroller = _lev_ctrl_CC116_EXT; + break; + case 117: + encodedcontroller = _lev_ctrl_CC117_EXT; + break; + case 118: + encodedcontroller = _lev_ctrl_CC118_EXT; + break; + case 119: + encodedcontroller = _lev_ctrl_CC119_EXT; + break; + default: throw gig::Exception("leverage controller number is not supported by the gig format"); } @@ -2667,6 +3201,18 @@ * dimension bits limit is violated */ void Region::AddDimension(dimension_def_t* pDimDef) { + // some initial sanity checks of the given dimension definition + if (pDimDef->zones < 2) + throw gig::Exception("Could not add new dimension, amount of requested zones must always be at least two"); + if (pDimDef->bits < 1) + throw gig::Exception("Could not add new dimension, amount of requested requested zone bits must always be at least one"); + if (pDimDef->dimension == dimension_samplechannel) { + if (pDimDef->zones != 2) + throw gig::Exception("Could not add new 'sample channel' dimensions, the requested amount of zones must always be 2 for this dimension type"); + if (pDimDef->bits != 1) + throw gig::Exception("Could not add new 'sample channel' dimensions, the requested amount of zone bits must always be 1 for this dimension type"); + } + // check if max. amount of dimensions reached File* file = (File*) GetParent()->GetParent(); const int iMaxDimensions = (file->pVersion && file->pVersion->major == 3) ? 8 : 5; @@ -2842,6 +3388,22 @@ if (pDimDef->dimension == dimension_layer) Layers = 1; } + /** + * Searches in the current Region for a dimension of the given dimension + * type and returns the precise configuration of that dimension in this + * Region. + * + * @param type - dimension type of the sought dimension + * @returns dimension definition or NULL if there is no dimension with + * sought type in this Region. + */ + dimension_def_t* Region::GetDimensionDefinition(dimension_t type) { + for (int i = 0; i < Dimensions; ++i) + if (pDimensionDefinitions[i].dimension == type) + return &pDimensionDefinitions[i]; + return NULL; + } + Region::~Region() { for (int i = 0; i < 256; i++) { if (pDimensionRegions[i]) delete pDimensionRegions[i]; @@ -2972,9 +3534,24 @@ * @param orig - original Region object to be copied from */ void Region::CopyAssign(const Region* orig) { + CopyAssign(orig, NULL); + } + + /** + * Make a (semi) deep copy of the Region object given by @a orig and + * assign it to this object + * + * @param mSamples - crosslink map between the foreign file's samples and + * this file's samples + */ + void Region::CopyAssign(const Region* orig, const std::map* mSamples) { // handle base classes DLS::Region::CopyAssign(orig); + if (mSamples && mSamples->count((gig::Sample*)orig->pSample)) { + pSample = mSamples->find((gig::Sample*)orig->pSample)->second; + } + // handle own member variables for (int i = Dimensions - 1; i >= 0; --i) { DeleteDimension(&pDimensionDefinitions[i]); @@ -2989,7 +3566,8 @@ for (int i = 0; i < 256; i++) { if (pDimensionRegions[i] && orig->pDimensionRegions[i]) { pDimensionRegions[i]->CopyAssign( - orig->pDimensionRegions[i] + orig->pDimensionRegions[i], + mSamples ); } } @@ -3000,24 +3578,168 @@ // *************** MidiRule *************** // * -MidiRuleCtrlTrigger::MidiRuleCtrlTrigger(RIFF::Chunk* _3ewg) { - _3ewg->SetPos(36); - Triggers = _3ewg->ReadUint8(); - _3ewg->SetPos(40); - ControllerNumber = _3ewg->ReadUint8(); - _3ewg->SetPos(46); - for (int i = 0 ; i < Triggers ; i++) { - pTriggers[i].TriggerPoint = _3ewg->ReadUint8(); - pTriggers[i].Descending = _3ewg->ReadUint8(); - pTriggers[i].VelSensitivity = _3ewg->ReadUint8(); - pTriggers[i].Key = _3ewg->ReadUint8(); - pTriggers[i].NoteOff = _3ewg->ReadUint8(); - pTriggers[i].Velocity = _3ewg->ReadUint8(); - pTriggers[i].OverridePedal = _3ewg->ReadUint8(); - _3ewg->ReadUint8(); + MidiRuleCtrlTrigger::MidiRuleCtrlTrigger(RIFF::Chunk* _3ewg) { + _3ewg->SetPos(36); + Triggers = _3ewg->ReadUint8(); + _3ewg->SetPos(40); + ControllerNumber = _3ewg->ReadUint8(); + _3ewg->SetPos(46); + for (int i = 0 ; i < Triggers ; i++) { + pTriggers[i].TriggerPoint = _3ewg->ReadUint8(); + pTriggers[i].Descending = _3ewg->ReadUint8(); + pTriggers[i].VelSensitivity = _3ewg->ReadUint8(); + pTriggers[i].Key = _3ewg->ReadUint8(); + pTriggers[i].NoteOff = _3ewg->ReadUint8(); + pTriggers[i].Velocity = _3ewg->ReadUint8(); + pTriggers[i].OverridePedal = _3ewg->ReadUint8(); + _3ewg->ReadUint8(); + } + } + + MidiRuleCtrlTrigger::MidiRuleCtrlTrigger() : + ControllerNumber(0), + Triggers(0) { + } + + void MidiRuleCtrlTrigger::UpdateChunks(uint8_t* pData) const { + pData[32] = 4; + pData[33] = 16; + pData[36] = Triggers; + pData[40] = ControllerNumber; + for (int i = 0 ; i < Triggers ; i++) { + pData[46 + i * 8] = pTriggers[i].TriggerPoint; + pData[47 + i * 8] = pTriggers[i].Descending; + pData[48 + i * 8] = pTriggers[i].VelSensitivity; + pData[49 + i * 8] = pTriggers[i].Key; + pData[50 + i * 8] = pTriggers[i].NoteOff; + pData[51 + i * 8] = pTriggers[i].Velocity; + pData[52 + i * 8] = pTriggers[i].OverridePedal; + } + } + + MidiRuleLegato::MidiRuleLegato(RIFF::Chunk* _3ewg) { + _3ewg->SetPos(36); + LegatoSamples = _3ewg->ReadUint8(); // always 12 + _3ewg->SetPos(40); + BypassUseController = _3ewg->ReadUint8(); + BypassKey = _3ewg->ReadUint8(); + BypassController = _3ewg->ReadUint8(); + ThresholdTime = _3ewg->ReadUint16(); + _3ewg->ReadInt16(); + ReleaseTime = _3ewg->ReadUint16(); + _3ewg->ReadInt16(); + KeyRange.low = _3ewg->ReadUint8(); + KeyRange.high = _3ewg->ReadUint8(); + _3ewg->SetPos(64); + ReleaseTriggerKey = _3ewg->ReadUint8(); + AltSustain1Key = _3ewg->ReadUint8(); + AltSustain2Key = _3ewg->ReadUint8(); + } + + MidiRuleLegato::MidiRuleLegato() : + LegatoSamples(12), + BypassUseController(false), + BypassKey(0), + BypassController(1), + ThresholdTime(20), + ReleaseTime(20), + ReleaseTriggerKey(0), + AltSustain1Key(0), + AltSustain2Key(0) + { + KeyRange.low = KeyRange.high = 0; + } + + void MidiRuleLegato::UpdateChunks(uint8_t* pData) const { + pData[32] = 0; + pData[33] = 16; + pData[36] = LegatoSamples; + pData[40] = BypassUseController; + pData[41] = BypassKey; + pData[42] = BypassController; + store16(&pData[43], ThresholdTime); + store16(&pData[47], ReleaseTime); + pData[51] = KeyRange.low; + pData[52] = KeyRange.high; + pData[64] = ReleaseTriggerKey; + pData[65] = AltSustain1Key; + pData[66] = AltSustain2Key; + } + + MidiRuleAlternator::MidiRuleAlternator(RIFF::Chunk* _3ewg) { + _3ewg->SetPos(36); + Articulations = _3ewg->ReadUint8(); + int flags = _3ewg->ReadUint8(); + Polyphonic = flags & 8; + Chained = flags & 4; + Selector = (flags & 2) ? selector_controller : + (flags & 1) ? selector_key_switch : selector_none; + Patterns = _3ewg->ReadUint8(); + _3ewg->ReadUint8(); // chosen row + _3ewg->ReadUint8(); // unknown + _3ewg->ReadUint8(); // unknown + _3ewg->ReadUint8(); // unknown + KeySwitchRange.low = _3ewg->ReadUint8(); + KeySwitchRange.high = _3ewg->ReadUint8(); + Controller = _3ewg->ReadUint8(); + PlayRange.low = _3ewg->ReadUint8(); + PlayRange.high = _3ewg->ReadUint8(); + + int n = std::min(int(Articulations), 32); + for (int i = 0 ; i < n ; i++) { + _3ewg->ReadString(pArticulations[i], 32); + } + _3ewg->SetPos(1072); + n = std::min(int(Patterns), 32); + for (int i = 0 ; i < n ; i++) { + _3ewg->ReadString(pPatterns[i].Name, 16); + pPatterns[i].Size = _3ewg->ReadUint8(); + _3ewg->Read(&pPatterns[i][0], 1, 32); + } } -} + MidiRuleAlternator::MidiRuleAlternator() : + Articulations(0), + Patterns(0), + Selector(selector_none), + Controller(0), + Polyphonic(false), + Chained(false) + { + PlayRange.low = PlayRange.high = 0; + KeySwitchRange.low = KeySwitchRange.high = 0; + } + + void MidiRuleAlternator::UpdateChunks(uint8_t* pData) const { + pData[32] = 3; + pData[33] = 16; + pData[36] = Articulations; + pData[37] = (Polyphonic ? 8 : 0) | (Chained ? 4 : 0) | + (Selector == selector_controller ? 2 : + (Selector == selector_key_switch ? 1 : 0)); + pData[38] = Patterns; + + pData[43] = KeySwitchRange.low; + pData[44] = KeySwitchRange.high; + pData[45] = Controller; + pData[46] = PlayRange.low; + pData[47] = PlayRange.high; + + char* str = reinterpret_cast(pData); + int pos = 48; + int n = std::min(int(Articulations), 32); + for (int i = 0 ; i < n ; i++, pos += 32) { + strncpy(&str[pos], pArticulations[i].c_str(), 32); + } + + pos = 1072; + n = std::min(int(Patterns), 32); + for (int i = 0 ; i < n ; i++, pos += 49) { + strncpy(&str[pos], pPatterns[i].Name.c_str(), 16); + pData[pos + 16] = pPatterns[i].Size; + memcpy(&pData[pos + 16], &(pPatterns[i][0]), 32); + } + } // *************** Instrument *************** // * @@ -3063,8 +3785,19 @@ uint8_t id1 = _3ewg->ReadUint8(); uint8_t id2 = _3ewg->ReadUint8(); - if (id1 == 4 && id2 == 16) { - pMidiRules[i++] = new MidiRuleCtrlTrigger(_3ewg); + if (id2 == 16) { + if (id1 == 4) { + pMidiRules[i++] = new MidiRuleCtrlTrigger(_3ewg); + } else if (id1 == 0) { + pMidiRules[i++] = new MidiRuleLegato(_3ewg); + } else if (id1 == 3) { + pMidiRules[i++] = new MidiRuleAlternator(_3ewg); + } else { + pMidiRules[i++] = new MidiRuleUnknown; + } + } + else if (id1 != 0 || id2 != 0) { + pMidiRules[i++] = new MidiRuleUnknown; } //TODO: all the other types of rules @@ -3156,6 +3889,15 @@ DimensionKeyRange.low << 1; pData[10] = dimkeystart; pData[11] = DimensionKeyRange.high; + + if (pMidiRules[0] == 0 && _3ewg->GetSize() >= 34) { + pData[32] = 0; + pData[33] = 0; + } else { + for (int i = 0 ; pMidiRules[i] ; i++) { + pMidiRules[i]->UpdateChunks(pData); + } + } } /** @@ -3237,7 +3979,56 @@ MidiRule* Instrument::GetMidiRule(int i) { return pMidiRules[i]; } - + + /** + * Adds the "controller trigger" MIDI rule to the instrument. + * + * @returns the new MIDI rule + */ + MidiRuleCtrlTrigger* Instrument::AddMidiRuleCtrlTrigger() { + delete pMidiRules[0]; + MidiRuleCtrlTrigger* r = new MidiRuleCtrlTrigger; + pMidiRules[0] = r; + pMidiRules[1] = 0; + return r; + } + + /** + * Adds the legato MIDI rule to the instrument. + * + * @returns the new MIDI rule + */ + MidiRuleLegato* Instrument::AddMidiRuleLegato() { + delete pMidiRules[0]; + MidiRuleLegato* r = new MidiRuleLegato; + pMidiRules[0] = r; + pMidiRules[1] = 0; + return r; + } + + /** + * Adds the alternator MIDI rule to the instrument. + * + * @returns the new MIDI rule + */ + MidiRuleAlternator* Instrument::AddMidiRuleAlternator() { + delete pMidiRules[0]; + MidiRuleAlternator* r = new MidiRuleAlternator; + pMidiRules[0] = r; + pMidiRules[1] = 0; + return r; + } + + /** + * Deletes a MIDI rule from the instrument. + * + * @param i - MIDI rule number + */ + void Instrument::DeleteMidiRule(int i) { + delete pMidiRules[i]; + pMidiRules[i] = 0; + } + /** * Make a (semi) deep copy of the Instrument object given by @a orig * and assign it to this object. @@ -3248,6 +4039,18 @@ * @param orig - original Instrument object to be copied from */ void Instrument::CopyAssign(const Instrument* orig) { + CopyAssign(orig, NULL); + } + + /** + * Make a (semi) deep copy of the Instrument object given by @a orig + * and assign it to this object. + * + * @param orig - original Instrument object to be copied from + * @param mSamples - crosslink map between the foreign file's samples and + * this file's samples + */ + void Instrument::CopyAssign(const Instrument* orig, const std::map* mSamples) { // handle base class // (without copying DLS region stuff) DLS::Instrument::CopyAssignCore(orig); @@ -3276,7 +4079,8 @@ Region* dstRgn = AddRegion(); //NOTE: Region does semi-deep copy ! dstRgn->CopyAssign( - static_cast(*it) + static_cast(*it), + mSamples ); } } @@ -3485,6 +4289,23 @@ SamplesIterator++; return static_cast( (SamplesIterator != pSamples->end()) ? *SamplesIterator : NULL ); } + + /** + * Returns Sample object of @a index. + * + * @returns sample object or NULL if index is out of bounds + */ + Sample* File::GetSample(uint index) { + if (!pSamples) LoadSamples(); + if (!pSamples) return NULL; + DLS::File::SampleList::iterator it = pSamples->begin(); + for (int i = 0; i < index; ++i) { + ++it; + if (it == pSamples->end()) return NULL; + } + if (it == pSamples->end()) return NULL; + return static_cast( *it ); + } /** @brief Add a new sample. * @@ -3703,6 +4524,69 @@ instr->CopyAssign(orig); return instr; } + + /** @brief Add content of another existing file. + * + * Duplicates the samples, groups and instruments of the original file + * given by @a pFile and adds them to @c this File. In case @c this File is + * a new one that you haven't saved before, then you have to call + * SetFileName() before calling AddContentOf(), because this method will + * automatically save this file during operation, which is required for + * writing the sample waveform data by disk streaming. + * + * @param pFile - original file whose's content shall be copied from + */ + void File::AddContentOf(File* pFile) { + static int iCallCount = -1; + iCallCount++; + std::map mGroups; + std::map mSamples; + + // clone sample groups + for (int i = 0; pFile->GetGroup(i); ++i) { + Group* g = AddGroup(); + g->Name = + "COPY" + ToString(iCallCount) + "_" + pFile->GetGroup(i)->Name; + mGroups[pFile->GetGroup(i)] = g; + } + + // clone samples (not waveform data here yet) + for (int i = 0; pFile->GetSample(i); ++i) { + Sample* s = AddSample(); + s->CopyAssignMeta(pFile->GetSample(i)); + mGroups[pFile->GetSample(i)->GetGroup()]->AddSample(s); + mSamples[pFile->GetSample(i)] = s; + } + + //BUG: For some reason this method only works with this additional + // Save() call in between here. + // + // Important: The correct one of the 2 Save() methods has to be called + // here, depending on whether the file is completely new or has been + // saved to disk already, otherwise it will result in data corruption. + if (pRIFF->IsNew()) + Save(GetFileName()); + else + Save(); + + // clone instruments + // (passing the crosslink table here for the cloned samples) + for (int i = 0; pFile->GetInstrument(i); ++i) { + Instrument* instr = AddInstrument(); + instr->CopyAssign(pFile->GetInstrument(i), &mSamples); + } + + // Mandatory: file needs to be saved to disk at this point, so this + // file has the correct size and data layout for writing the samples' + // waveform data to disk. + Save(); + + // clone samples' waveform data + // (using direct read & write disk streaming) + for (int i = 0; pFile->GetSample(i); ++i) { + mSamples[pFile->GetSample(i)]->CopyAssignWave(pFile->GetSample(i)); + } + } /** @brief Delete an instrument. * @@ -3805,6 +4689,24 @@ return NULL; } + /** + * Returns the group with the given group name. + * + * Note: group names don't have to be unique in the gig format! So there + * can be multiple groups with the same name. This method will simply + * return the first group found with the given name. + * + * @param name - name of the sought group + * @returns sought group or NULL if there's no group with that name + */ + Group* File::GetGroup(String name) { + if (!pGroups) LoadGroups(); + GroupsIterator = pGroups->begin(); + for (uint i = 0; GroupsIterator != pGroups->end(); ++GroupsIterator, ++i) + if ((*GroupsIterator)->Name == name) return *GroupsIterator; + return NULL; + } + Group* File::AddGroup() { if (!pGroups) LoadGroups(); // there must always be at least one group @@ -3915,21 +4817,31 @@ // update group's chunks if (pGroups) { - std::list::iterator iter = pGroups->begin(); - std::list::iterator end = pGroups->end(); - for (; iter != end; ++iter) { - (*iter)->UpdateChunks(); + // make sure '3gri' and '3gnl' list chunks exist + // (before updating the Group chunks) + RIFF::List* _3gri = pRIFF->GetSubList(LIST_TYPE_3GRI); + if (!_3gri) { + _3gri = pRIFF->AddSubList(LIST_TYPE_3GRI); + pRIFF->MoveSubChunk(_3gri, pRIFF->GetSubChunk(CHUNK_ID_PTBL)); } + RIFF::List* _3gnl = _3gri->GetSubList(LIST_TYPE_3GNL); + if (!_3gnl) _3gnl = _3gri->AddSubList(LIST_TYPE_3GNL); // v3: make sure the file has 128 3gnm chunks + // (before updating the Group chunks) if (pVersion && pVersion->major == 3) { - RIFF::List* _3gnl = pRIFF->GetSubList(LIST_TYPE_3GRI)->GetSubList(LIST_TYPE_3GNL); RIFF::Chunk* _3gnm = _3gnl->GetFirstSubChunk(); for (int i = 0 ; i < 128 ; i++) { if (i >= pGroups->size()) ::SaveString(CHUNK_ID_3GNM, _3gnm, _3gnl, "", "", true, 64); if (_3gnm) _3gnm = _3gnl->GetNextSubChunk(); } } + + std::list::iterator iter = pGroups->begin(); + std::list::iterator end = pGroups->end(); + for (; iter != end; ++iter) { + (*iter)->UpdateChunks(); + } } // update einf chunk