libgig  4.1.0
gig.h
1 /***************************************************************************
2  * *
3  * libgig - C++ cross-platform Gigasampler format file access library *
4  * *
5  * Copyright (C) 2003-2017 by Christian Schoenebeck *
6  * <cuse@users.sourceforge.net> *
7  * *
8  * This library is free software; you can redistribute it and/or modify *
9  * it under the terms of the GNU General Public License as published by *
10  * the Free Software Foundation; either version 2 of the License, or *
11  * (at your option) any later version. *
12  * *
13  * This library is distributed in the hope that it will be useful, *
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of *
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
16  * GNU General Public License for more details. *
17  * *
18  * You should have received a copy of the GNU General Public License *
19  * along with this library; if not, write to the Free Software *
20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, *
21  * MA 02111-1307 USA *
22  ***************************************************************************/
23 
24 #ifndef __GIG_H__
25 #define __GIG_H__
26 
27 #include "DLS.h"
28 #include <vector>
29 
30 #ifndef __has_feature
31 # define __has_feature(x) 0
32 #endif
33 #ifndef HAVE_RTTI
34 # if __GXX_RTTI || __has_feature(cxx_rtti) || _CPPRTTI
35 # define HAVE_RTTI 1
36 # else
37 # define HAVE_RTTI 0
38 # endif
39 #endif
40 #if HAVE_RTTI
41 # include <typeinfo>
42 #else
43 # warning No RTTI available!
44 #endif
45 
46 #if WORDS_BIGENDIAN
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
85 
86 #ifndef GIG_DECLARE_ENUM
87 # define GIG_DECLARE_ENUM(type, ...) enum type { __VA_ARGS__ }
88 #endif
89 
90 // just symbol prototyping (since Serialization.h not included by default here)
91 namespace Serialization { class Archive; }
92 
94 namespace gig {
95 
96  typedef std::string String;
98  typedef RIFF::file_offset_t file_offset_t;
99 
101  struct range_t {
102  uint8_t low;
103  uint8_t high;
104  };
105 
107  struct buffer_t {
108  void* pStart;
109  file_offset_t Size;
110  file_offset_t NullExtensionSize;
111  buffer_t() {
112  pStart = NULL;
113  Size = 0;
114  NullExtensionSize = 0;
115  }
116  };
117 
122  GIG_DECLARE_ENUM(loop_type_t,
123  loop_type_normal = 0x00000000,
124  loop_type_bidirectional = 0x00000001,
125  loop_type_backward = 0x00000002
126  );
127 
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
138  );
139 
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
149  );
150 
155  GIG_DECLARE_ENUM(dim_bypass_ctrl_t,
156  dim_bypass_ctrl_none,
157  dim_bypass_ctrl_94,
158  dim_bypass_ctrl_95
159  );
160 
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
171  );
172 
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
183  );
184 
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
195  );
196 
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
214  );
215 
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
226  );
227 
241  GIG_DECLARE_ENUM(type_t,
242  type_none = 0x00,
243  type_channelaftertouch = 0x2f,
244  type_velocity = 0xff,
245  type_controlchange = 0xfe
246  );
247 
248  type_t type;
250 
251  void serialize(Serialization::Archive* archive);
252  };
253 
260 
267 
274 
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
319  );
320 
327  GIG_DECLARE_ENUM(split_type_t,
328  split_type_normal,
329  split_type_bit
330  );
331 
334  dimension_t dimension;
335  uint8_t bits;
336  uint8_t zones;
338  float zone_size;
339  };
340 
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
351  );
352 
360  struct crossfade_t {
361  #if WORDS_BIGENDIAN
362  uint8_t out_end;
363  uint8_t out_start;
364  uint8_t in_end;
365  uint8_t in_start;
366  #else // little endian
367  uint8_t in_start;
368  uint8_t in_end;
369  uint8_t out_start;
370  uint8_t out_end;
371  #endif // WORDS_BIGENDIAN
372 
373  void serialize(Serialization::Archive* archive);
374  };
375 
378  file_offset_t position;
379  bool reverse;
380  file_offset_t loop_cycles_left;
381  };
382 
406  struct eg_opt_t {
412 
413  eg_opt_t();
414  void serialize(Serialization::Archive* archive);
415  };
416 
417  // just symbol prototyping
418  class File;
419  class Instrument;
420  class Sample;
421  class Region;
422  class Group;
423  class Script;
424  class ScriptGroup;
425 
468  class DimensionRegion : protected DLS::Sampler {
469  public:
472  // Sample Amplitude EG/LFO
473  uint16_t EG1PreAttack;
474  double EG1Attack;
475  double EG1Decay1;
476  double EG1Decay2;
478  uint16_t EG1Sustain;
479  double EG1Release;
480  bool EG1Hold;
486  double LFO1Frequency;
487  uint16_t LFO1InternalDepth;
488  uint16_t LFO1ControlDepth;
489  lfo1_ctrl_t LFO1Controller;
491  bool LFO1Sync;
492  // Filter Cutoff Frequency EG/LFO
493  uint16_t EG2PreAttack;
494  double EG2Attack;
495  double EG2Decay1;
496  double EG2Decay2;
498  uint16_t EG2Sustain;
499  double EG2Release;
505  double LFO2Frequency;
506  uint16_t LFO2InternalDepth;
507  uint16_t LFO2ControlDepth;
508  lfo2_ctrl_t LFO2Controller;
510  bool LFO2Sync;
511  // Sample Pitch EG/LFO
512  double EG3Attack;
513  int16_t EG3Depth;
514  double LFO3Frequency;
517  lfo3_ctrl_t LFO3Controller;
518  bool LFO3Sync;
519  // Filter
520  bool VCFEnabled;
521  vcf_type_t VCFType;
522  vcf_cutoff_ctrl_t VCFCutoffController;
524  uint8_t VCFCutoff;
525  curve_type_t VCFVelocityCurve;
528  uint8_t VCFResonance;
530  vcf_res_ctrl_t VCFResonanceController;
533  // Key Velocity Transformations
534  curve_type_t VelocityResponseCurve;
540  // Mix / Layer
541  crossfade_t Crossfade;
542  bool PitchTrack;
544  int8_t Pan;
545  bool SelfMask;
549  uint8_t ChannelOffset;
551  bool MSDecode;
552  uint16_t SampleStartOffset;
554  uint8_t DimensionUpperLimits[8];
557 
558  // derived attributes from DLS::Sampler
559  using DLS::Sampler::UnityNote;
560  using DLS::Sampler::FineTune;
561  using DLS::Sampler::Gain;
564 
565  // own methods
566  double GetVelocityAttenuation(uint8_t MIDIKeyVelocity);
567  double GetVelocityRelease(uint8_t MIDIKeyVelocity);
568  double GetVelocityCutoff(uint8_t MIDIKeyVelocity);
569  void SetVelocityResponseCurve(curve_type_t curve);
570  void SetVelocityResponseDepth(uint8_t depth);
571  void SetVelocityResponseCurveScaling(uint8_t scaling);
572  void SetReleaseVelocityResponseCurve(curve_type_t curve);
573  void SetReleaseVelocityResponseDepth(uint8_t depth);
574  void SetVCFCutoffController(vcf_cutoff_ctrl_t controller);
575  void SetVCFVelocityCurve(curve_type_t curve);
576  void SetVCFVelocityDynamicRange(uint8_t range);
577  void SetVCFVelocityScale(uint8_t scaling);
578  Region* GetParent() const;
579  // derived methods
582  // overridden methods
583  virtual void SetGain(int32_t gain);
584  virtual void UpdateChunks(progress_t* pProgress);
585  virtual void CopyAssign(const DimensionRegion* orig);
586  protected:
587  uint8_t* VelocityTable;
588  DimensionRegion(Region* pParent, RIFF::List* _3ewl);
589  DimensionRegion(RIFF::List* _3ewl, const DimensionRegion& src);
590  ~DimensionRegion();
591  void CopyAssign(const DimensionRegion* orig, const std::map<Sample*,Sample*>* mSamples);
592  void serialize(Serialization::Archive* archive);
593  friend class Region;
594  friend class Serialization::Archive;
595  private:
596  typedef enum {
597  // official leverage controllers as they were defined in the original Gigasampler/GigaStudio format:
598  _lev_ctrl_none = 0x00,
599  _lev_ctrl_modwheel = 0x03,
600  _lev_ctrl_breath = 0x05,
601  _lev_ctrl_foot = 0x07,
602  _lev_ctrl_effect1 = 0x0d,
603  _lev_ctrl_effect2 = 0x0f,
604  _lev_ctrl_genpurpose1 = 0x11,
605  _lev_ctrl_genpurpose2 = 0x13,
606  _lev_ctrl_genpurpose3 = 0x15,
607  _lev_ctrl_genpurpose4 = 0x17,
608  _lev_ctrl_portamentotime = 0x0b,
609  _lev_ctrl_sustainpedal = 0x01,
610  _lev_ctrl_portamento = 0x19,
611  _lev_ctrl_sostenutopedal = 0x1b,
612  _lev_ctrl_softpedal = 0x09,
613  _lev_ctrl_genpurpose5 = 0x1d,
614  _lev_ctrl_genpurpose6 = 0x1f,
615  _lev_ctrl_genpurpose7 = 0x21,
616  _lev_ctrl_genpurpose8 = 0x23,
617  _lev_ctrl_effect1depth = 0x25,
618  _lev_ctrl_effect2depth = 0x27,
619  _lev_ctrl_effect3depth = 0x29,
620  _lev_ctrl_effect4depth = 0x2b,
621  _lev_ctrl_effect5depth = 0x2d,
622  _lev_ctrl_channelaftertouch = 0x2f,
623  _lev_ctrl_velocity = 0xff,
624 
625  // format extension (these controllers are so far only supported by LinuxSampler & gigedit) they will *NOT* work with Gigasampler/GigaStudio !
626  // (the assigned values here are their official MIDI CC number plus the highest bit set):
627  _lev_ctrl_CC3_EXT = 0x83,
628 
629  _lev_ctrl_CC6_EXT = 0x86,
630  _lev_ctrl_CC7_EXT = 0x87,
631  _lev_ctrl_CC8_EXT = 0x88,
632  _lev_ctrl_CC9_EXT = 0x89,
633  _lev_ctrl_CC10_EXT = 0x8a,
634  _lev_ctrl_CC11_EXT = 0x8b,
635 
636  _lev_ctrl_CC14_EXT = 0x8e,
637  _lev_ctrl_CC15_EXT = 0x8f,
638 
639  _lev_ctrl_CC20_EXT = 0x94,
640  _lev_ctrl_CC21_EXT = 0x95,
641  _lev_ctrl_CC22_EXT = 0x96,
642  _lev_ctrl_CC23_EXT = 0x97,
643  _lev_ctrl_CC24_EXT = 0x98,
644  _lev_ctrl_CC25_EXT = 0x99,
645  _lev_ctrl_CC26_EXT = 0x9a,
646  _lev_ctrl_CC27_EXT = 0x9b,
647  _lev_ctrl_CC28_EXT = 0x9c,
648  _lev_ctrl_CC29_EXT = 0x9d,
649  _lev_ctrl_CC30_EXT = 0x9e,
650  _lev_ctrl_CC31_EXT = 0x9f,
651 
652  _lev_ctrl_CC68_EXT = 0xc4,
653  _lev_ctrl_CC69_EXT = 0xc5,
654  _lev_ctrl_CC70_EXT = 0xc6,
655  _lev_ctrl_CC71_EXT = 0xc7,
656  _lev_ctrl_CC72_EXT = 0xc8,
657  _lev_ctrl_CC73_EXT = 0xc9,
658  _lev_ctrl_CC74_EXT = 0xca,
659  _lev_ctrl_CC75_EXT = 0xcb,
660  _lev_ctrl_CC76_EXT = 0xcc,
661  _lev_ctrl_CC77_EXT = 0xcd,
662  _lev_ctrl_CC78_EXT = 0xce,
663  _lev_ctrl_CC79_EXT = 0xcf,
664 
665  _lev_ctrl_CC84_EXT = 0xd4,
666  _lev_ctrl_CC85_EXT = 0xd5,
667  _lev_ctrl_CC86_EXT = 0xd6,
668  _lev_ctrl_CC87_EXT = 0xd7,
669 
670  _lev_ctrl_CC89_EXT = 0xd9,
671  _lev_ctrl_CC90_EXT = 0xda,
672 
673  _lev_ctrl_CC96_EXT = 0xe0,
674  _lev_ctrl_CC97_EXT = 0xe1,
675 
676  _lev_ctrl_CC102_EXT = 0xe6,
677  _lev_ctrl_CC103_EXT = 0xe7,
678  _lev_ctrl_CC104_EXT = 0xe8,
679  _lev_ctrl_CC105_EXT = 0xe9,
680  _lev_ctrl_CC106_EXT = 0xea,
681  _lev_ctrl_CC107_EXT = 0xeb,
682  _lev_ctrl_CC108_EXT = 0xec,
683  _lev_ctrl_CC109_EXT = 0xed,
684  _lev_ctrl_CC110_EXT = 0xee,
685  _lev_ctrl_CC111_EXT = 0xef,
686  _lev_ctrl_CC112_EXT = 0xf0,
687  _lev_ctrl_CC113_EXT = 0xf1,
688  _lev_ctrl_CC114_EXT = 0xf2,
689  _lev_ctrl_CC115_EXT = 0xf3,
690  _lev_ctrl_CC116_EXT = 0xf4,
691  _lev_ctrl_CC117_EXT = 0xf5,
692  _lev_ctrl_CC118_EXT = 0xf6,
693  _lev_ctrl_CC119_EXT = 0xf7
694  } _lev_ctrl_t;
695  typedef std::map<uint32_t, double*> VelocityTableMap;
696 
697  static size_t Instances;
698  static VelocityTableMap* pVelocityTables;
699  double* pVelocityAttenuationTable;
700  double* pVelocityReleaseTable;
701  double* pVelocityCutoffTable;
702  Region* pRegion;
703 
704  leverage_ctrl_t DecodeLeverageController(_lev_ctrl_t EncodedController);
705  _lev_ctrl_t EncodeLeverageController(leverage_ctrl_t DecodedController);
706  double* GetReleaseVelocityTable(curve_type_t releaseVelocityResponseCurve, uint8_t releaseVelocityResponseDepth);
707  double* GetCutoffVelocityTable(curve_type_t vcfVelocityCurve, uint8_t vcfVelocityDynamicRange, uint8_t vcfVelocityScale, vcf_cutoff_ctrl_t vcfCutoffController);
708  double* GetVelocityTable(curve_type_t curveType, uint8_t depth, uint8_t scaling);
709  double* CreateVelocityTable(curve_type_t curveType, uint8_t depth, uint8_t scaling);
710  };
711 
737  class Sample : public DLS::Sample {
738  public:
739  uint32_t Manufacturer;
740  uint32_t Product;
741  uint32_t SamplePeriod;
742  uint32_t MIDIUnityNote;
743  uint32_t FineTune;
744  smpte_format_t SMPTEFormat;
745  uint32_t SMPTEOffset;
746  uint32_t Loops;
747  uint32_t LoopID;
748  loop_type_t LoopType;
749  uint32_t LoopStart;
750  uint32_t LoopEnd;
751  uint32_t LoopSize;
752  uint32_t LoopFraction;
753  uint32_t LoopPlayCount;
754  bool Compressed;
755  uint32_t TruncatedBits;
756  bool Dithered;
757 
758  // own methods
759  buffer_t LoadSampleData();
760  buffer_t LoadSampleData(file_offset_t SampleCount);
761  buffer_t LoadSampleDataWithNullSamplesExtension(uint NullSamplesCount);
762  buffer_t LoadSampleDataWithNullSamplesExtension(file_offset_t SampleCount, uint NullSamplesCount);
763  buffer_t GetCache();
764  // own static methods
765  static buffer_t CreateDecompressionBuffer(file_offset_t MaxReadSize);
766  static void DestroyDecompressionBuffer(buffer_t& DecompressionBuffer);
767  // overridden methods
768  void ReleaseSampleData();
769  void Resize(file_offset_t NewSize);
770  file_offset_t SetPos(file_offset_t SampleCount, RIFF::stream_whence_t Whence = RIFF::stream_start);
771  file_offset_t GetPos() const;
772  file_offset_t Read(void* pBuffer, file_offset_t SampleCount, buffer_t* pExternalDecompressionBuffer = NULL);
773  file_offset_t ReadAndLoop(void* pBuffer, file_offset_t SampleCount, playback_state_t* pPlaybackState, DimensionRegion* pDimRgn, buffer_t* pExternalDecompressionBuffer = NULL);
774  file_offset_t Write(void* pBuffer, file_offset_t SampleCount);
775  Group* GetGroup() const;
776  virtual void UpdateChunks(progress_t* pProgress);
777  void CopyAssignMeta(const Sample* orig);
778  void CopyAssignWave(const Sample* orig);
779  uint32_t GetWaveDataCRC32Checksum();
780  bool VerifyWaveData(uint32_t* pActually = NULL);
781  protected:
782  static size_t Instances;
785  file_offset_t FrameOffset;
786  file_offset_t* FrameTable;
787  file_offset_t SamplePos;
788  file_offset_t SamplesInLastFrame;
789  file_offset_t WorstCaseFrameSize;
790  file_offset_t SamplesPerFrame;
792  unsigned long FileNo;
793  RIFF::Chunk* pCk3gix;
794  RIFF::Chunk* pCkSmpl;
795  uint32_t crc;
796 
797  Sample(File* pFile, RIFF::List* waveList, file_offset_t WavePoolOffset, unsigned long fileNo = 0, int index = -1);
798  ~Sample();
799  uint32_t CalculateWaveDataChecksum();
800 
801  // Guess size (in bytes) of a compressed sample
802  inline file_offset_t GuessSize(file_offset_t samples) {
803  // 16 bit: assume all frames are compressed - 1 byte
804  // per sample and 5 bytes header per 2048 samples
805 
806  // 24 bit: assume next best compression rate - 1.5
807  // bytes per sample and 13 bytes header per 256
808  // samples
809  const file_offset_t size =
810  BitDepth == 24 ? samples + (samples >> 1) + (samples >> 8) * 13
811  : samples + (samples >> 10) * 5;
812  // Double for stereo and add one worst case sample
813  // frame
814  return (Channels == 2 ? size << 1 : size) + WorstCaseFrameSize;
815  }
816 
817  // Worst case amount of sample points that can be read with the
818  // given decompression buffer.
819  inline file_offset_t WorstCaseMaxSamples(buffer_t* pDecompressionBuffer) {
820  return (file_offset_t) ((float)pDecompressionBuffer->Size / (float)WorstCaseFrameSize * (float)SamplesPerFrame);
821  }
822  private:
823  void ScanCompressedSample();
824  friend class File;
825  friend class Region;
826  friend class Group; // allow to modify protected member pGroup
827  };
828 
829  // TODO: <3dnl> list not used yet - not important though (just contains optional descriptions for the dimensions)
850  class Region : public DLS::Region {
851  public:
852  unsigned int Dimensions;
853  dimension_def_t pDimensionDefinitions[8];
854  uint32_t DimensionRegions;
855  DimensionRegion* pDimensionRegions[256];
856  unsigned int Layers;
857 
858  // own methods
859  DimensionRegion* GetDimensionRegionByValue(const uint DimValues[8]);
860  DimensionRegion* GetDimensionRegionByBit(const uint8_t DimBits[8]);
861  int GetDimensionRegionIndexByValue(const uint DimValues[8]);
862  Sample* GetSample();
863  void AddDimension(dimension_def_t* pDimDef);
864  void DeleteDimension(dimension_def_t* pDimDef);
865  dimension_def_t* GetDimensionDefinition(dimension_t type);
866  void DeleteDimensionZone(dimension_t type, int zone);
867  void SplitDimensionZone(dimension_t type, int zone);
868  void SetDimensionType(dimension_t oldType, dimension_t newType);
869  // overridden methods
870  virtual void SetKeyRange(uint16_t Low, uint16_t High);
871  virtual void UpdateChunks(progress_t* pProgress);
872  virtual void CopyAssign(const Region* orig);
873  protected:
874  Region(Instrument* pInstrument, RIFF::List* rgnList);
875  void LoadDimensionRegions(RIFF::List* rgn);
876  void UpdateVelocityTable();
877  Sample* GetSampleFromWavePool(unsigned int WavePoolTableIndex, progress_t* pProgress = NULL);
878  void CopyAssign(const Region* orig, const std::map<Sample*,Sample*>* mSamples);
879  DimensionRegion* GetDimensionRegionByBit(const std::map<dimension_t,int>& DimCase);
880  ~Region();
881  friend class Instrument;
882  };
883 
926  class MidiRule {
927  public:
928  virtual ~MidiRule() { }
929  protected:
930  virtual void UpdateChunks(uint8_t* pData) const = 0;
931  friend class Instrument;
932  };
933 
947  class MidiRuleCtrlTrigger : public MidiRule {
948  public:
950  uint8_t Triggers;
951  struct trigger_t {
952  uint8_t TriggerPoint;
953  bool Descending;
954  uint8_t VelSensitivity;
955  uint8_t Key;
956  bool NoteOff;
957  uint8_t Velocity;
958  bool OverridePedal;
959  } pTriggers[32];
960 
961  protected:
964  void UpdateChunks(uint8_t* pData) const;
965  friend class Instrument;
966  };
967 
988  class MidiRuleLegato : public MidiRule {
989  public:
990  uint8_t LegatoSamples;
992  uint8_t BypassKey;
994  uint16_t ThresholdTime;
995  uint16_t ReleaseTime;
998  uint8_t AltSustain1Key;
999  uint8_t AltSustain2Key;
1000 
1001  protected:
1002  MidiRuleLegato(RIFF::Chunk* _3ewg);
1003  MidiRuleLegato();
1004  void UpdateChunks(uint8_t* pData) const;
1005  friend class Instrument;
1006  };
1007 
1020  class MidiRuleAlternator : public MidiRule {
1021  public:
1022  uint8_t Articulations;
1023  String pArticulations[32];
1024 
1026 
1027  uint8_t Patterns;
1028  struct pattern_t {
1029  String Name;
1030  int Size;
1031  const uint8_t& operator[](int i) const {
1032  return data[i];
1033  }
1034  uint8_t& operator[](int i) {
1035  return data[i];
1036  }
1037  private:
1038  uint8_t data[32];
1039  } pPatterns[32];
1040 
1041  typedef enum {
1042  selector_none,
1043  selector_key_switch,
1044  selector_controller
1045  } selector_t;
1046  selector_t Selector;
1048  uint8_t Controller;
1049 
1050  bool Polyphonic;
1051  bool Chained;
1052 
1053  protected:
1056  void UpdateChunks(uint8_t* pData) const;
1057  friend class Instrument;
1058  };
1059 
1073  class MidiRuleUnknown : public MidiRule {
1074  protected:
1075  MidiRuleUnknown() { }
1076  void UpdateChunks(uint8_t* pData) const { }
1077  friend class Instrument;
1078  };
1079 
1100  class Script {
1101  public:
1102  enum Encoding_t {
1103  ENCODING_ASCII = 0
1104  };
1106  COMPRESSION_NONE = 0
1107  };
1108  enum Language_t {
1109  LANGUAGE_NKSP = 0
1110  };
1111 
1112  String Name;
1116  bool Bypass;
1117 
1118  String GetScriptAsText();
1119  void SetScriptAsText(const String& text);
1120  void SetGroup(ScriptGroup* pGroup);
1121  ScriptGroup* GetGroup() const;
1122  void CopyAssign(const Script* orig);
1123  protected:
1124  Script(ScriptGroup* group, RIFF::Chunk* ckScri);
1125  virtual ~Script();
1126  void UpdateChunks(progress_t* pProgress);
1127  void RemoveAllScriptReferences();
1128  friend class ScriptGroup;
1129  friend class Instrument;
1130  private:
1131  ScriptGroup* pGroup;
1132  RIFF::Chunk* pChunk;
1133  std::vector<uint8_t> data;
1134  uint32_t crc;
1135  };
1136 
1148  class ScriptGroup {
1149  public:
1150  String Name;
1151 
1152  Script* GetScript(uint index);
1153  Script* AddScript();
1154  void DeleteScript(Script* pScript);
1155  protected:
1156  ScriptGroup(File* file, RIFF::List* lstRTIS);
1157  virtual ~ScriptGroup();
1158  void LoadScripts();
1159  void UpdateChunks(progress_t* pProgress);
1160  friend class Script;
1161  friend class File;
1162  private:
1163  File* pFile;
1164  RIFF::List* pList;
1165  std::list<Script*>* pScripts;
1166  };
1167 
1183  class Instrument : protected DLS::Instrument {
1184  public:
1185  // derived attributes from DLS::Resource
1186  using DLS::Resource::pInfo;
1187  using DLS::Resource::pDLSID;
1188  // derived attributes from DLS::Instrument
1195  // own attributes
1196  int32_t Attenuation;
1197  uint16_t EffectSend;
1198  int16_t FineTune;
1199  uint16_t PitchbendRange;
1200  bool PianoReleaseMode;
1202 
1203 
1204  // derived methods from DLS::Resource
1205  using DLS::Resource::GetParent;
1206  // overridden methods
1207  Region* GetFirstRegion();
1208  Region* GetNextRegion();
1209  Region* AddRegion();
1210  void DeleteRegion(Region* pRegion);
1211  void MoveTo(Instrument* dst);
1212  virtual void UpdateChunks(progress_t* pProgress);
1213  virtual void CopyAssign(const Instrument* orig);
1214  // own methods
1215  Region* GetRegion(unsigned int Key);
1216  MidiRule* GetMidiRule(int i);
1217  MidiRuleCtrlTrigger* AddMidiRuleCtrlTrigger();
1218  MidiRuleLegato* AddMidiRuleLegato();
1219  MidiRuleAlternator* AddMidiRuleAlternator();
1220  void DeleteMidiRule(int i);
1221  // real-time instrument script methods
1222  Script* GetScriptOfSlot(uint index);
1223  void AddScriptSlot(Script* pScript, bool bypass = false);
1224  void SwapScriptSlots(uint index1, uint index2);
1225  void RemoveScriptSlot(uint index);
1226  void RemoveScript(Script* pScript);
1227  uint ScriptSlotCount() const;
1228  bool IsScriptSlotBypassed(uint index);
1229  void SetScriptSlotBypassed(uint index, bool bBypass);
1230  protected:
1231  Region* RegionKeyTable[128];
1232 
1233  Instrument(File* pFile, RIFF::List* insList, progress_t* pProgress = NULL);
1234  ~Instrument();
1235  void CopyAssign(const Instrument* orig, const std::map<Sample*,Sample*>* mSamples);
1236  void UpdateRegionKeyTable();
1237  void LoadScripts();
1238  void UpdateScriptFileOffsets();
1239  friend class File;
1240  friend class Region; // so Region can call UpdateRegionKeyTable()
1241  private:
1242  struct _ScriptPooolEntry {
1243  uint32_t fileOffset;
1244  bool bypass;
1245  };
1246  struct _ScriptPooolRef {
1247  Script* script;
1248  bool bypass;
1249  };
1250  MidiRule** pMidiRules;
1251  std::vector<_ScriptPooolEntry> scriptPoolFileOffsets;
1252  std::vector<_ScriptPooolRef>* pScriptRefs;
1253  };
1254 
1266  class Group {
1267  public:
1268  String Name;
1269 
1270  Sample* GetFirstSample();
1271  Sample* GetNextSample();
1272  void AddSample(Sample* pSample);
1273  protected:
1274  Group(File* file, RIFF::Chunk* ck3gnm);
1275  virtual ~Group();
1276  virtual void UpdateChunks(progress_t* pProgress);
1277  void MoveAll();
1278  friend class File;
1279  private:
1280  File* pFile;
1281  RIFF::Chunk* pNameChunk;
1282  };
1283 
1320  class File : protected DLS::File {
1321  public:
1324 
1325  // derived attributes from DLS::Resource
1326  using DLS::Resource::pInfo;
1327  using DLS::Resource::pDLSID;
1328  // derived attributes from DLS::File
1329  using DLS::File::pVersion;
1330  using DLS::File::Instruments;
1331 
1332  // derived methods from DLS::Resource
1333  using DLS::Resource::GetParent;
1334  // derived methods from DLS::File
1335  using DLS::File::Save;
1336  using DLS::File::GetFileName;
1337  using DLS::File::SetFileName;
1338  // overridden methods
1339  File();
1340  File(RIFF::File* pRIFF);
1341  Sample* GetFirstSample(progress_t* pProgress = NULL);
1342  Sample* GetNextSample();
1343  Sample* GetSample(uint index);
1344  Sample* AddSample();
1345  void DeleteSample(Sample* pSample);
1346  Instrument* GetFirstInstrument();
1347  Instrument* GetNextInstrument();
1348  Instrument* GetInstrument(uint index, progress_t* pProgress = NULL);
1349  Instrument* AddInstrument();
1350  Instrument* AddDuplicateInstrument(const Instrument* orig);
1351  void DeleteInstrument(Instrument* pInstrument);
1352  Group* GetFirstGroup();
1353  Group* GetNextGroup();
1354  Group* GetGroup(uint index);
1355  Group* GetGroup(String name);
1356  Group* AddGroup();
1357  void DeleteGroup(Group* pGroup);
1358  void DeleteGroupOnly(Group* pGroup);
1359  void SetAutoLoad(bool b);
1360  bool GetAutoLoad();
1361  void AddContentOf(File* pFile);
1362  ScriptGroup* GetScriptGroup(uint index);
1363  ScriptGroup* GetScriptGroup(const String& name);
1364  ScriptGroup* AddScriptGroup();
1365  void DeleteScriptGroup(ScriptGroup* pGroup);
1366  virtual ~File();
1367  virtual void UpdateChunks(progress_t* pProgress);
1368  protected:
1369  // overridden protected methods from DLS::File
1370  virtual void LoadSamples();
1371  virtual void LoadInstruments();
1372  virtual void LoadGroups();
1373  virtual void UpdateFileOffsets();
1374  // own protected methods
1375  virtual void LoadSamples(progress_t* pProgress);
1376  virtual void LoadInstruments(progress_t* pProgress);
1377  virtual void LoadScriptGroups();
1378  void SetSampleChecksum(Sample* pSample, uint32_t crc);
1379  uint32_t GetSampleChecksum(Sample* pSample);
1380  uint32_t GetSampleChecksumByIndex(int index);
1381  bool VerifySampleChecksumTable();
1382  bool RebuildSampleChecksumTable();
1383  int GetWaveTableIndexOf(gig::Sample* pSample);
1384  friend class Region;
1385  friend class Sample;
1386  friend class Instrument;
1387  friend class Group; // so Group can access protected member pRIFF
1388  friend class ScriptGroup; // so ScriptGroup can access protected member pRIFF
1389  private:
1390  std::list<Group*>* pGroups;
1391  std::list<Group*>::iterator GroupsIterator;
1392  bool bAutoLoad;
1393  std::list<ScriptGroup*>* pScriptGroups;
1394  };
1395 
1404  class Exception : public DLS::Exception {
1405  public:
1406  Exception(String format, ...);
1407  Exception(String format, va_list arg);
1408  void PrintMessage();
1409  protected:
1410  Exception();
1411  };
1412 
1413 #if HAVE_RTTI
1414  size_t enumCount(const std::type_info& type);
1415  const char* enumKey(const std::type_info& type, size_t value);
1416  bool enumKey(const std::type_info& type, String key);
1417  const char** enumKeys(const std::type_info& type);
1418 #endif // HAVE_RTTI
1419  size_t enumCount(String typeName);
1420  const char* enumKey(String typeName, size_t value);
1421  bool enumKey(String typeName, String key);
1422  const char** enumKeys(String typeName);
1423  size_t enumValue(String key);
1424 
1425  String libraryName();
1426  String libraryVersion();
1427 
1428 } // namespace gig
1429 
1430 #endif // __GIG_H__
range_t KeySwitchRange
Key range for key switch selector.
Definition: gig.h:1047
bool LFO2FlipPhase
Inverts phase of the filter cutoff LFO wave.
Definition: gig.h:509
dim_bypass_ctrl_t DimensionBypass
If defined, the MIDI controller can switch on/off the dimension in realtime.
Definition: gig.h:543
file_offset_t position
Current position within the sample.
Definition: gig.h:378
Encapsulates articulation informations of a dimension region.
Definition: gig.h:468
range_t DimensionKeyRange
0-127 (where 0 means C1 and 127 means G9)
Definition: gig.h:1201
sample_loop_t * pSampleLoops
Points to the beginning of a sample loop array, or is NULL if there are no loops defined.
Definition: DLS.h:373
uint8_t VCFVelocityScale
(0-127) Amount velocity controls VCF cutoff frequency (only if no other VCF cutoff controller is defi...
Definition: gig.h:526
bool reverse
If playback direction is currently backwards (in case there is a pingpong or reverse loop defined)...
Definition: gig.h:379
uint8_t AltSustain2Key
Key triggering a second set of alternate sustain samples.
Definition: gig.h:999
Destination container for serialization, and source container for deserialization.
file_offset_t FrameOffset
Current offset (sample points) in current sample frame (for decompression only).
Definition: gig.h:785
uint32_t Regions
Reflects the number of Region defintions this Instrument has.
Definition: DLS.h:468
file_offset_t SamplePos
For compressed samples only: stores the current position (in sample points).
Definition: gig.h:787
split_type_normal split_type_t
Intended for internal usage: will be used to convert a dimension value into the corresponding dimensi...
Definition: gig.h:330
bool VCFEnabled
If filter should be used.
Definition: gig.h:520
Parses DLS Level 1 and 2 compliant files and provides abstract access to the data.
Definition: DLS.h:498
stream_whence_t
File stream position dependent to these relations.
Definition: RIFF.h:165
uint32_t FineTune
Specifies the fraction of a semitone up from the specified MIDI unity note field. A value of 0x800000...
Definition: gig.h:743
uint8_t BypassKey
Key to be used to bypass the sustain note.
Definition: gig.h:992
uint16_t LFO1ControlDepth
Controller depth influencing sample amplitude LFO pitch (0 - 1200 cents).
Definition: gig.h:488
file_offset_t SamplesPerFrame
For compressed samples only: number of samples in a full sample frame.
Definition: gig.h:790
Group of Gigasampler samples.
Definition: gig.h:1266
uint8_t VCFVelocityDynamicRange
0x04 = lowest, 0x00 = highest .
Definition: gig.h:527
String Name
Stores the name of this Group.
Definition: gig.h:1268
uint16_t PitchbendRange
Number of semitones pitchbend controller can pitch (default is 2).
Definition: gig.h:1199
double EG1Release
Release time of the sample amplitude EG (0.000 - 60.000s).
Definition: gig.h:479
uint8_t Triggers
Number of triggers.
Definition: gig.h:950
Defines behavior options for envelope generators (gig format extension).
Definition: gig.h:406
vcf_type_t VCFType
Defines the general filter characteristic (lowpass, highpass, bandpass, etc.).
Definition: gig.h:521
uint32_t LoopSize
Caution: Use the respective fields in the DimensionRegion instead of this one! (Intended purpose: Len...
Definition: gig.h:751
loop_type_t LoopType
Caution: Use the respective field in the DimensionRegion instead of this one! (Intended purpose: The ...
Definition: gig.h:748
lfo1_ctrl_t LFO1Controller
MIDI Controller which controls sample amplitude LFO.
Definition: gig.h:489
uint8_t low
Low value of range.
Definition: gig.h:102
Will be thrown whenever a DLS specific error occurs while trying to access a DLS File.
Definition: DLS.h:553
uint16_t SampleStartOffset
Number of samples the sample start should be moved (0 - 2000).
Definition: gig.h:552
MIDI rule for triggering notes by control change events.
Definition: gig.h:947
file_offset_t WorstCaseFrameSize
For compressed samples only: size (in bytes) of the largest possible sample frame.
Definition: gig.h:789
file_offset_t Size
Size of the actual data in the buffer in bytes.
Definition: gig.h:109
bool EG1Hold
If true, Decay1 stage should be postponed until the sample reached the sample loop start...
Definition: gig.h:480
range_t PlayRange
Key range of the playable keys in the instrument.
Definition: gig.h:1025
uint16_t ThresholdTime
Maximum time (ms) between two notes that should be played legato.
Definition: gig.h:994
static size_t Instances
Number of instances of class Sample.
Definition: gig.h:782
uint8_t VelocityResponseCurveScaling
0 - 127 (usually you don&#39;t have to interpret this parameter, use GetVelocityAttenuation() instead)...
Definition: gig.h:536
uint8_t ReleaseTriggerKey
Key triggering release samples.
Definition: gig.h:997
bool VCFKeyboardTracking
If true: VCF cutoff frequence will be dependend to the note key position relative to the defined brea...
Definition: gig.h:531
uint32_t crc
Reflects CRC-32 checksum of the raw sample data at the last time when the sample&#39;s raw wave form data...
Definition: gig.h:795
Defines a controller that has a certain contrained influence on a particular synthesis parameter (use...
Definition: gig.h:236
uint8_t Controller
CC number for controller selector.
Definition: gig.h:1048
Defines Region information of a Gigasampler/GigaStudio instrument.
Definition: gig.h:850
uint32_t LoopPlayCount
Number of times the loop should be played (a value of 0 = infinite).
Definition: gig.h:753
uint8_t ReleaseTriggerDecay
0 - 8
Definition: gig.h:539
lfo3_ctrl_t LFO3Controller
MIDI Controller which controls the sample pitch LFO.
Definition: gig.h:517
bool Chained
If all patterns should be chained together.
Definition: gig.h:1051
uint32_t MIDIUnityNote
Specifies the musical note at which the sample will be played at it&#39;s original sample rate...
Definition: gig.h:742
uint8_t ControllerNumber
MIDI controller number.
Definition: gig.h:949
uint8_t ChannelOffset
Audio output where the audio signal of the dimension region should be routed to (0 - 9)...
Definition: gig.h:549
uint8_t VCFResonance
Firm internal filter resonance weight.
Definition: gig.h:528
bool VCFResonanceDynamic
If true: Increases the resonance Q according to changes of controllers that actually control the VCF ...
Definition: gig.h:529
Language_t Language
Programming language and dialect the script is written in.
Definition: gig.h:1115
unsigned int Dimensions
Number of defined dimensions, do not alter!
Definition: gig.h:852
vcf_cutoff_ctrl_t VCFCutoffController
Specifies which external controller has influence on the filter cutoff frequency. ...
Definition: gig.h:522
file_offset_t loop_cycles_left
How many times the loop has still to be passed, this value will be decremented with each loop cycle...
Definition: gig.h:380
uint16_t MIDIBank
Reflects combination of MIDIBankCoarse and MIDIBankFine (bank 1 - bank 16384). Do not change this val...
Definition: DLS.h:464
double EG1Decay1
Decay time of the sample amplitude EG (0.000 - 60.000s).
Definition: gig.h:475
lfo2_ctrl_t LFO2Controller
MIDI Controlle which controls the filter cutoff LFO.
Definition: gig.h:508
Compression_t Compression
Whether the script was/should be compressed, and if so, which compression algorithm shall be used...
Definition: gig.h:1113
bool Dithered
For 24-bit compressed samples only: if dithering was used during compression with bit reduction...
Definition: gig.h:756
uint8_t VelocityUpperLimit
Defines the upper velocity value limit of a velocity split (only if an user defined limit was set...
Definition: gig.h:470
uint8_t ReleaseVelocityResponseDepth
Dynamic range of release velocity affecting envelope time (0 - 4).
Definition: gig.h:538
const char * enumKey(const std::type_info &type, size_t value)
Enum constant name of numeric value.
Definition: typeinfo.cpp:305
Will be thrown whenever a gig specific error occurs while trying to access a Gigasampler File...
Definition: gig.h:1404
uint8_t MIDIBankCoarse
Reflects the MIDI Bank number for MIDI Control Change 0 (bank 1 - 128).
Definition: DLS.h:465
uint8_t in_end
End position of fade in.
Definition: gig.h:368
static const DLS::version_t VERSION_2
Reflects Gigasampler file format version 2.0 (1998-06-28).
Definition: gig.h:1322
Sample * pSample
Points to the Sample which is assigned to the dimension region.
Definition: gig.h:471
size_t enumValue(String key)
Numeric value of enum constant.
Definition: typeinfo.cpp:219
uint16_t ReleaseTime
Release time.
Definition: gig.h:995
uint32_t LoopStart
Caution: Use the respective field in the DimensionRegion instead of this one! (Intended purpose: The ...
Definition: gig.h:749
double EG2Decay1
Decay time of the filter cutoff EG (0.000 - 60.000s).
Definition: gig.h:495
uint8_t EG1ControllerAttackInfluence
Amount EG1 Controller has influence on the EG1 Attack time (0 - 3, where 0 means off).
Definition: gig.h:483
Compression_t
Definition: gig.h:1105
void DeleteSampleLoop(sample_loop_t *pLoopDef)
Deletes an existing sample loop.
Definition: DLS.cpp:655
smpte_format_t SMPTEFormat
Specifies the Society of Motion Pictures and Television E time format used in the following SMPTEOffs...
Definition: gig.h:744
double SampleAttenuation
Sample volume (calculated from DLS::Sampler::Gain)
Definition: gig.h:553
bool ReleaseCancel
Whether the "release" stage is cancelled when receiving a note-on (default: true).
Definition: gig.h:411
RIFF List Chunk.
Definition: RIFF.h:294
double EG1Decay2
Only if EG1InfiniteSustain == false: 2nd decay stage time of the sample amplitude EG (0...
Definition: gig.h:476
uint8_t BypassController
Controller to be used to bypass the sustain note.
Definition: gig.h:993
attenuation_ctrl_t AttenuationController
MIDI Controller which has influence on the volume level of the sample (or entire sample group)...
Definition: gig.h:546
static buffer_t InternalDecompressionBuffer
Buffer used for decompression as well as for truncation of 24 Bit -> 16 Bit samples.
Definition: gig.h:783
Pointer address and size of a buffer.
Definition: gig.h:107
bool Decay1Cancel
Whether the "decay 1" stage is cancelled when receiving a note-off (default: true).
Definition: gig.h:409
uint8_t in_start
Start position of fade in.
Definition: gig.h:367
uint8_t Patterns
Number of alternator patterns.
Definition: gig.h:1027
dimension_t dimension
Specifies which source (usually a MIDI controller) is associated with the dimension.
Definition: gig.h:334
bool Bypass
Global bypass: if enabled, this script shall not be executed by the sampler for any instrument...
Definition: gig.h:1116
Abstract base class which provides mandatory informations about sample players in general...
Definition: DLS.h:365
range_t KeyRange
Key range for legato notes.
Definition: gig.h:996
bool EG2ControllerInvert
Invert values coming from defined EG2 controller.
Definition: gig.h:501
uint8_t Articulations
Number of articulations in the instrument.
Definition: gig.h:1022
eg_opt_t EG2Options
[gig extension]: Behavior options which should be used for envelope generator 2 (filter cutoff EG)...
Definition: gig.h:556
String Name
Arbitrary name of the script, which may be displayed i.e. in an instrument editor.
Definition: gig.h:1112
uint32_t DimensionRegions
Total number of DimensionRegions this Region contains, do not alter!
Definition: gig.h:854
bool MSDecode
Gigastudio flag: defines if Mid Side Recordings should be decoded.
Definition: gig.h:551
bool EG1InfiniteSustain
If true, instead of going into Decay2 phase, Decay1 level will be hold until note will be released...
Definition: gig.h:477
bool Compressed
If the sample wave is compressed (probably just interesting for instrument and sample editors...
Definition: gig.h:754
void SetFileName(const String &name)
You may call this method store a future file name, so you don&#39;t have to to pass it to the Save() call...
Definition: DLS.cpp:1686
uint32_t SampleLoops
Reflects the number of sample loops.
Definition: DLS.h:372
virtual void Save(const String &Path, progress_t *pProgress=NULL)
Save changes to another file.
Definition: DLS.cpp:1803
uint16_t LFO2InternalDepth
Firm pitch of the filter cutoff LFO (0 - 1200 cents).
Definition: gig.h:506
uint16_t LFO1InternalDepth
Firm pitch of the sample amplitude LFO (0 - 1200 cents).
Definition: gig.h:487
float zone_size
Intended for internal usage: reflects the size of each zone (128/zones) for normal split types only...
Definition: gig.h:338
bool PitchTrack
If true: sample will be pitched according to the key position (this will be disabled for drums for ex...
Definition: gig.h:542
Encoding_t
Definition: gig.h:1102
uint64_t file_offset_t
Type used by libgig for handling file positioning during file I/O tasks.
Definition: RIFF.h:148
bool BypassUseController
If a controller should be used to bypass the sustain note.
Definition: gig.h:991
unsigned int Layers
Amount of defined layers (1 - 32). A value of 1 actually means no layering, a value > 1 means there i...
Definition: gig.h:856
void * pStart
Points to the beginning of the buffer.
Definition: gig.h:108
bool EG2InfiniteSustain
If true, instead of going into Decay2 phase, Decay1 level will be hold until note will be released...
Definition: gig.h:497
Group * pGroup
pointer to the Group this sample belongs to (always not-NULL)
Definition: gig.h:784
uint8_t EG2ControllerAttackInfluence
Amount EG2 Controller has influence on the EG2 Attack time (0 - 3, where 0 means off).
Definition: gig.h:502
bool SelfMask
If true: high velocity notes will stop low velocity notes at the same note, with that you can save vo...
Definition: gig.h:545
int16_t LFO3ControlDepth
Controller depth of the sample pitch LFO (-1200 - +1200 cents).
Definition: gig.h:516
double EG3Attack
Attack time of the sample pitch EG (0.000 - 10.000s).
Definition: gig.h:512
uint8_t LegatoSamples
Number of legato samples per key in each direction (always 12)
Definition: gig.h:990
uint8_t out_end
End postition of fade out.
Definition: gig.h:370
double EG2Attack
Attack time of the filter cutoff EG (0.000 - 60.000s).
Definition: gig.h:494
bool InvertAttenuationController
Inverts the values coming from the defined Attenuation Controller.
Definition: gig.h:547
double LFO1Frequency
Frequency of the sample amplitude LFO (0.10 - 10.00 Hz).
Definition: gig.h:486
Ordinary RIFF Chunk.
Definition: RIFF.h:218
uint32_t LoopID
Specifies the unique ID that corresponds to one of the defined cue points in the cue point list (only...
Definition: gig.h:747
bool LFO1FlipPhase
Inverts phase of the sample amplitude LFO wave.
Definition: gig.h:490
uint8_t AltSustain1Key
Key triggering alternate sustain samples.
Definition: gig.h:998
int16_t FineTune
in cents
Definition: gig.h:1198
bool LFO3Sync
If set to true only one LFO should be used for all voices.
Definition: gig.h:518
uint32_t MIDIProgram
Specifies the MIDI Program Change Number this Instrument should be assigned to.
Definition: DLS.h:467
loop_type_normal
Standard types of sample loops.
Definition: gig.h:126
double LFO3Frequency
Frequency of the sample pitch LFO (0.10 - 10.00 Hz).
Definition: gig.h:514
static const DLS::version_t VERSION_3
Reflects Gigasampler file format version 3.0 (2003-03-31).
Definition: gig.h:1323
uint32_t Product
Specifies the MIDI model ID defined by the manufacturer corresponding to the Manufacturer field...
Definition: gig.h:740
bool LFO1Sync
If set to true only one LFO should be used for all voices.
Definition: gig.h:491
uint8_t EG2ControllerReleaseInfluence
Amount EG2 Controller has influence on the EG2 Release time (0 - 3, where 0 means off)...
Definition: gig.h:504
size_t enumCount(const std::type_info &type)
Amount of elements in given enum type.
Definition: typeinfo.cpp:206
Used for indicating the progress of a certain task.
Definition: RIFF.h:204
uint16_t EG2PreAttack
Preattack value of the filter cutoff EG (0 - 1000 permille).
Definition: gig.h:493
uint32_t Loops
Caution: Use the respective field in the DimensionRegion instead of this one! (Intended purpose: Numb...
Definition: gig.h:746
bool LFO2Sync
If set to true only one LFO should be used for all voices.
Definition: gig.h:510
uint32_t SMPTEOffset
The SMPTE Offset value specifies the time offset to be used for the synchronization / calibration to ...
Definition: gig.h:745
unsigned long FileNo
File number (> 0 when sample is stored in an extension file, 0 when it&#39;s in the gig) ...
Definition: gig.h:792
bool EG1ControllerInvert
Invert values coming from defined EG1 controller.
Definition: gig.h:482
dim_bypass_ctrl_none dim_bypass_ctrl_t
Dimensions allow to bypass one of the following controllers.
Definition: gig.h:159
version_t * pVersion
Points to a version_t structure if the file provided a version number else is set to NULL...
Definition: DLS.h:500
uint16_t LFO2ControlDepth
Controller depth influencing filter cutoff LFO pitch (0 - 1200).
Definition: gig.h:507
bool AttackHoldCancel
Whether the "attack hold" stage is cancelled when receiving a note-off (default: true).
Definition: gig.h:408
String Name
Name of this script group. For example to be displayed in an instrument editor.
Definition: gig.h:1150
file_offset_t * FrameTable
For positioning within compressed samples only: stores the offset values for each frame...
Definition: gig.h:786
int16_t EG3Depth
Depth of the sample pitch EG (-1200 - +1200).
Definition: gig.h:513
uint8_t VCFKeyboardTrackingBreakpoint
See VCFKeyboardTracking (0 - 127).
Definition: gig.h:532
eg2_ctrl_t EG2Controller
MIDI Controller which has influence on filter cutoff EG parameters (attack, decay, release).
Definition: gig.h:500
bool VCFCutoffControllerInvert
Inverts values coming from the defined cutoff controller.
Definition: gig.h:523
file_offset_t NullExtensionSize
The buffer might be bigger than the actual data, if that&#39;s the case that unused space at the end of t...
Definition: gig.h:110
double EG2Release
Release time of the filter cutoff EG (0.000 - 60.000s).
Definition: gig.h:499
uint8_t EG1ControllerReleaseInfluence
Amount EG1 Controller has influence on the EG1 Release time (0 - 3, where 0 means off)...
Definition: gig.h:485
uint8_t EG2ControllerDecayInfluence
Amount EG2 Controller has influence on the EG2 Decay time (0 - 3, where 0 means off).
Definition: gig.h:503
bool Polyphonic
If alternator should step forward only when all notes are off.
Definition: gig.h:1050
Abstract base class for all MIDI rules.
Definition: gig.h:926
file_offset_t SamplesInLastFrame
For compressed samples only: length of the last sample frame.
Definition: gig.h:788
uint32_t LoopEnd
Caution: Use the respective field in the DimensionRegion instead of this one! (Intended purpose: The ...
Definition: gig.h:750
bool AttackCancel
Whether the "attack" stage is cancelled when receiving a note-off (default: true).
Definition: gig.h:407
Defines the envelope of a crossfade.
Definition: gig.h:360
uint8_t MIDIBankFine
Reflects the MIDI Bank number for MIDI Control Change 32 (bank 1 - 128).
Definition: DLS.h:466
curve_type_t ReleaseVelocityResponseCurve
Defines a transformation curve to the incoming release veloctiy values affecting envelope times...
Definition: gig.h:537
uint8_t zones
Number of zones the dimension has.
Definition: gig.h:336
uint8_t AttenuationControllerThreshold
0-127
Definition: gig.h:548
Encapsulates sample waves of Gigasampler/GigaStudio files used for playback.
Definition: gig.h:737
RIFF File.
Definition: RIFF.h:344
int16_t LFO3InternalDepth
Firm depth of the sample pitch LFO (-1200 - +1200 cents).
Definition: gig.h:515
Lower and upper limit of a range.
Definition: gig.h:101
double EG2Decay2
Only if EG2InfiniteSustain == false: 2nd stage decay time of the filter cutoff EG (0...
Definition: gig.h:496
int32_t Attenuation
in dB
Definition: gig.h:1196
Encapsulates sample waves used for playback.
Definition: DLS.h:396
type_t type
Controller type.
Definition: gig.h:248
uint controller_number
MIDI controller number if this controller is a control change controller, 0 otherwise.
Definition: gig.h:249
uint8_t * VelocityTable
For velocity dimensions with custom defined zone ranges only: used for fast converting from velocity ...
Definition: gig.h:587
curve_type_t VelocityResponseCurve
Defines a transformation curve to the incoming velocity values affecting amplitude (usually you don&#39;t...
Definition: gig.h:534
A MIDI rule not yet implemented by libgig.
Definition: gig.h:1073
uint16_t EG1Sustain
Sustain value of the sample amplitude EG (0 - 1000 permille).
Definition: gig.h:478
String GetFileName()
File name of this DLS file.
Definition: DLS.cpp:1678
Real-time instrument script (gig format extension).
Definition: gig.h:1100
Gigasampler/GigaStudio specific classes and definitions.
Definition: gig.h:94
uint8_t VelocityResponseDepth
Dynamic range of velocity affecting amplitude (0 - 4) (usually you don&#39;t have to interpret this param...
Definition: gig.h:535
uint32_t LoopFraction
The fractional value specifies a fraction of a sample at which to loop. This allows a loop to be fine...
Definition: gig.h:752
uint32_t TruncatedBits
For 24-bit compressed samples only: number of bits truncated during compression (0, 4 or 6)
Definition: gig.h:755
const char ** enumKeys(const std::type_info &type)
All element names of enum type.
Definition: typeinfo.cpp:342
Group of instrument scripts (gig format extension).
Definition: gig.h:1148
Language_t
Definition: gig.h:1108
int8_t Pan
Panorama / Balance (-64..0..63 <-> left..middle..right)
Definition: gig.h:544
Provides convenient access to Gigasampler/GigaStudio .gig files.
Definition: gig.h:1320
MIDI rule for instruments with legato samples.
Definition: gig.h:988
uint16_t EG2Sustain
Sustain value of the filter cutoff EG (0 - 1000 permille).
Definition: gig.h:498
dlsid_t * pDLSID
Points to a dlsid_t structure if the file provided a DLS ID else is NULL.
Definition: DLS.h:349
uint32_t Instruments
Reflects the number of available Instrument objects.
Definition: DLS.h:501
Provides all neccessary information for the synthesis of a DLS Instrument.
Definition: DLS.h:461
Provides access to a Gigasampler/GigaStudio instrument.
Definition: gig.h:1183
bool SustainDefeat
If true: Sustain pedal will not hold a note.
Definition: gig.h:550
Encoding_t Encoding
Format the script&#39;s source code text is encoded with.
Definition: gig.h:1114
buffer_t RAMCache
Buffers samples (already uncompressed) in RAM.
Definition: gig.h:791
int32_t Gain
Definition: DLS.h:369
Quadtuple version number ("major.minor.release.build").
Definition: DLS.h:111
Serialization / deserialization framework.
Definition: gig.h:91
bool Decay2Cancel
Whether the "decay 2" stage is cancelled when receiving a note-off (default: true).
Definition: gig.h:410
double LFO2Frequency
Frequency of the filter cutoff LFO (0.10 - 10.00 Hz).
Definition: gig.h:505
uint32_t SamplePeriod
Specifies the duration of time that passes during the playback of one sample in nanoseconds (normally...
Definition: gig.h:741
uint16_t EG1PreAttack
Preattack value of the sample amplitude EG (0 - 1000 permille).
Definition: gig.h:473
uint8_t bits
Number of "bits" (1 bit = 2 splits/zones, 2 bit = 4 splits/zones, 3 bit = 8 splits/zones,...).
Definition: gig.h:335
selector_t Selector
Method by which pattern is chosen.
Definition: gig.h:1046
uint8_t out_start
Start position of fade out.
Definition: gig.h:369
uint8_t VCFCutoff
Max. cutoff frequency.
Definition: gig.h:524
eg_opt_t EG1Options
[gig extension]: Behavior options which should be used for envelope generator 1 (volume amplitude EG)...
Definition: gig.h:555
Info * pInfo
Points (in any case) to an Info object, providing additional, optional infos and comments.
Definition: DLS.h:348
uint32_t Manufacturer
Specifies the MIDI Manufacturer&#39;s Association (MMA) Manufacturer code for the sampler intended to rec...
Definition: gig.h:739
uint8_t high
High value of range.
Definition: gig.h:103
MIDI rule to automatically cycle through specified sequences of different articulations.
Definition: gig.h:1020
Reflects the current playback state for a sample.
Definition: gig.h:377
General dimension definition.
Definition: gig.h:333
eg1_ctrl_t EG1Controller
MIDI Controller which has influence on sample amplitude EG parameters (attack, decay, release).
Definition: gig.h:481
split_type_t split_type
Intended for internal usage: will be used to convert a dimension value into the corresponding dimensi...
Definition: gig.h:337
vcf_res_ctrl_t VCFResonanceController
Specifies which external controller has influence on the filter resonance Q.
Definition: gig.h:530
curve_type_t VCFVelocityCurve
Defines a transformation curve for the incoming velocity values, affecting the VCF.
Definition: gig.h:525
uint8_t EG1ControllerDecayInfluence
Amount EG1 Controller has influence on the EG1 Decay time (0 - 3, where 0 means off).
Definition: gig.h:484
Defines Region information of an Instrument.
Definition: DLS.h:431
double EG1Attack
Attack time of the sample amplitude EG (0.000 - 60.000s).
Definition: gig.h:474
bool IsDrum
Indicates if the Instrument is a drum type, as they differ in the synthesis model of DLS from melodic...
Definition: DLS.h:463
void AddSampleLoop(sample_loop_t *pLoopDef)
Adds a new sample loop with the provided loop definition.
Definition: DLS.cpp:633