--- libgig/trunk/src/gig.cpp 2017/04/16 23:20:30 3117 +++ libgig/trunk/src/gig.cpp 2017/10/03 15:05:45 3348 @@ -24,6 +24,7 @@ #include "gig.h" #include "helper.h" +#include "Serialization.h" #include #include @@ -55,6 +56,9 @@ #define GIG_EG_CTR_DECAY_INFLUENCE_ENCODE(x) ((x & 0x03) << 3) #define GIG_EG_CTR_RELEASE_INFLUENCE_ENCODE(x) ((x & 0x03) << 5) +#define SRLZ(member) \ + archive->serializeMember(*this, member, #member); + namespace gig { // *************** Internal functions for sample decompression *************** @@ -315,6 +319,49 @@ +// *************** leverage_ctrl_t *************** +// * + + void leverage_ctrl_t::serialize(Serialization::Archive* archive) { + SRLZ(type); + SRLZ(controller_number); + } + + + +// *************** crossfade_t *************** +// * + + void crossfade_t::serialize(Serialization::Archive* archive) { + SRLZ(in_start); + SRLZ(in_end); + SRLZ(out_start); + SRLZ(out_end); + } + + + +// *************** eg_opt_t *************** +// * + + eg_opt_t::eg_opt_t() { + AttackCancel = true; + AttackHoldCancel = true; + Decay1Cancel = true; + Decay2Cancel = true; + ReleaseCancel = true; + } + + void eg_opt_t::serialize(Serialization::Archive* archive) { + SRLZ(AttackCancel); + SRLZ(AttackHoldCancel); + SRLZ(Decay1Cancel); + SRLZ(Decay2Cancel); + SRLZ(ReleaseCancel); + } + + + // *************** Sample *************** // * @@ -1685,6 +1732,20 @@ VCFType = vcf_type_lowpass; memset(DimensionUpperLimits, 127, 8); } + // format extension for EG behavior options, these will *NOT* work with + // Gigasampler/GigaStudio ! + RIFF::Chunk* lsde = _3ewl->GetSubChunk(CHUNK_ID_LSDE); + if (lsde) { + eg_opt_t* pEGOpts[2] = { &EG1Options, &EG2Options }; + for (int i = 0; i < 2; ++i) { + unsigned char byte = lsde->ReadUint8(); + pEGOpts[i]->AttackCancel = byte & 1; + pEGOpts[i]->AttackHoldCancel = byte & (1 << 1); + pEGOpts[i]->Decay1Cancel = byte & (1 << 2); + pEGOpts[i]->Decay2Cancel = byte & (1 << 3); + pEGOpts[i]->ReleaseCancel = byte & (1 << 4); + } + } pVelocityAttenuationTable = GetVelocityTable(VelocityResponseCurve, VelocityResponseDepth, @@ -1790,6 +1851,97 @@ } } + void DimensionRegion::serialize(Serialization::Archive* archive) { + // in case this class will become backward incompatible one day, + // then set a version and minimum version for this class like: + //archive->setVersion(*this, 2); + //archive->setMinVersion(*this, 1); + + SRLZ(VelocityUpperLimit); + SRLZ(EG1PreAttack); + SRLZ(EG1Attack); + SRLZ(EG1Decay1); + SRLZ(EG1Decay2); + SRLZ(EG1InfiniteSustain); + SRLZ(EG1Sustain); + SRLZ(EG1Release); + SRLZ(EG1Hold); + SRLZ(EG1Controller); + SRLZ(EG1ControllerInvert); + SRLZ(EG1ControllerAttackInfluence); + SRLZ(EG1ControllerDecayInfluence); + SRLZ(EG1ControllerReleaseInfluence); + SRLZ(LFO1Frequency); + SRLZ(LFO1InternalDepth); + SRLZ(LFO1ControlDepth); + SRLZ(LFO1Controller); + SRLZ(LFO1FlipPhase); + SRLZ(LFO1Sync); + SRLZ(EG2PreAttack); + SRLZ(EG2Attack); + SRLZ(EG2Decay1); + SRLZ(EG2Decay2); + SRLZ(EG2InfiniteSustain); + SRLZ(EG2Sustain); + SRLZ(EG2Release); + SRLZ(EG2Controller); + SRLZ(EG2ControllerInvert); + SRLZ(EG2ControllerAttackInfluence); + SRLZ(EG2ControllerDecayInfluence); + SRLZ(EG2ControllerReleaseInfluence); + SRLZ(LFO2Frequency); + SRLZ(LFO2InternalDepth); + SRLZ(LFO2ControlDepth); + SRLZ(LFO2Controller); + SRLZ(LFO2FlipPhase); + SRLZ(LFO2Sync); + SRLZ(EG3Attack); + SRLZ(EG3Depth); + SRLZ(LFO3Frequency); + SRLZ(LFO3InternalDepth); + SRLZ(LFO3ControlDepth); + SRLZ(LFO3Controller); + SRLZ(LFO3Sync); + SRLZ(VCFEnabled); + SRLZ(VCFType); + SRLZ(VCFCutoffController); + SRLZ(VCFCutoffControllerInvert); + SRLZ(VCFCutoff); + SRLZ(VCFVelocityCurve); + SRLZ(VCFVelocityScale); + SRLZ(VCFVelocityDynamicRange); + SRLZ(VCFResonance); + SRLZ(VCFResonanceDynamic); + SRLZ(VCFResonanceController); + SRLZ(VCFKeyboardTracking); + SRLZ(VCFKeyboardTrackingBreakpoint); + SRLZ(VelocityResponseCurve); + SRLZ(VelocityResponseDepth); + SRLZ(VelocityResponseCurveScaling); + SRLZ(ReleaseVelocityResponseCurve); + SRLZ(ReleaseVelocityResponseDepth); + SRLZ(ReleaseTriggerDecay); + SRLZ(Crossfade); + SRLZ(PitchTrack); + SRLZ(DimensionBypass); + SRLZ(Pan); + SRLZ(SelfMask); + SRLZ(AttenuationController); + SRLZ(InvertAttenuationController); + SRLZ(AttenuationControllerThreshold); + SRLZ(ChannelOffset); + SRLZ(SustainDefeat); + SRLZ(MSDecode); + //SRLZ(SampleStartOffset); + SRLZ(SampleAttenuation); + SRLZ(EG1Options); + SRLZ(EG2Options); + + // derived attributes from DLS::Sampler + SRLZ(FineTune); + SRLZ(Gain); + } + /** * Updates the respective member variable and updates @c SampleAttenuation * which depends on this value. @@ -2090,6 +2242,34 @@ if (chunksize >= 148) { memcpy(&pData[140], DimensionUpperLimits, 8); } + + // format extension for EG behavior options, these will *NOT* work with + // Gigasampler/GigaStudio ! + RIFF::Chunk* lsde = pParentList->GetSubChunk(CHUNK_ID_LSDE); + if (!lsde) { + // only add this "LSDE" chunk if the EG options do not match the + // default EG behavior + eg_opt_t defaultOpt; + if (memcmp(&EG1Options, &defaultOpt, sizeof(eg_opt_t)) || + memcmp(&EG2Options, &defaultOpt, sizeof(eg_opt_t))) + { + lsde = pParentList->AddSubChunk(CHUNK_ID_LSDE, 2); + // move LSDE chunk to the end of parent list + pParentList->MoveSubChunk(lsde, (RIFF::Chunk*)NULL); + } + } + if (lsde) { + unsigned char* pData = (unsigned char*) lsde->LoadChunkData(); + eg_opt_t* pEGOpts[2] = { &EG1Options, &EG2Options }; + for (int i = 0; i < 2; ++i) { + pData[i] = + (pEGOpts[i]->AttackCancel ? 1 : 0) | + (pEGOpts[i]->AttackHoldCancel ? (1<<1) : 0) | + (pEGOpts[i]->Decay1Cancel ? (1<<2) : 0) | + (pEGOpts[i]->Decay2Cancel ? (1<<3) : 0) | + (pEGOpts[i]->ReleaseCancel ? (1<<4) : 0); + } + } } double* DimensionRegion::GetReleaseVelocityTable(curve_type_t releaseVelocityResponseCurve, uint8_t releaseVelocityResponseDepth) { @@ -2504,7 +2684,10 @@ // unknown controller type default: - throw gig::Exception("Unknown leverage controller type."); + decodedcontroller.type = leverage_ctrl_t::type_none; + decodedcontroller.controller_number = 0; + printf("Warning: Unknown leverage controller type (0x%x).\n", EncodedController); + break; } return decodedcontroller; } @@ -3051,7 +3234,8 @@ if (file->GetAutoLoad()) { for (uint i = 0; i < DimensionRegions; i++) { uint32_t wavepoolindex = _3lnk->ReadUint32(); - if (file->pWavePoolTable) pDimensionRegions[i]->pSample = GetSampleFromWavePool(wavepoolindex); + if (file->pWavePoolTable && pDimensionRegions[i]) + pDimensionRegions[i]->pSample = GetSampleFromWavePool(wavepoolindex); } GetSample(); // load global region sample reference } @@ -4558,7 +4742,9 @@ RegionList::iterator end = pRegions->end(); for (; iter != end; ++iter) { gig::Region* pRegion = static_cast(*iter); - for (int iKey = pRegion->KeyRange.low; iKey <= pRegion->KeyRange.high; iKey++) { + const int low = std::max(int(pRegion->KeyRange.low), 0); + const int high = std::min(int(pRegion->KeyRange.high), 127); + for (int iKey = low; iKey <= high; iKey++) { RegionKeyTable[iKey] = pRegion; } } @@ -6358,7 +6544,18 @@ // *************** Exception *************** // * - Exception::Exception(String Message) : DLS::Exception(Message) { + Exception::Exception() : DLS::Exception() { + } + + Exception::Exception(String format, ...) : DLS::Exception() { + va_list arg; + va_start(arg, format); + Message = assemble(format, arg); + va_end(arg); + } + + Exception::Exception(String format, va_list arg) : DLS::Exception() { + Message = assemble(format, arg); } void Exception::PrintMessage() {