31 # define __has_feature(x) 0 34 # if __GXX_RTTI || __has_feature(cxx_rtti) || _CPPRTTI 43 # warning No RTTI available! 47 # define LIST_TYPE_3PRG 0x33707267 48 # define LIST_TYPE_3EWL 0x3365776C 49 # define LIST_TYPE_3GRI 0x33677269 50 # define LIST_TYPE_3GNL 0x33676E6C 51 # define LIST_TYPE_3LS 0x334c5320 // own gig format extension 52 # define LIST_TYPE_RTIS 0x52544953 // own gig format extension 53 # define CHUNK_ID_3GIX 0x33676978 54 # define CHUNK_ID_3EWA 0x33657761 55 # define CHUNK_ID_3LNK 0x336C6E6B 56 # define CHUNK_ID_3EWG 0x33657767 57 # define CHUNK_ID_EWAV 0x65776176 58 # define CHUNK_ID_3GNM 0x33676E6D 59 # define CHUNK_ID_EINF 0x65696E66 60 # define CHUNK_ID_3CRC 0x33637263 61 # define CHUNK_ID_SCRI 0x53637269 // own gig format extension 62 # define CHUNK_ID_LSNM 0x4c534e4d // own gig format extension 63 # define CHUNK_ID_SCSL 0x5343534c // own gig format extension 64 # define CHUNK_ID_LSDE 0x4c534445 // own gig format extension 65 #else // little endian 66 # define LIST_TYPE_3PRG 0x67727033 67 # define LIST_TYPE_3EWL 0x6C776533 68 # define LIST_TYPE_3GRI 0x69726733 69 # define LIST_TYPE_3GNL 0x6C6E6733 70 # define LIST_TYPE_3LS 0x20534c33 // own gig format extension 71 # define LIST_TYPE_RTIS 0x53495452 // own gig format extension 72 # define CHUNK_ID_3GIX 0x78696733 73 # define CHUNK_ID_3EWA 0x61776533 74 # define CHUNK_ID_3LNK 0x6B6E6C33 75 # define CHUNK_ID_3EWG 0x67776533 76 # define CHUNK_ID_EWAV 0x76617765 77 # define CHUNK_ID_3GNM 0x6D6E6733 78 # define CHUNK_ID_EINF 0x666E6965 79 # define CHUNK_ID_3CRC 0x63726333 80 # define CHUNK_ID_SCRI 0x69726353 // own gig format extension 81 # define CHUNK_ID_LSNM 0x4d4e534c // own gig format extension 82 # define CHUNK_ID_SCSL 0x4c534353 // own gig format extension 83 # define CHUNK_ID_LSDE 0x4544534c // own gig format extension 84 #endif // WORDS_BIGENDIAN 86 #ifndef GIG_DECLARE_ENUM 87 # define GIG_DECLARE_ENUM(type, ...) enum type { __VA_ARGS__ } 96 typedef std::string String;
114 NullExtensionSize = 0;
122 GIG_DECLARE_ENUM(loop_type_t,
123 loop_type_normal = 0x00000000,
124 loop_type_bidirectional = 0x00000001,
125 loop_type_backward = 0x00000002
132 GIG_DECLARE_ENUM(smpte_format_t,
133 smpte_format_no_offset = 0x00000000,
134 smpte_format_24_frames = 0x00000018,
135 smpte_format_25_frames = 0x00000019,
136 smpte_format_30_frames_dropping = 0x0000001D,
137 smpte_format_30_frames = 0x0000001E
144 GIG_DECLARE_ENUM(curve_type_t,
145 curve_type_nonlinear = 0,
146 curve_type_linear = 1,
147 curve_type_special = 2,
148 curve_type_unknown = 0xffffffff
155 GIG_DECLARE_ENUM(dim_bypass_ctrl_t,
156 dim_bypass_ctrl_none,
165 GIG_DECLARE_ENUM(lfo3_ctrl_t,
166 lfo3_ctrl_internal = 0x00,
167 lfo3_ctrl_modwheel = 0x01,
168 lfo3_ctrl_aftertouch = 0x02,
169 lfo3_ctrl_internal_modwheel = 0x03,
170 lfo3_ctrl_internal_aftertouch = 0x04
177 GIG_DECLARE_ENUM(lfo2_ctrl_t,
178 lfo2_ctrl_internal = 0x00,
179 lfo2_ctrl_modwheel = 0x01,
180 lfo2_ctrl_foot = 0x02,
181 lfo2_ctrl_internal_modwheel = 0x03,
182 lfo2_ctrl_internal_foot = 0x04
189 GIG_DECLARE_ENUM(lfo1_ctrl_t,
190 lfo1_ctrl_internal = 0x00,
191 lfo1_ctrl_modwheel = 0x01,
192 lfo1_ctrl_breath = 0x02,
193 lfo1_ctrl_internal_modwheel = 0x03,
194 lfo1_ctrl_internal_breath = 0x04
201 GIG_DECLARE_ENUM(vcf_cutoff_ctrl_t,
202 vcf_cutoff_ctrl_none = 0x00,
203 vcf_cutoff_ctrl_none2 = 0x01,
204 vcf_cutoff_ctrl_modwheel = 0x81,
205 vcf_cutoff_ctrl_effect1 = 0x8c,
206 vcf_cutoff_ctrl_effect2 = 0x8d,
207 vcf_cutoff_ctrl_breath = 0x82,
208 vcf_cutoff_ctrl_foot = 0x84,
209 vcf_cutoff_ctrl_sustainpedal = 0xc0,
210 vcf_cutoff_ctrl_softpedal = 0xc3,
211 vcf_cutoff_ctrl_genpurpose7 = 0xd2,
212 vcf_cutoff_ctrl_genpurpose8 = 0xd3,
213 vcf_cutoff_ctrl_aftertouch = 0x80
220 GIG_DECLARE_ENUM(vcf_res_ctrl_t,
221 vcf_res_ctrl_none = 0xffffffff,
222 vcf_res_ctrl_genpurpose3 = 0,
223 vcf_res_ctrl_genpurpose4 = 1,
224 vcf_res_ctrl_genpurpose5 = 2,
225 vcf_res_ctrl_genpurpose6 = 3
236 struct leverage_ctrl_t {
241 GIG_DECLARE_ENUM(type_t,
243 type_channelaftertouch = 0x2f,
244 type_velocity = 0xff,
245 type_controlchange = 0xfe
249 uint controller_number;
259 typedef leverage_ctrl_t attenuation_ctrl_t;
266 typedef leverage_ctrl_t eg1_ctrl_t;
273 typedef leverage_ctrl_t eg2_ctrl_t;
284 GIG_DECLARE_ENUM(dimension_t,
285 dimension_none = 0x00,
286 dimension_samplechannel = 0x80,
287 dimension_layer = 0x81,
288 dimension_velocity = 0x82,
289 dimension_channelaftertouch = 0x83,
290 dimension_releasetrigger = 0x84,
291 dimension_keyboard = 0x85,
292 dimension_roundrobin = 0x86,
293 dimension_random = 0x87,
294 dimension_smartmidi = 0x88,
295 dimension_roundrobinkeyboard = 0x89,
296 dimension_modwheel = 0x01,
297 dimension_breath = 0x02,
298 dimension_foot = 0x04,
299 dimension_portamentotime = 0x05,
300 dimension_effect1 = 0x0c,
301 dimension_effect2 = 0x0d,
302 dimension_genpurpose1 = 0x10,
303 dimension_genpurpose2 = 0x11,
304 dimension_genpurpose3 = 0x12,
305 dimension_genpurpose4 = 0x13,
306 dimension_sustainpedal = 0x40,
307 dimension_portamento = 0x41,
308 dimension_sostenutopedal = 0x42,
309 dimension_softpedal = 0x43,
310 dimension_genpurpose5 = 0x30,
311 dimension_genpurpose6 = 0x31,
312 dimension_genpurpose7 = 0x32,
313 dimension_genpurpose8 = 0x33,
314 dimension_effect1depth = 0x5b,
315 dimension_effect2depth = 0x5c,
316 dimension_effect3depth = 0x5d,
317 dimension_effect4depth = 0x5e,
318 dimension_effect5depth = 0x5f
327 GIG_DECLARE_ENUM(split_type_t,
333 struct dimension_def_t {
334 dimension_t dimension;
337 split_type_t split_type;
345 GIG_DECLARE_ENUM(vcf_type_t,
346 vcf_type_lowpass = 0x00,
347 vcf_type_lowpassturbo = 0xff,
348 vcf_type_bandpass = 0x01,
349 vcf_type_highpass = 0x02,
350 vcf_type_bandreject = 0x03
366 #else // little endian 371 #endif // WORDS_BIGENDIAN 377 struct playback_state_t {
408 bool AttackHoldCancel;
433 GIG_DECLARE_ENUM(sust_rel_trg_t,
434 sust_rel_trg_none = 0x00,
435 sust_rel_trg_maxvelocity = 0x01,
436 sust_rel_trg_keyvelocity = 0x02
492 uint8_t VelocityUpperLimit;
495 uint16_t EG1PreAttack;
499 bool EG1InfiniteSustain;
503 eg1_ctrl_t EG1Controller;
504 bool EG1ControllerInvert;
505 uint8_t EG1ControllerAttackInfluence;
506 uint8_t EG1ControllerDecayInfluence;
507 uint8_t EG1ControllerReleaseInfluence;
508 double LFO1Frequency;
509 uint16_t LFO1InternalDepth;
510 uint16_t LFO1ControlDepth;
511 lfo1_ctrl_t LFO1Controller;
515 uint16_t EG2PreAttack;
519 bool EG2InfiniteSustain;
522 eg2_ctrl_t EG2Controller;
523 bool EG2ControllerInvert;
524 uint8_t EG2ControllerAttackInfluence;
525 uint8_t EG2ControllerDecayInfluence;
526 uint8_t EG2ControllerReleaseInfluence;
527 double LFO2Frequency;
528 uint16_t LFO2InternalDepth;
529 uint16_t LFO2ControlDepth;
530 lfo2_ctrl_t LFO2Controller;
536 double LFO3Frequency;
537 int16_t LFO3InternalDepth;
538 int16_t LFO3ControlDepth;
539 lfo3_ctrl_t LFO3Controller;
544 vcf_cutoff_ctrl_t VCFCutoffController;
545 bool VCFCutoffControllerInvert;
547 curve_type_t VCFVelocityCurve;
548 uint8_t VCFVelocityScale;
549 uint8_t VCFVelocityDynamicRange;
550 uint8_t VCFResonance;
551 bool VCFResonanceDynamic;
552 vcf_res_ctrl_t VCFResonanceController;
553 bool VCFKeyboardTracking;
554 uint8_t VCFKeyboardTrackingBreakpoint;
556 curve_type_t VelocityResponseCurve;
557 uint8_t VelocityResponseDepth;
558 uint8_t VelocityResponseCurveScaling;
559 curve_type_t ReleaseVelocityResponseCurve;
560 uint8_t ReleaseVelocityResponseDepth;
561 uint8_t ReleaseTriggerDecay;
563 crossfade_t Crossfade;
565 dim_bypass_ctrl_t DimensionBypass;
568 attenuation_ctrl_t AttenuationController;
569 bool InvertAttenuationController;
570 uint8_t AttenuationControllerThreshold;
571 uint8_t ChannelOffset;
574 uint16_t SampleStartOffset;
575 double SampleAttenuation;
576 uint8_t DimensionUpperLimits[8];
579 sust_rel_trg_t SustainReleaseTrigger;
580 bool NoNoteOffReleaseTrigger;
583 using DLS::Sampler::UnityNote;
584 using DLS::Sampler::FineTune;
590 double GetVelocityAttenuation(uint8_t MIDIKeyVelocity);
591 double GetVelocityRelease(uint8_t MIDIKeyVelocity);
592 double GetVelocityCutoff(uint8_t MIDIKeyVelocity);
593 void SetVelocityResponseCurve(curve_type_t curve);
594 void SetVelocityResponseDepth(uint8_t depth);
595 void SetVelocityResponseCurveScaling(uint8_t scaling);
596 void SetReleaseVelocityResponseCurve(curve_type_t curve);
597 void SetReleaseVelocityResponseDepth(uint8_t depth);
598 void SetVCFCutoffController(vcf_cutoff_ctrl_t controller);
599 void SetVCFVelocityCurve(curve_type_t curve);
600 void SetVCFVelocityDynamicRange(uint8_t range);
601 void SetVCFVelocityScale(uint8_t scaling);
602 Region* GetParent()
const;
607 virtual void SetGain(int32_t gain);
608 virtual void UpdateChunks(progress_t* pProgress);
609 virtual void CopyAssign(
const DimensionRegion* orig);
611 uint8_t* VelocityTable;
612 DimensionRegion(Region* pParent,
RIFF::List* _3ewl);
613 DimensionRegion(
RIFF::List* _3ewl,
const DimensionRegion& src);
615 void CopyAssign(
const DimensionRegion* orig,
const std::map<Sample*,Sample*>* mSamples);
622 _lev_ctrl_none = 0x00,
623 _lev_ctrl_modwheel = 0x03,
624 _lev_ctrl_breath = 0x05,
625 _lev_ctrl_foot = 0x07,
626 _lev_ctrl_effect1 = 0x0d,
627 _lev_ctrl_effect2 = 0x0f,
628 _lev_ctrl_genpurpose1 = 0x11,
629 _lev_ctrl_genpurpose2 = 0x13,
630 _lev_ctrl_genpurpose3 = 0x15,
631 _lev_ctrl_genpurpose4 = 0x17,
632 _lev_ctrl_portamentotime = 0x0b,
633 _lev_ctrl_sustainpedal = 0x01,
634 _lev_ctrl_portamento = 0x19,
635 _lev_ctrl_sostenutopedal = 0x1b,
636 _lev_ctrl_softpedal = 0x09,
637 _lev_ctrl_genpurpose5 = 0x1d,
638 _lev_ctrl_genpurpose6 = 0x1f,
639 _lev_ctrl_genpurpose7 = 0x21,
640 _lev_ctrl_genpurpose8 = 0x23,
641 _lev_ctrl_effect1depth = 0x25,
642 _lev_ctrl_effect2depth = 0x27,
643 _lev_ctrl_effect3depth = 0x29,
644 _lev_ctrl_effect4depth = 0x2b,
645 _lev_ctrl_effect5depth = 0x2d,
646 _lev_ctrl_channelaftertouch = 0x2f,
647 _lev_ctrl_velocity = 0xff,
651 _lev_ctrl_CC3_EXT = 0x83,
653 _lev_ctrl_CC6_EXT = 0x86,
654 _lev_ctrl_CC7_EXT = 0x87,
655 _lev_ctrl_CC8_EXT = 0x88,
656 _lev_ctrl_CC9_EXT = 0x89,
657 _lev_ctrl_CC10_EXT = 0x8a,
658 _lev_ctrl_CC11_EXT = 0x8b,
660 _lev_ctrl_CC14_EXT = 0x8e,
661 _lev_ctrl_CC15_EXT = 0x8f,
663 _lev_ctrl_CC20_EXT = 0x94,
664 _lev_ctrl_CC21_EXT = 0x95,
665 _lev_ctrl_CC22_EXT = 0x96,
666 _lev_ctrl_CC23_EXT = 0x97,
667 _lev_ctrl_CC24_EXT = 0x98,
668 _lev_ctrl_CC25_EXT = 0x99,
669 _lev_ctrl_CC26_EXT = 0x9a,
670 _lev_ctrl_CC27_EXT = 0x9b,
671 _lev_ctrl_CC28_EXT = 0x9c,
672 _lev_ctrl_CC29_EXT = 0x9d,
673 _lev_ctrl_CC30_EXT = 0x9e,
674 _lev_ctrl_CC31_EXT = 0x9f,
676 _lev_ctrl_CC68_EXT = 0xc4,
677 _lev_ctrl_CC69_EXT = 0xc5,
678 _lev_ctrl_CC70_EXT = 0xc6,
679 _lev_ctrl_CC71_EXT = 0xc7,
680 _lev_ctrl_CC72_EXT = 0xc8,
681 _lev_ctrl_CC73_EXT = 0xc9,
682 _lev_ctrl_CC74_EXT = 0xca,
683 _lev_ctrl_CC75_EXT = 0xcb,
684 _lev_ctrl_CC76_EXT = 0xcc,
685 _lev_ctrl_CC77_EXT = 0xcd,
686 _lev_ctrl_CC78_EXT = 0xce,
687 _lev_ctrl_CC79_EXT = 0xcf,
689 _lev_ctrl_CC84_EXT = 0xd4,
690 _lev_ctrl_CC85_EXT = 0xd5,
691 _lev_ctrl_CC86_EXT = 0xd6,
692 _lev_ctrl_CC87_EXT = 0xd7,
694 _lev_ctrl_CC89_EXT = 0xd9,
695 _lev_ctrl_CC90_EXT = 0xda,
697 _lev_ctrl_CC96_EXT = 0xe0,
698 _lev_ctrl_CC97_EXT = 0xe1,
700 _lev_ctrl_CC102_EXT = 0xe6,
701 _lev_ctrl_CC103_EXT = 0xe7,
702 _lev_ctrl_CC104_EXT = 0xe8,
703 _lev_ctrl_CC105_EXT = 0xe9,
704 _lev_ctrl_CC106_EXT = 0xea,
705 _lev_ctrl_CC107_EXT = 0xeb,
706 _lev_ctrl_CC108_EXT = 0xec,
707 _lev_ctrl_CC109_EXT = 0xed,
708 _lev_ctrl_CC110_EXT = 0xee,
709 _lev_ctrl_CC111_EXT = 0xef,
710 _lev_ctrl_CC112_EXT = 0xf0,
711 _lev_ctrl_CC113_EXT = 0xf1,
712 _lev_ctrl_CC114_EXT = 0xf2,
713 _lev_ctrl_CC115_EXT = 0xf3,
714 _lev_ctrl_CC116_EXT = 0xf4,
715 _lev_ctrl_CC117_EXT = 0xf5,
716 _lev_ctrl_CC118_EXT = 0xf6,
717 _lev_ctrl_CC119_EXT = 0xf7
719 typedef std::map<uint32_t, double*> VelocityTableMap;
721 static size_t Instances;
722 static VelocityTableMap* pVelocityTables;
723 double* pVelocityAttenuationTable;
724 double* pVelocityReleaseTable;
725 double* pVelocityCutoffTable;
728 leverage_ctrl_t DecodeLeverageController(_lev_ctrl_t EncodedController);
729 _lev_ctrl_t EncodeLeverageController(leverage_ctrl_t DecodedController);
730 double* GetReleaseVelocityTable(curve_type_t releaseVelocityResponseCurve, uint8_t releaseVelocityResponseDepth);
731 double* GetCutoffVelocityTable(curve_type_t vcfVelocityCurve, uint8_t vcfVelocityDynamicRange, uint8_t vcfVelocityScale, vcf_cutoff_ctrl_t vcfCutoffController);
732 double* GetVelocityTable(curve_type_t curveType, uint8_t depth, uint8_t scaling);
733 double* CreateVelocityTable(curve_type_t curveType, uint8_t depth, uint8_t scaling);
763 uint32_t Manufacturer;
765 uint32_t SamplePeriod;
766 uint32_t MIDIUnityNote;
768 smpte_format_t SMPTEFormat;
769 uint32_t SMPTEOffset;
772 loop_type_t LoopType;
776 uint32_t LoopFraction;
777 uint32_t LoopPlayCount;
779 uint32_t TruncatedBits;
783 buffer_t LoadSampleData();
784 buffer_t LoadSampleData(file_offset_t SampleCount);
785 buffer_t LoadSampleDataWithNullSamplesExtension(uint NullSamplesCount);
786 buffer_t LoadSampleDataWithNullSamplesExtension(file_offset_t SampleCount, uint NullSamplesCount);
789 static buffer_t CreateDecompressionBuffer(file_offset_t MaxReadSize);
790 static void DestroyDecompressionBuffer(buffer_t& DecompressionBuffer);
792 void ReleaseSampleData();
793 void Resize(file_offset_t NewSize);
796 file_offset_t Read(
void* pBuffer, file_offset_t SampleCount, buffer_t* pExternalDecompressionBuffer = NULL);
797 file_offset_t ReadAndLoop(
void* pBuffer, file_offset_t SampleCount, playback_state_t* pPlaybackState, DimensionRegion* pDimRgn, buffer_t* pExternalDecompressionBuffer = NULL);
798 file_offset_t Write(
void* pBuffer, file_offset_t SampleCount);
799 Group* GetGroup()
const;
800 virtual void UpdateChunks(progress_t* pProgress);
801 void CopyAssignMeta(
const Sample* orig);
802 void CopyAssignWave(
const Sample* orig);
803 uint32_t GetWaveDataCRC32Checksum();
804 bool VerifyWaveData(uint32_t* pActually = NULL);
806 static size_t Instances;
807 static buffer_t InternalDecompressionBuffer;
816 unsigned long FileNo;
821 Sample(File* pFile,
RIFF::List* waveList, file_offset_t WavePoolOffset,
unsigned long fileNo = 0,
int index = -1);
823 uint32_t CalculateWaveDataChecksum();
834 BitDepth == 24 ? samples + (samples >> 1) + (samples >> 8) * 13
835 : samples + (samples >> 10) * 5;
838 return (Channels == 2 ? size << 1 : size) + WorstCaseFrameSize;
843 inline file_offset_t WorstCaseMaxSamples(buffer_t* pDecompressionBuffer) {
844 return (file_offset_t) ((float)pDecompressionBuffer->Size / (
float)WorstCaseFrameSize * (float)SamplesPerFrame);
847 void ScanCompressedSample();
876 unsigned int Dimensions;
877 dimension_def_t pDimensionDefinitions[8];
878 uint32_t DimensionRegions;
879 DimensionRegion* pDimensionRegions[256];
883 DimensionRegion* GetDimensionRegionByValue(
const uint DimValues[8]);
884 DimensionRegion* GetDimensionRegionByBit(
const uint8_t DimBits[8]);
885 int GetDimensionRegionIndexByValue(
const uint DimValues[8]);
887 void AddDimension(dimension_def_t* pDimDef);
888 void DeleteDimension(dimension_def_t* pDimDef);
889 dimension_def_t* GetDimensionDefinition(dimension_t type);
890 void DeleteDimensionZone(dimension_t type,
int zone);
891 void SplitDimensionZone(dimension_t type,
int zone);
892 void SetDimensionType(dimension_t oldType, dimension_t newType);
894 virtual void SetKeyRange(uint16_t Low, uint16_t High);
895 virtual void UpdateChunks(progress_t* pProgress);
896 virtual void CopyAssign(
const Region* orig);
898 Region(Instrument* pInstrument,
RIFF::List* rgnList);
900 void UpdateVelocityTable();
901 Sample* GetSampleFromWavePool(
unsigned int WavePoolTableIndex, progress_t* pProgress = NULL);
902 void CopyAssign(
const Region* orig,
const std::map<Sample*,Sample*>* mSamples);
903 DimensionRegion* GetDimensionRegionByBit(
const std::map<dimension_t,int>& DimCase);
905 friend class Instrument;
952 virtual ~MidiRule() { }
954 virtual void UpdateChunks(uint8_t* pData)
const = 0;
955 friend class Instrument;
971 class MidiRuleCtrlTrigger :
public MidiRule {
973 uint8_t ControllerNumber;
976 uint8_t TriggerPoint;
978 uint8_t VelSensitivity;
987 MidiRuleCtrlTrigger();
988 void UpdateChunks(uint8_t* pData)
const;
989 friend class Instrument;
1012 class MidiRuleLegato :
public MidiRule {
1014 uint8_t LegatoSamples;
1015 bool BypassUseController;
1017 uint8_t BypassController;
1018 uint16_t ThresholdTime;
1019 uint16_t ReleaseTime;
1021 uint8_t ReleaseTriggerKey;
1022 uint8_t AltSustain1Key;
1023 uint8_t AltSustain2Key;
1028 void UpdateChunks(uint8_t* pData)
const;
1029 friend class Instrument;
1044 class MidiRuleAlternator :
public MidiRule {
1046 uint8_t Articulations;
1047 String pArticulations[32];
1055 const uint8_t& operator[](
int i)
const {
1058 uint8_t& operator[](
int i) {
1067 selector_key_switch,
1070 selector_t Selector;
1071 range_t KeySwitchRange;
1079 MidiRuleAlternator();
1080 void UpdateChunks(uint8_t* pData)
const;
1081 friend class Instrument;
1097 class MidiRuleUnknown :
public MidiRule {
1099 MidiRuleUnknown() { }
1100 void UpdateChunks(uint8_t* pData)
const { }
1101 friend class Instrument;
1129 enum Compression_t {
1130 COMPRESSION_NONE = 0
1137 Compression_t Compression;
1138 Encoding_t Encoding;
1139 Language_t Language;
1142 String GetScriptAsText();
1143 void SetScriptAsText(
const String& text);
1144 void SetGroup(ScriptGroup* pGroup);
1145 ScriptGroup* GetGroup()
const;
1146 void CopyAssign(
const Script* orig);
1150 void UpdateChunks(progress_t* pProgress);
1151 void RemoveAllScriptReferences();
1152 friend class ScriptGroup;
1153 friend class Instrument;
1155 ScriptGroup* pGroup;
1157 std::vector<uint8_t> data;
1176 Script* GetScript(uint index);
1177 Script* AddScript();
1178 void DeleteScript(Script* pScript);
1180 ScriptGroup(File* file,
RIFF::List* lstRTIS);
1181 virtual ~ScriptGroup();
1183 void UpdateChunks(progress_t* pProgress);
1184 friend class Script;
1189 std::list<Script*>* pScripts;
1220 int32_t Attenuation;
1221 uint16_t EffectSend;
1223 uint16_t PitchbendRange;
1224 bool PianoReleaseMode;
1225 range_t DimensionKeyRange;
1229 using DLS::Resource::GetParent;
1231 Region* GetFirstRegion();
1232 Region* GetNextRegion();
1233 Region* AddRegion();
1234 void DeleteRegion(Region* pRegion);
1235 void MoveTo(Instrument* dst);
1236 virtual void UpdateChunks(progress_t* pProgress);
1237 virtual void CopyAssign(
const Instrument* orig);
1239 Region* GetRegion(
unsigned int Key);
1240 MidiRule* GetMidiRule(
int i);
1241 MidiRuleCtrlTrigger* AddMidiRuleCtrlTrigger();
1242 MidiRuleLegato* AddMidiRuleLegato();
1243 MidiRuleAlternator* AddMidiRuleAlternator();
1244 void DeleteMidiRule(
int i);
1246 Script* GetScriptOfSlot(uint index);
1247 void AddScriptSlot(Script* pScript,
bool bypass =
false);
1248 void SwapScriptSlots(uint index1, uint index2);
1249 void RemoveScriptSlot(uint index);
1250 void RemoveScript(Script* pScript);
1251 uint ScriptSlotCount()
const;
1252 bool IsScriptSlotBypassed(uint index);
1253 void SetScriptSlotBypassed(uint index,
bool bBypass);
1255 Region* RegionKeyTable[128];
1257 Instrument(File* pFile,
RIFF::List* insList, progress_t* pProgress = NULL);
1259 void CopyAssign(
const Instrument* orig,
const std::map<Sample*,Sample*>* mSamples);
1260 void UpdateRegionKeyTable();
1262 void UpdateScriptFileOffsets();
1264 friend class Region;
1266 struct _ScriptPooolEntry {
1267 uint32_t fileOffset;
1270 struct _ScriptPooolRef {
1274 MidiRule** pMidiRules;
1275 std::vector<_ScriptPooolEntry> scriptPoolFileOffsets;
1276 std::vector<_ScriptPooolRef>* pScriptRefs;
1294 Sample* GetFirstSample();
1295 Sample* GetNextSample();
1296 void AddSample(Sample* pSample);
1300 virtual void UpdateChunks(progress_t* pProgress);
1358 using DLS::Resource::GetParent;
1366 Sample* GetFirstSample(progress_t* pProgress = NULL);
1367 Sample* GetNextSample();
1368 Sample* GetSample(uint index);
1369 Sample* AddSample();
1370 size_t CountSamples();
1371 void DeleteSample(Sample* pSample);
1372 Instrument* GetFirstInstrument();
1373 Instrument* GetNextInstrument();
1374 Instrument* GetInstrument(uint index, progress_t* pProgress = NULL);
1375 Instrument* AddInstrument();
1376 Instrument* AddDuplicateInstrument(
const Instrument* orig);
1377 size_t CountInstruments();
1378 void DeleteInstrument(Instrument* pInstrument);
1379 Group* GetFirstGroup();
1380 Group* GetNextGroup();
1381 Group* GetGroup(uint index);
1382 Group* GetGroup(String name);
1384 void DeleteGroup(Group* pGroup);
1385 void DeleteGroupOnly(Group* pGroup);
1386 void SetAutoLoad(
bool b);
1388 void AddContentOf(File* pFile);
1389 ScriptGroup* GetScriptGroup(uint index);
1390 ScriptGroup* GetScriptGroup(
const String& name);
1391 ScriptGroup* AddScriptGroup();
1392 void DeleteScriptGroup(ScriptGroup* pGroup);
1394 virtual void UpdateChunks(progress_t* pProgress);
1397 virtual void LoadSamples();
1398 virtual void LoadInstruments();
1399 virtual void LoadGroups();
1400 virtual void UpdateFileOffsets();
1402 virtual void LoadSamples(progress_t* pProgress);
1403 virtual void LoadInstruments(progress_t* pProgress);
1404 virtual void LoadScriptGroups();
1405 void SetSampleChecksum(Sample* pSample, uint32_t crc);
1406 uint32_t GetSampleChecksum(Sample* pSample);
1407 uint32_t GetSampleChecksumByIndex(
int index);
1408 bool VerifySampleChecksumTable();
1409 bool RebuildSampleChecksumTable();
1410 int GetWaveTableIndexOf(gig::Sample* pSample);
1411 friend class Region;
1412 friend class Sample;
1413 friend class Instrument;
1415 friend class ScriptGroup;
1417 std::list<Group*>* pGroups;
1418 std::list<Group*>::iterator GroupsIterator;
1420 std::list<ScriptGroup*>* pScriptGroups;
1433 Exception(String format, ...);
1434 Exception(String format, va_list arg);
1435 void PrintMessage();
1441 size_t enumCount(
const std::type_info& type);
1442 const char* enumKey(
const std::type_info& type,
size_t value);
1443 bool enumKey(
const std::type_info& type, String key);
1444 const char** enumKeys(
const std::type_info& type);
1446 size_t enumCount(String typeName);
1447 const char* enumKey(String typeName,
size_t value);
1448 bool enumKey(String typeName, String key);
1449 const char** enumKeys(String typeName);
1450 size_t enumValue(String key);
sample_loop_t * pSampleLoops
Points to the beginning of a sample loop array, or is NULL if there are no loops defined.
Destination container for serialization, and source container for deserialization.
uint32_t Regions
Reflects the number of Region defintions this Instrument has.
Parses DLS Level 1 and 2 compliant files and provides abstract access to the data.
stream_whence_t
File stream position dependent to these relations.
String libraryName()
Returns the name of this C++ library.
Will be thrown whenever a DLS specific error occurs while trying to access a DLS File.
String libraryVersion()
Returns version of this C++ library.
uint16_t MIDIBank
Reflects combination of MIDIBankCoarse and MIDIBankFine (bank 1 - bank 16384). Do not change this val...
uint8_t MIDIBankCoarse
Reflects the MIDI Bank number for MIDI Control Change 0 (bank 1 - 128).
void DeleteSampleLoop(sample_loop_t *pLoopDef)
Deletes an existing sample loop.
Abstract base class which provides mandatory informations about sample players in general...
void SetFileName(const String &name)
You may call this method store a future file name, so you don't have to to pass it to the Save() call...
uint32_t SampleLoops
Reflects the number of sample loops.
virtual void Save(const String &Path, progress_t *pProgress=NULL)
Save changes to another file.
uint64_t file_offset_t
Type used by libgig for handling file positioning during file I/O tasks.
uint32_t MIDIProgram
Specifies the MIDI Program Change Number this Instrument should be assigned to.
Used for indicating the progress of a certain task.
version_t * pVersion
Points to a version_t structure if the file provided a version number else is set to NULL...
uint8_t MIDIBankFine
Reflects the MIDI Bank number for MIDI Control Change 32 (bank 1 - 128).
Encapsulates sample waves used for playback.
String GetFileName()
File name of this DLS file.
dlsid_t * pDLSID
Points to a dlsid_t structure if the file provided a DLS ID else is NULL.
uint32_t Instruments
Reflects the number of available Instrument objects.
Provides all neccessary information for the synthesis of a DLS Instrument.
Quadtuple version number ("major.minor.release.build").
Serialization / deserialization framework.
Info * pInfo
Points (in any case) to an Info object, providing additional, optional infos and comments.
Defines Region information of an Instrument.
bool IsDrum
Indicates if the Instrument is a drum type, as they differ in the synthesis model of DLS from melodic...
void AddSampleLoop(sample_loop_t *pLoopDef)
Adds a new sample loop with the provided loop definition.