libgig  4.2.0
gig.h
1 /***************************************************************************
2  * *
3  * libgig - C++ cross-platform Gigasampler format file access library *
4  * *
5  * Copyright (C) 2003-2018 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,
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,
159  );
160 
165  GIG_DECLARE_ENUM(lfo3_ctrl_t,
166  lfo3_ctrl_internal = 0x00,
167  lfo3_ctrl_modwheel = 0x01,
168  lfo3_ctrl_aftertouch = 0x02,
171  );
172 
177  GIG_DECLARE_ENUM(lfo2_ctrl_t,
178  lfo2_ctrl_internal = 0x00,
179  lfo2_ctrl_modwheel = 0x01,
180  lfo2_ctrl_foot = 0x02,
183  );
184 
189  GIG_DECLARE_ENUM(lfo1_ctrl_t,
190  lfo1_ctrl_internal = 0x00,
191  lfo1_ctrl_modwheel = 0x01,
192  lfo1_ctrl_breath = 0x02,
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,
214  );
215 
220  GIG_DECLARE_ENUM(vcf_res_ctrl_t,
221  vcf_res_ctrl_none = 0xffffffff,
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 
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,
290  dimension_releasetrigger = 0x84,
291  dimension_keyboard = 0x85,
292  dimension_roundrobin = 0x86,
293  dimension_random = 0x87,
294  dimension_smartmidi = 0x88,
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,
330  );
331 
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 
433  GIG_DECLARE_ENUM(sust_rel_trg_t,
434  sust_rel_trg_none = 0x00,
435  sust_rel_trg_maxvelocity = 0x01,
437  );
438 
439  // just symbol prototyping
440  class File;
441  class Instrument;
442  class Sample;
443  class Region;
444  class Group;
445  class Script;
446  class ScriptGroup;
447 
490  class DimensionRegion : protected DLS::Sampler {
491  public:
494  // Sample Amplitude EG/LFO
495  uint16_t EG1PreAttack;
496  double EG1Attack;
497  double EG1Decay1;
498  double EG1Decay2;
500  uint16_t EG1Sustain;
501  double EG1Release;
502  bool EG1Hold;
508  double LFO1Frequency;
509  uint16_t LFO1InternalDepth;
510  uint16_t LFO1ControlDepth;
513  bool LFO1Sync;
514  // Filter Cutoff Frequency EG/LFO
515  uint16_t EG2PreAttack;
516  double EG2Attack;
517  double EG2Decay1;
518  double EG2Decay2;
520  uint16_t EG2Sustain;
521  double EG2Release;
527  double LFO2Frequency;
528  uint16_t LFO2InternalDepth;
529  uint16_t LFO2ControlDepth;
532  bool LFO2Sync;
533  // Sample Pitch EG/LFO
534  double EG3Attack;
535  int16_t EG3Depth;
536  double LFO3Frequency;
540  bool LFO3Sync;
541  // Filter
542  bool VCFEnabled;
546  uint8_t VCFCutoff;
550  uint8_t VCFResonance;
555  // Key Velocity Transformations
562  // Mix / Layer
563  crossfade_t Crossfade;
564  bool PitchTrack;
566  int8_t Pan;
567  bool SelfMask;
571  uint8_t ChannelOffset;
573  bool MSDecode;
574  uint16_t SampleStartOffset;
576  uint8_t DimensionUpperLimits[8];
581 
582  // derived attributes from DLS::Sampler
583  using DLS::Sampler::UnityNote;
584  using DLS::Sampler::FineTune;
585  using DLS::Sampler::Gain;
588 
589  // own methods
590  double GetVelocityAttenuation(uint8_t MIDIKeyVelocity);
591  double GetVelocityRelease(uint8_t MIDIKeyVelocity);
592  double GetVelocityCutoff(uint8_t MIDIKeyVelocity);
594  void SetVelocityResponseDepth(uint8_t depth);
595  void SetVelocityResponseCurveScaling(uint8_t scaling);
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;
603  // derived methods
606  // overridden methods
607  virtual void SetGain(int32_t gain) OVERRIDE;
608  virtual void UpdateChunks(progress_t* pProgress) OVERRIDE;
609  virtual void CopyAssign(const DimensionRegion* orig);
610  protected:
611  uint8_t* VelocityTable;
612  DimensionRegion(Region* pParent, RIFF::List* _3ewl);
613  DimensionRegion(RIFF::List* _3ewl, const DimensionRegion& src);
614  ~DimensionRegion();
615  void CopyAssign(const DimensionRegion* orig, const std::map<Sample*,Sample*>* mSamples);
616  void serialize(Serialization::Archive* archive);
617  friend class Region;
618  friend class Serialization::Archive;
619  private:
620  typedef enum {
621  // official leverage controllers as they were defined in the original Gigasampler/GigaStudio format:
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,
648 
649  // format extension (these controllers are so far only supported by LinuxSampler & gigedit) they will *NOT* work with Gigasampler/GigaStudio !
650  // (the assigned values here are their official MIDI CC number plus the highest bit set):
651  _lev_ctrl_CC3_EXT = 0x83,
652 
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,
659 
660  _lev_ctrl_CC14_EXT = 0x8e,
661  _lev_ctrl_CC15_EXT = 0x8f,
662 
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,
675 
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,
688 
689  _lev_ctrl_CC84_EXT = 0xd4,
690  _lev_ctrl_CC85_EXT = 0xd5,
691  _lev_ctrl_CC86_EXT = 0xd6,
692  _lev_ctrl_CC87_EXT = 0xd7,
693 
694  _lev_ctrl_CC89_EXT = 0xd9,
695  _lev_ctrl_CC90_EXT = 0xda,
696 
697  _lev_ctrl_CC96_EXT = 0xe0,
698  _lev_ctrl_CC97_EXT = 0xe1,
699 
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
718  } _lev_ctrl_t;
719  typedef std::map<uint32_t, double*> VelocityTableMap;
720 
721  static size_t Instances;
722  static VelocityTableMap* pVelocityTables;
723  double* pVelocityAttenuationTable;
724  double* pVelocityReleaseTable;
725  double* pVelocityCutoffTable;
726  Region* pRegion;
727 
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);
734  };
735 
761  class Sample : public DLS::Sample {
762  public:
763  uint32_t Manufacturer;
764  uint32_t Product;
765  uint32_t SamplePeriod;
766  uint32_t MIDIUnityNote;
767  uint32_t FineTune;
769  uint32_t SMPTEOffset;
770  uint32_t Loops;
771  uint32_t LoopID;
773  uint32_t LoopStart;
774  uint32_t LoopEnd;
775  uint32_t LoopSize;
776  uint32_t LoopFraction;
777  uint32_t LoopPlayCount;
778  bool Compressed;
779  uint32_t TruncatedBits;
780  bool Dithered;
781 
782  // own methods
784  buffer_t LoadSampleData(file_offset_t SampleCount);
785  buffer_t LoadSampleDataWithNullSamplesExtension(uint NullSamplesCount);
786  buffer_t LoadSampleDataWithNullSamplesExtension(file_offset_t SampleCount, uint NullSamplesCount);
787  buffer_t GetCache();
788  // own static methods
789  static buffer_t CreateDecompressionBuffer(file_offset_t MaxReadSize);
790  static void DestroyDecompressionBuffer(buffer_t& DecompressionBuffer);
791  // overridden methods
792  void ReleaseSampleData();
793  void Resize(file_offset_t NewSize);
794  file_offset_t SetPos(file_offset_t SampleCount, RIFF::stream_whence_t Whence = RIFF::stream_start);
795  file_offset_t GetPos() const;
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) OVERRIDE;
801  void CopyAssignMeta(const Sample* orig);
802  void CopyAssignWave(const Sample* orig);
803  uint32_t GetWaveDataCRC32Checksum();
804  bool VerifyWaveData(uint32_t* pActually = NULL);
805  protected:
806  static size_t Instances;
809  file_offset_t FrameOffset;
810  file_offset_t* FrameTable;
811  file_offset_t SamplePos;
812  file_offset_t SamplesInLastFrame;
813  file_offset_t WorstCaseFrameSize;
814  file_offset_t SamplesPerFrame;
816  unsigned long FileNo;
817  RIFF::Chunk* pCk3gix;
818  RIFF::Chunk* pCkSmpl;
819  uint32_t crc;
820 
821  Sample(File* pFile, RIFF::List* waveList, file_offset_t WavePoolOffset, unsigned long fileNo = 0, int index = -1);
822  ~Sample();
823  uint32_t CalculateWaveDataChecksum();
824 
825  // Guess size (in bytes) of a compressed sample
826  inline file_offset_t GuessSize(file_offset_t samples) {
827  // 16 bit: assume all frames are compressed - 1 byte
828  // per sample and 5 bytes header per 2048 samples
829 
830  // 24 bit: assume next best compression rate - 1.5
831  // bytes per sample and 13 bytes header per 256
832  // samples
833  const file_offset_t size =
834  BitDepth == 24 ? samples + (samples >> 1) + (samples >> 8) * 13
835  : samples + (samples >> 10) * 5;
836  // Double for stereo and add one worst case sample
837  // frame
838  return (Channels == 2 ? size << 1 : size) + WorstCaseFrameSize;
839  }
840 
841  // Worst case amount of sample points that can be read with the
842  // given decompression buffer.
843  inline file_offset_t WorstCaseMaxSamples(buffer_t* pDecompressionBuffer) {
844  return (file_offset_t) ((float)pDecompressionBuffer->Size / (float)WorstCaseFrameSize * (float)SamplesPerFrame);
845  }
846  private:
847  void ScanCompressedSample();
848  friend class File;
849  friend class Region;
850  friend class Group; // allow to modify protected member pGroup
851  };
852 
853  // TODO: <3dnl> list not used yet - not important though (just contains optional descriptions for the dimensions)
874  class Region : public DLS::Region {
875  public:
876  unsigned int Dimensions;
878  uint32_t DimensionRegions;
880  unsigned int Layers;
881 
882  // own methods
883  DimensionRegion* GetDimensionRegionByValue(const uint DimValues[8]);
884  DimensionRegion* GetDimensionRegionByBit(const uint8_t DimBits[8]);
885  int GetDimensionRegionIndexByValue(const uint DimValues[8]);
886  Sample* GetSample();
887  void AddDimension(dimension_def_t* pDimDef);
888  void DeleteDimension(dimension_def_t* pDimDef);
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);
893  // overridden methods
894  virtual void SetKeyRange(uint16_t Low, uint16_t High) OVERRIDE;
895  virtual void UpdateChunks(progress_t* pProgress) OVERRIDE;
896  virtual void CopyAssign(const Region* orig);
897  protected:
898  Region(Instrument* pInstrument, RIFF::List* rgnList);
899  void LoadDimensionRegions(RIFF::List* rgn);
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);
904  ~Region();
905  friend class Instrument;
906  };
907 
950  class MidiRule {
951  public:
952  virtual ~MidiRule() { }
953  protected:
954  virtual void UpdateChunks(uint8_t* pData) const = 0;
955  friend class Instrument;
956  };
957 
971  class MidiRuleCtrlTrigger : public MidiRule {
972  public:
974  uint8_t Triggers;
975  struct trigger_t {
976  uint8_t TriggerPoint;
977  bool Descending;
978  uint8_t VelSensitivity;
979  uint8_t Key;
980  bool NoteOff;
981  uint8_t Velocity;
982  bool OverridePedal;
983  } pTriggers[32];
984 
985  protected:
988  void UpdateChunks(uint8_t* pData) const OVERRIDE;
989  friend class Instrument;
990  };
991 
1012  class MidiRuleLegato : public MidiRule {
1013  public:
1014  uint8_t LegatoSamples;
1016  uint8_t BypassKey;
1018  uint16_t ThresholdTime;
1019  uint16_t ReleaseTime;
1022  uint8_t AltSustain1Key;
1023  uint8_t AltSustain2Key;
1024 
1025  protected:
1026  MidiRuleLegato(RIFF::Chunk* _3ewg);
1027  MidiRuleLegato();
1028  void UpdateChunks(uint8_t* pData) const OVERRIDE;
1029  friend class Instrument;
1030  };
1031 
1044  class MidiRuleAlternator : public MidiRule {
1045  public:
1046  uint8_t Articulations;
1047  String pArticulations[32];
1048 
1050 
1051  uint8_t Patterns;
1052  struct pattern_t {
1053  String Name;
1054  int Size;
1055  const uint8_t& operator[](int i) const {
1056  return data[i];
1057  }
1058  uint8_t& operator[](int i) {
1059  return data[i];
1060  }
1061  private:
1062  uint8_t data[32];
1063  } pPatterns[32];
1064 
1065  typedef enum {
1066  selector_none,
1067  selector_key_switch,
1068  selector_controller
1069  } selector_t;
1070  selector_t Selector;
1072  uint8_t Controller;
1073 
1074  bool Polyphonic;
1075  bool Chained;
1076 
1077  protected:
1080  void UpdateChunks(uint8_t* pData) const OVERRIDE;
1081  friend class Instrument;
1082  };
1083 
1097  class MidiRuleUnknown : public MidiRule {
1098  protected:
1099  MidiRuleUnknown() { }
1100  void UpdateChunks(uint8_t* pData) const OVERRIDE { }
1101  friend class Instrument;
1102  };
1103 
1124  class Script : protected DLS::Storage {
1125  public:
1126  enum Encoding_t {
1128  };
1131  };
1132  enum Language_t {
1134  };
1135 
1136  String Name;
1140  bool Bypass;
1141 
1142  String GetScriptAsText();
1143  void SetScriptAsText(const String& text);
1144  void SetGroup(ScriptGroup* pGroup);
1145  ScriptGroup* GetGroup() const;
1146  void CopyAssign(const Script* orig);
1147  protected:
1148  Script(ScriptGroup* group, RIFF::Chunk* ckScri);
1149  virtual ~Script();
1150  void UpdateChunks(progress_t* pProgress) OVERRIDE;
1151  void DeleteChunks() OVERRIDE;
1152  void RemoveAllScriptReferences();
1153  friend class ScriptGroup;
1154  friend class Instrument;
1155  private:
1156  ScriptGroup* pGroup;
1157  RIFF::Chunk* pChunk;
1158  std::vector<uint8_t> data;
1159  uint32_t crc;
1160  };
1161 
1173  class ScriptGroup : protected DLS::Storage {
1174  public:
1175  String Name;
1176 
1177  Script* GetScript(uint index);
1178  Script* AddScript();
1179  void DeleteScript(Script* pScript);
1180  protected:
1181  ScriptGroup(File* file, RIFF::List* lstRTIS);
1182  virtual ~ScriptGroup();
1183  void LoadScripts();
1184  virtual void UpdateChunks(progress_t* pProgress) OVERRIDE;
1185  virtual void DeleteChunks() OVERRIDE;
1186  friend class Script;
1187  friend class File;
1188  private:
1189  File* pFile;
1190  RIFF::List* pList;
1191  std::list<Script*>* pScripts;
1192  };
1193 
1209  class Instrument : protected DLS::Instrument {
1210  public:
1211  // derived attributes from DLS::Resource
1212  using DLS::Resource::pInfo;
1213  using DLS::Resource::pDLSID;
1214  // derived attributes from DLS::Instrument
1221  // own attributes
1222  int32_t Attenuation;
1223  uint16_t EffectSend;
1224  int16_t FineTune;
1225  uint16_t PitchbendRange;
1226  bool PianoReleaseMode;
1228 
1229 
1230  // derived methods from DLS::Resource
1231  using DLS::Resource::GetParent;
1232  // overridden methods
1233  Region* GetFirstRegion();
1234  Region* GetNextRegion();
1235  Region* AddRegion();
1236  void DeleteRegion(Region* pRegion);
1237  void MoveTo(Instrument* dst);
1238  virtual void UpdateChunks(progress_t* pProgress) OVERRIDE;
1239  virtual void CopyAssign(const Instrument* orig);
1240  // own methods
1241  Region* GetRegion(unsigned int Key);
1242  MidiRule* GetMidiRule(int i);
1243  MidiRuleCtrlTrigger* AddMidiRuleCtrlTrigger();
1244  MidiRuleLegato* AddMidiRuleLegato();
1245  MidiRuleAlternator* AddMidiRuleAlternator();
1246  void DeleteMidiRule(int i);
1247  // real-time instrument script methods
1248  Script* GetScriptOfSlot(uint index);
1249  void AddScriptSlot(Script* pScript, bool bypass = false);
1250  void SwapScriptSlots(uint index1, uint index2);
1251  void RemoveScriptSlot(uint index);
1252  void RemoveScript(Script* pScript);
1253  uint ScriptSlotCount() const;
1254  bool IsScriptSlotBypassed(uint index);
1255  void SetScriptSlotBypassed(uint index, bool bBypass);
1256  protected:
1257  Region* RegionKeyTable[128];
1258 
1259  Instrument(File* pFile, RIFF::List* insList, progress_t* pProgress = NULL);
1260  ~Instrument();
1261  void CopyAssign(const Instrument* orig, const std::map<Sample*,Sample*>* mSamples);
1262  void UpdateRegionKeyTable();
1263  void LoadScripts();
1264  void UpdateScriptFileOffsets();
1265  friend class File;
1266  friend class Region; // so Region can call UpdateRegionKeyTable()
1267  private:
1268  struct _ScriptPooolEntry {
1269  uint32_t fileOffset;
1270  bool bypass;
1271  };
1272  struct _ScriptPooolRef {
1273  Script* script;
1274  bool bypass;
1275  };
1276  MidiRule** pMidiRules;
1277  std::vector<_ScriptPooolEntry> scriptPoolFileOffsets;
1278  std::vector<_ScriptPooolRef>* pScriptRefs;
1279  };
1280 
1292  class Group : public DLS::Storage {
1293  public:
1294  String Name;
1295 
1296  Sample* GetFirstSample();
1297  Sample* GetNextSample();
1298  void AddSample(Sample* pSample);
1299  protected:
1300  Group(File* file, RIFF::Chunk* ck3gnm);
1301  virtual ~Group();
1302  virtual void UpdateChunks(progress_t* pProgress) OVERRIDE;
1303  virtual void DeleteChunks() OVERRIDE;
1304  void MoveAll();
1305  friend class File;
1306  private:
1307  File* pFile;
1308  RIFF::Chunk* pNameChunk;
1309  };
1310 
1347  class File : protected DLS::File {
1348  public:
1352 
1353  // derived attributes from DLS::Resource
1354  using DLS::Resource::pInfo;
1355  using DLS::Resource::pDLSID;
1356  // derived attributes from DLS::File
1357  using DLS::File::pVersion;
1358  using DLS::File::Instruments;
1359 
1360  // derived methods from DLS::Resource
1361  using DLS::Resource::GetParent;
1362  // derived methods from DLS::File
1363  using DLS::File::Save;
1364  using DLS::File::GetFileName;
1365  using DLS::File::SetFileName;
1366  using DLS::File::GetRiffFile;
1367  // overridden methods
1368  File();
1369  File(RIFF::File* pRIFF);
1370  Sample* GetFirstSample(progress_t* pProgress = NULL);
1371  Sample* GetNextSample();
1372  Sample* GetSample(uint index);
1373  Sample* AddSample();
1374  size_t CountSamples();
1375  void DeleteSample(Sample* pSample);
1376  Instrument* GetFirstInstrument();
1377  Instrument* GetNextInstrument();
1378  Instrument* GetInstrument(uint index, progress_t* pProgress = NULL);
1379  Instrument* AddInstrument();
1380  Instrument* AddDuplicateInstrument(const Instrument* orig);
1381  size_t CountInstruments();
1382  void DeleteInstrument(Instrument* pInstrument);
1383  Group* GetFirstGroup();
1384  Group* GetNextGroup();
1385  Group* GetGroup(uint index);
1386  Group* GetGroup(String name);
1387  Group* AddGroup();
1388  void DeleteGroup(Group* pGroup);
1389  void DeleteGroupOnly(Group* pGroup);
1390  void SetAutoLoad(bool b);
1391  bool GetAutoLoad();
1392  void AddContentOf(File* pFile);
1393  ScriptGroup* GetScriptGroup(uint index);
1394  ScriptGroup* GetScriptGroup(const String& name);
1395  ScriptGroup* AddScriptGroup();
1396  void DeleteScriptGroup(ScriptGroup* pGroup);
1397  virtual ~File();
1398  virtual void UpdateChunks(progress_t* pProgress) OVERRIDE;
1399  protected:
1400  // overridden protected methods from DLS::File
1401  virtual void LoadSamples() OVERRIDE;
1402  virtual void LoadInstruments() OVERRIDE;
1403  virtual void LoadGroups();
1404  virtual void UpdateFileOffsets() OVERRIDE;
1405  // own protected methods
1406  virtual void LoadSamples(progress_t* pProgress);
1407  virtual void LoadInstruments(progress_t* pProgress);
1408  virtual void LoadScriptGroups();
1409  void SetSampleChecksum(Sample* pSample, uint32_t crc);
1410  uint32_t GetSampleChecksum(Sample* pSample);
1411  uint32_t GetSampleChecksumByIndex(int index);
1412  bool VerifySampleChecksumTable();
1413  bool RebuildSampleChecksumTable();
1414  int GetWaveTableIndexOf(gig::Sample* pSample);
1415  friend class Region;
1416  friend class Sample;
1417  friend class Instrument;
1418  friend class Group; // so Group can access protected member pRIFF
1419  friend class ScriptGroup; // so ScriptGroup can access protected member pRIFF
1420  private:
1421  std::list<Group*>* pGroups;
1422  std::list<Group*>::iterator GroupsIterator;
1423  bool bAutoLoad;
1424  std::list<ScriptGroup*>* pScriptGroups;
1425  };
1426 
1435  class Exception : public DLS::Exception {
1436  public:
1437  Exception(String format, ...);
1438  Exception(String format, va_list arg);
1439  void PrintMessage();
1440  protected:
1441  Exception();
1442  };
1443 
1444 #if HAVE_RTTI
1445  size_t enumCount(const std::type_info& type);
1446  const char* enumKey(const std::type_info& type, size_t value);
1447  bool enumKey(const std::type_info& type, String key);
1448  const char** enumKeys(const std::type_info& type);
1449 #endif // HAVE_RTTI
1450  size_t enumCount(String typeName);
1451  const char* enumKey(String typeName, size_t value);
1452  bool enumKey(String typeName, String key);
1453  const char** enumKeys(String typeName);
1454  size_t enumValue(String key);
1455 
1456  String libraryName();
1457  String libraryVersion();
1458 
1459 } // namespace gig
1460 
1461 #endif // __GIG_H__
gig::Sample::~Sample
~Sample()
Destructor.
Definition: gig.cpp:1477
gig::DimensionRegion::InvertAttenuationController
bool InvertAttenuationController
Inverts the values coming from the defined Attenuation Controller.
Definition: gig.h:569
gig::Region::SetDimensionType
void SetDimensionType(dimension_t oldType, dimension_t newType)
Change type of an existing dimension.
Definition: gig.cpp:3970
gig::Sample::Write
file_offset_t Write(void *pBuffer, file_offset_t SampleCount)
Write sample wave data.
Definition: gig.cpp:1329
gig::DimensionRegion::EG2Decay1
double EG2Decay1
Decay time of the filter cutoff EG (0.000 - 60.000s).
Definition: gig.h:517
gig::Instrument
Provides access to a Gigasampler/GigaStudio instrument.
Definition: gig.h:1209
gig::dimension_genpurpose6
@ dimension_genpurpose6
General Purpose Controller 6 (Button, MIDI Controller 81)
Definition: gig.h:319
gig::crossfade_t::in_start
uint8_t in_start
Start position of fade in.
Definition: gig.h:367
gig::Script::Encoding_t
Encoding_t
Definition: gig.h:1126
gig::MidiRuleAlternator::Articulations
uint8_t Articulations
Number of articulations in the instrument.
Definition: gig.h:1046
gig::Sample::SamplesInLastFrame
file_offset_t SamplesInLastFrame
For compressed samples only: length of the last sample frame.
Definition: gig.h:812
gig::Sample::CopyAssignWave
void CopyAssignWave(const Sample *orig)
Should be called after CopyAssignMeta() and File::Save() sequence.
Definition: gig.cpp:546
gig::smpte_format_t
smpte_format_t
Society of Motion Pictures and Television E time format.
Definition: gig.h:138
gig::smpte_format_24_frames
@ smpte_format_24_frames
24 frames per second
Definition: gig.h:138
gig::Sample::GetWaveDataCRC32Checksum
uint32_t GetWaveDataCRC32Checksum()
Returns the CRC-32 checksum of the sample's raw wave form data at the time when this sample's wave fo...
Definition: gig.cpp:1423
gig::lfo2_ctrl_internal
@ lfo2_ctrl_internal
Only internally controlled.
Definition: gig.h:183
gig::Script::Encoding
Encoding_t Encoding
Format the script's source code text is encoded with.
Definition: gig.h:1138
gig::DimensionRegion::LFO2ControlDepth
uint16_t LFO2ControlDepth
Controller depth influencing filter cutoff LFO pitch (0 - 1200).
Definition: gig.h:529
gig::DimensionRegion::EG3Depth
int16_t EG3Depth
Depth of the sample pitch EG (-1200 - +1200).
Definition: gig.h:535
gig::MidiRuleCtrlTrigger::Triggers
uint8_t Triggers
Number of triggers.
Definition: gig.h:974
gig::range_t
Lower and upper limit of a range.
Definition: gig.h:101
gig::Script::GetGroup
ScriptGroup * GetGroup() const
Returns the script group this script currently belongs to.
Definition: gig.cpp:4555
gig::loop_type_t
loop_type_t
Standard types of sample loops.
Definition: gig.h:126
DLS::Sampler::DeleteSampleLoop
void DeleteSampleLoop(sample_loop_t *pLoopDef)
Deletes an existing sample loop.
Definition: DLS.cpp:728
gig::DimensionRegion::EG2ControllerReleaseInfluence
uint8_t EG2ControllerReleaseInfluence
Amount EG2 Controller has influence on the EG2 Release time (0 - 3, where 0 means off).
Definition: gig.h:526
DLS::Instrument::IsDrum
bool IsDrum
Indicates if the Instrument is a drum type, as they differ in the synthesis model of DLS from melodic...
Definition: DLS.h:525
gig::Sample::Loops
uint32_t Loops
Caution: Use the respective field in the DimensionRegion instead of this one! (Intended purpose: Numb...
Definition: gig.h:770
gig::Region::pDimensionDefinitions
dimension_def_t pDimensionDefinitions[8]
Defines the five (gig2) or eight (gig3) possible dimensions (the dimension's controller and number of...
Definition: gig.h:877
gig::Sample::LoopEnd
uint32_t LoopEnd
Caution: Use the respective field in the DimensionRegion instead of this one! (Intended purpose: The ...
Definition: gig.h:774
gig::dimension_releasetrigger
@ dimension_releasetrigger
Special dimension for triggering samples on releasing a key.
Definition: gig.h:319
gig::Script::DeleteChunks
void DeleteChunks()
Remove all RIFF chunks associated with this Script object.
Definition: gig.cpp:4492
gig::Region::DeleteDimensionZone
void DeleteDimensionZone(dimension_t type, int zone)
Delete one split zone of a dimension (decrement zone amount).
Definition: gig.cpp:3705
gig::DimensionRegion::SetVelocityResponseCurveScaling
void SetVelocityResponseCurveScaling(uint8_t scaling)
Updates the respective member variable and the lookup table / cache that depends on this value.
Definition: gig.cpp:3098
DLS::version_t
Quadtuple version number ("major.minor.release.build").
Definition: DLS.h:115
gig::DimensionRegion::SelfMask
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:567
gig::smpte_format_no_offset
@ smpte_format_no_offset
no SMPTE offset
Definition: gig.h:138
DLS::Sample::Channels
uint16_t Channels
Number of channels represented in the waveform data, e.g. 1 for mono, 2 for stereo (defaults to 1=mon...
Definition: DLS.h:459
gig::DimensionRegion::EG2ControllerAttackInfluence
uint8_t EG2ControllerAttackInfluence
Amount EG2 Controller has influence on the EG2 Attack time (0 - 3, where 0 means off).
Definition: gig.h:524
gig::vcf_cutoff_ctrl_genpurpose8
@ vcf_cutoff_ctrl_genpurpose8
General Purpose Controller 8 (Button, MIDI Controller 83)
Definition: gig.h:214
gig::Region::GetSample
Sample * GetSample()
Returns pointer address to the Sample referenced with this region.
Definition: gig.cpp:4169
DLS::Sampler::Gain
int32_t Gain
Definition: DLS.h:428
gig
Gigasampler/GigaStudio specific classes and definitions.
Definition: gig.h:94
gig::ScriptGroup
Group of instrument scripts (gig format extension).
Definition: gig.h:1173
DLS::Sample
Encapsulates sample waves used for playback.
Definition: DLS.h:456
gig::Sample::MIDIUnityNote
uint32_t MIDIUnityNote
Specifies the musical note at which the sample will be played at it's original sample rate.
Definition: gig.h:766
gig::Sample::FineTune
uint32_t FineTune
Specifies the fraction of a semitone up from the specified MIDI unity note field. A value of 0x800000...
Definition: gig.h:767
gig::playback_state_t
Reflects the current playback state for a sample.
Definition: gig.h:377
gig::vcf_type_lowpass
@ vcf_type_lowpass
Standard lowpass filter type.
Definition: gig.h:351
gig::leverage_ctrl_t::type_velocity
@ type_velocity
Key Velocity.
Definition: gig.h:246
gig::DimensionRegion::AttenuationControllerThreshold
uint8_t AttenuationControllerThreshold
0-127
Definition: gig.h:570
gig::loop_type_normal
@ loop_type_normal
Loop forward (normal)
Definition: gig.h:126
gig::DimensionRegion::EG1InfiniteSustain
bool EG1InfiniteSustain
If true, instead of going into Decay2 phase, Decay1 level will be hold until note will be released.
Definition: gig.h:499
gig::buffer_t::Size
file_offset_t Size
Size of the actual data in the buffer in bytes.
Definition: gig.h:109
gig::vcf_cutoff_ctrl_modwheel
@ vcf_cutoff_ctrl_modwheel
Modulation Wheel (MIDI Controller 1)
Definition: gig.h:214
gig::DimensionRegion::LFO3InternalDepth
int16_t LFO3InternalDepth
Firm depth of the sample pitch LFO (-1200 - +1200 cents).
Definition: gig.h:537
gig::Script::Bypass
bool Bypass
Global bypass: if enabled, this script shall not be executed by the sampler for any instrument.
Definition: gig.h:1140
gig::MidiRuleAlternator::PlayRange
range_t PlayRange
Key range of the playable keys in the instrument.
Definition: gig.h:1049
gig::dimension_genpurpose3
@ dimension_genpurpose3
General Purpose Controller 3 (Slider, MIDI Controller 18)
Definition: gig.h:319
gig::DimensionRegion::EG2Controller
eg2_ctrl_t EG2Controller
MIDI Controller which has influence on filter cutoff EG parameters (attack, decay,...
Definition: gig.h:522
gig::curve_type_t
curve_type_t
Defines the shape of a function graph.
Definition: gig.h:149
gig::DimensionRegion::LFO3Frequency
double LFO3Frequency
Frequency of the sample pitch LFO (0.10 - 10.00 Hz).
Definition: gig.h:536
gig::DimensionRegion::LFO3Sync
bool LFO3Sync
If set to true only one LFO should be used for all voices.
Definition: gig.h:540
gig::DimensionRegion::PitchTrack
bool PitchTrack
If true: sample will be pitched according to the key position (this will be disabled for drums for ex...
Definition: gig.h:564
gig::DimensionRegion::LFO1InternalDepth
uint16_t LFO1InternalDepth
Firm pitch of the sample amplitude LFO (0 - 1200 cents).
Definition: gig.h:509
gig::DimensionRegion::EG2Release
double EG2Release
Release time of the filter cutoff EG (0.000 - 60.000s).
Definition: gig.h:521
gig::lfo3_ctrl_internal
@ lfo3_ctrl_internal
Only internally controlled.
Definition: gig.h:171
gig::Instrument::PitchbendRange
uint16_t PitchbendRange
Number of semitones pitchbend controller can pitch (default is 2).
Definition: gig.h:1225
RIFF::List
RIFF List Chunk.
Definition: RIFF.h:308
gig::DimensionRegion::VCFKeyboardTrackingBreakpoint
uint8_t VCFKeyboardTrackingBreakpoint
See VCFKeyboardTracking (0 - 127).
Definition: gig.h:554
gig::lfo3_ctrl_modwheel
@ lfo3_ctrl_modwheel
Only controlled by external modulation wheel.
Definition: gig.h:171
gig::split_type_bit
@ split_type_bit
dimension values are already the sought bit number
Definition: gig.h:330
gig::DimensionRegion::EG1Sustain
uint16_t EG1Sustain
Sustain value of the sample amplitude EG (0 - 1000 permille).
Definition: gig.h:500
gig::File
Provides convenient access to Gigasampler/GigaStudio .gig files.
Definition: gig.h:1347
gig::Sample::FrameTable
file_offset_t * FrameTable
For positioning within compressed samples only: stores the offset values for each frame.
Definition: gig.h:810
gig::Script::Language_t
Language_t
Definition: gig.h:1132
DLS::Sampler
Abstract base class which provides mandatory informations about sample players in general.
Definition: DLS.h:424
gig::DimensionRegion::EG2PreAttack
uint16_t EG2PreAttack
Preattack value of the filter cutoff EG (0 - 1000 permille).
Definition: gig.h:515
DLS::Instrument::MIDIBank
uint16_t MIDIBank
Reflects combination of MIDIBankCoarse and MIDIBankFine (bank 1 - bank 16384). Do not change this val...
Definition: DLS.h:526
gig::dimension_def_t::bits
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
gig::DimensionRegion::EG2InfiniteSustain
bool EG2InfiniteSustain
If true, instead of going into Decay2 phase, Decay1 level will be hold until note will be released.
Definition: gig.h:519
gig::lfo3_ctrl_t
lfo3_ctrl_t
Defines how LFO3 is controlled by.
Definition: gig.h:171
gig::dimension_breath
@ dimension_breath
Breath Controller (Coarse, MIDI Controller 2)
Definition: gig.h:319
gig::vcf_cutoff_ctrl_effect2
@ vcf_cutoff_ctrl_effect2
Effect Controller 2 (Coarse, MIDI Controller 13)
Definition: gig.h:214
gig::Exception
Will be thrown whenever a gig specific error occurs while trying to access a Gigasampler File.
Definition: gig.h:1435
gig::Script::GetScriptAsText
String GetScriptAsText()
Returns the current script (i.e.
Definition: gig.cpp:4465
gig::Sample::SetPos
file_offset_t SetPos(file_offset_t SampleCount, RIFF::stream_whence_t Whence=RIFF::stream_start)
Sets the position within the sample (in sample points, not in bytes).
Definition: gig.cpp:892
RIFF::progress_t
Used for indicating the progress of a certain task.
Definition: RIFF.h:216
gig::vcf_res_ctrl_none
@ vcf_res_ctrl_none
No MIDI controller assigned for filter resonance.
Definition: gig.h:226
gig::DimensionRegion::EG1ControllerInvert
bool EG1ControllerInvert
Invert values coming from defined EG1 controller.
Definition: gig.h:504
gig::dimension_roundrobinkeyboard
@ dimension_roundrobinkeyboard
Different samples triggered each time a note is played, any key advances the counter.
Definition: gig.h:319
gig::MidiRuleLegato::AltSustain2Key
uint8_t AltSustain2Key
Key triggering a second set of alternate sustain samples.
Definition: gig.h:1023
gig::DimensionRegion::EG2Attack
double EG2Attack
Attack time of the filter cutoff EG (0.000 - 60.000s).
Definition: gig.h:516
gig::DimensionRegion::LFO1Frequency
double LFO1Frequency
Frequency of the sample amplitude LFO (0.10 - 10.00 Hz).
Definition: gig.h:508
gig::dimension_def_t
General dimension definition.
Definition: gig.h:333
gig::dimension_def_t::split_type
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
gig::leverage_ctrl_t::type
type_t type
Controller type.
Definition: gig.h:248
gig::DimensionRegion::SustainReleaseTrigger
sust_rel_trg_t SustainReleaseTrigger
[gig extension]: Whether a sustain pedal up event shall play release trigger sample.
Definition: gig.h:579
gig::dimension_effect1depth
@ dimension_effect1depth
Effect 1 Depth (MIDI Controller 91)
Definition: gig.h:319
gig::DimensionRegion::UpdateChunks
virtual void UpdateChunks(progress_t *pProgress)
Apply dimension region settings to the respective RIFF chunks.
Definition: gig.cpp:1984
gig::lfo1_ctrl_t
lfo1_ctrl_t
Defines how LFO1 is controlled by.
Definition: gig.h:195
gig::DimensionRegion::SustainDefeat
bool SustainDefeat
If true: Sustain pedal will not hold a note.
Definition: gig.h:572
gig::playback_state_t::loop_cycles_left
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
gig::Sample::LoopType
loop_type_t LoopType
Caution: Use the respective field in the DimensionRegion instead of this one! (Intended purpose: The ...
Definition: gig.h:772
gig::MidiRuleLegato::KeyRange
range_t KeyRange
Key range for legato notes.
Definition: gig.h:1020
gig::Script::Compression_t
Compression_t
Definition: gig.h:1129
gig::Region::SetKeyRange
virtual void SetKeyRange(uint16_t Low, uint16_t High)
Modifies the key range of this Region and makes sure the respective chunks are in correct order.
Definition: gig.cpp:3409
gig::DimensionRegion::EG2ControllerDecayInfluence
uint8_t EG2ControllerDecayInfluence
Amount EG2 Controller has influence on the EG2 Decay time (0 - 3, where 0 means off).
Definition: gig.h:525
gig::Sample
Encapsulates sample waves of Gigasampler/GigaStudio files used for playback.
Definition: gig.h:761
gig::dimension_effect2depth
@ dimension_effect2depth
Effect 2 Depth (MIDI Controller 92)
Definition: gig.h:319
gig::vcf_cutoff_ctrl_effect1
@ vcf_cutoff_ctrl_effect1
Effect Controller 1 (Coarse, MIDI Controller 12)
Definition: gig.h:214
gig::Sample::LoopPlayCount
uint32_t LoopPlayCount
Number of times the loop should be played (a value of 0 = infinite).
Definition: gig.h:777
gig::DimensionRegion::LFO2Sync
bool LFO2Sync
If set to true only one LFO should be used for all voices.
Definition: gig.h:532
gig::DimensionRegion::VCFCutoff
uint8_t VCFCutoff
Max. cutoff frequency.
Definition: gig.h:546
gig::MidiRuleLegato::BypassController
uint8_t BypassController
Controller to be used to bypass the sustain note.
Definition: gig.h:1017
gig::DimensionRegion::SetVelocityResponseDepth
void SetVelocityResponseDepth(uint8_t depth)
Updates the respective member variable and the lookup table / cache that depends on this value.
Definition: gig.cpp:3086
gig::Sample::WorstCaseFrameSize
file_offset_t WorstCaseFrameSize
For compressed samples only: size (in bytes) of the largest possible sample frame.
Definition: gig.h:813
gig::lfo1_ctrl_modwheel
@ lfo1_ctrl_modwheel
Only controlled by external modulation wheel.
Definition: gig.h:195
gig::curve_type_nonlinear
@ curve_type_nonlinear
Non-linear curve type.
Definition: gig.h:149
gig::Region::Layers
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:880
gig::Sample::Resize
void Resize(file_offset_t NewSize)
Resize sample.
Definition: gig.cpp:866
gig::enumCount
size_t enumCount(String typeName)
Amount of elements in given enum type.
Definition: typeinfo.cpp:190
gig::DimensionRegion::Pan
int8_t Pan
Panorama / Balance (-64..0..63 <-> left..middle..right)
Definition: gig.h:566
gig::File::VERSION_2
static const DLS::version_t VERSION_2
Reflects Gigasampler file format version 2.0 (1998-06-28).
Definition: gig.h:1349
gig::Group::Name
String Name
Stores the name of this Group.
Definition: gig.h:1294
gig::crossfade_t::out_end
uint8_t out_end
End postition of fade out.
Definition: gig.h:370
gig::MidiRuleCtrlTrigger
MIDI rule for triggering notes by control change events.
Definition: gig.h:971
DLS::File::GetRiffFile
RIFF::File * GetRiffFile()
Returns the underlying RIFF::File used for persistency of this DLS::File object.
Definition: DLS.cpp:1808
gig::DimensionRegion::SetGain
virtual void SetGain(int32_t gain)
Updates the respective member variable and updates SampleAttenuation which depends on this value.
Definition: gig.cpp:1970
gig::lfo3_ctrl_aftertouch
@ lfo3_ctrl_aftertouch
Only controlled by aftertouch controller.
Definition: gig.h:171
gig::Sample::ReadAndLoop
file_offset_t ReadAndLoop(void *pBuffer, file_offset_t SampleCount, playback_state_t *pPlaybackState, DimensionRegion *pDimRgn, buffer_t *pExternalDecompressionBuffer=NULL)
Reads SampleCount number of sample points from the position stored in pPlaybackState into the buffer ...
Definition: gig.cpp:965
gig::Script::SetScriptAsText
void SetScriptAsText(const String &text)
Replaces the current script with the new script source code text given by text.
Definition: gig.cpp:4478
gig::DimensionRegion::VCFVelocityCurve
curve_type_t VCFVelocityCurve
Defines a transformation curve for the incoming velocity values, affecting the VCF.
Definition: gig.h:547
gig::vcf_cutoff_ctrl_aftertouch
@ vcf_cutoff_ctrl_aftertouch
Key Pressure.
Definition: gig.h:214
DLS::Sample::BitDepth
uint16_t BitDepth
Size of each sample per channel (only if known sample data format is used, 0 otherwise).
Definition: DLS.h:463
gig::DimensionRegion::VelocityTable
uint8_t * VelocityTable
For velocity dimensions with custom defined zone ranges only: used for fast converting from velocity ...
Definition: gig.h:611
gig::Region::SplitDimensionZone
void SplitDimensionZone(dimension_t type, int zone)
Divide split zone of a dimension in two (increment zone amount).
Definition: gig.cpp:3830
gig::dimension_velocity
@ dimension_velocity
Key Velocity (this is the only dimension in gig2 where the ranges can exactly be defined).
Definition: gig.h:319
gig::MidiRuleAlternator::Controller
uint8_t Controller
CC number for controller selector.
Definition: gig.h:1072
gig::DimensionRegion::EG1ControllerReleaseInfluence
uint8_t EG1ControllerReleaseInfluence
Amount EG1 Controller has influence on the EG1 Release time (0 - 3, where 0 means off).
Definition: gig.h:507
gig::DimensionRegion::VCFCutoffControllerInvert
bool VCFCutoffControllerInvert
Inverts values coming from the defined cutoff controller.
Definition: gig.h:545
gig::eg_opt_t::ReleaseCancel
bool ReleaseCancel
Whether the "release" stage is cancelled when receiving a note-on (default: true).
Definition: gig.h:411
gig::DimensionRegion::EG2Sustain
uint16_t EG2Sustain
Sustain value of the filter cutoff EG (0 - 1000 permille).
Definition: gig.h:520
gig::ScriptGroup::Name
String Name
Name of this script group. For example to be displayed in an instrument editor.
Definition: gig.h:1175
gig::Script::SetGroup
void SetGroup(ScriptGroup *pGroup)
Move this script from its current ScriptGroup to another ScriptGroup given by pGroup.
Definition: gig.cpp:4542
gig::Region::CopyAssign
virtual void CopyAssign(const Region *orig)
Make a (semi) deep copy of the Region object given by orig and assign it to this object.
Definition: gig.cpp:4214
gig::dim_bypass_ctrl_95
@ dim_bypass_ctrl_95
Effect 5 Depth (MIDI Controller 95)
Definition: gig.h:159
gig::MidiRuleLegato::AltSustain1Key
uint8_t AltSustain1Key
Key triggering alternate sustain samples.
Definition: gig.h:1022
gig::DimensionRegion::SetVCFVelocityDynamicRange
void SetVCFVelocityDynamicRange(uint8_t range)
Updates the respective member variable and the lookup table / cache that depends on this value.
Definition: gig.cpp:3146
gig::DimensionRegion::ReleaseVelocityResponseCurve
curve_type_t ReleaseVelocityResponseCurve
Defines a transformation curve to the incoming release veloctiy values affecting envelope times.
Definition: gig.h:559
gig::DimensionRegion::CopyAssign
virtual void CopyAssign(const DimensionRegion *orig)
Make a (semi) deep copy of the DimensionRegion object given by orig and assign it to this object.
Definition: gig.cpp:1819
gig::DimensionRegion::VelocityResponseDepth
uint8_t VelocityResponseDepth
Dynamic range of velocity affecting amplitude (0 - 4) (usually you don't have to interpret this param...
Definition: gig.h:557
DLS::File::Save
virtual void Save(const String &Path, progress_t *pProgress=NULL)
Save changes to another file.
Definition: DLS.cpp:2103
gig::Region::AddDimension
void AddDimension(dimension_def_t *pDimDef)
Einstein would have dreamed of it - create a new dimension.
Definition: gig.cpp:3503
gig::split_type_t
split_type_t
Intended for internal usage: will be used to convert a dimension value into the corresponding dimensi...
Definition: gig.h:330
gig::Sample::VerifyWaveData
bool VerifyWaveData(uint32_t *pActually=NULL)
Checks the integrity of this sample's raw audio wave data.
Definition: gig.cpp:1452
gig::smpte_format_25_frames
@ smpte_format_25_frames
25 frames per second
Definition: gig.h:138
gig::DimensionRegion::VCFResonanceController
vcf_res_ctrl_t VCFResonanceController
Specifies which external controller has influence on the filter resonance Q.
Definition: gig.h:552
gig::dimension_portamento
@ dimension_portamento
Portamento (MIDI Controller 65)
Definition: gig.h:319
gig::Script::COMPRESSION_NONE
@ COMPRESSION_NONE
Is not compressed at all (default).
Definition: gig.h:1130
gig::DimensionRegion::EG1Controller
eg1_ctrl_t EG1Controller
MIDI Controller which has influence on sample amplitude EG parameters (attack, decay,...
Definition: gig.h:503
gig::Sample::FileNo
unsigned long FileNo
File number (> 0 when sample is stored in an extension file, 0 when it's in the gig)
Definition: gig.h:816
gig::DimensionRegion::NoNoteOffReleaseTrigger
bool NoNoteOffReleaseTrigger
[gig extension]: If true then don't play a release trigger sample on MIDI note-off events.
Definition: gig.h:580
gig::DimensionRegion::SetReleaseVelocityResponseCurve
void SetReleaseVelocityResponseCurve(curve_type_t curve)
Updates the respective member variable and the lookup table / cache that depends on this value.
Definition: gig.cpp:3110
gig::range_t::low
uint8_t low
Low value of range.
Definition: gig.h:102
gig::MidiRuleLegato::LegatoSamples
uint8_t LegatoSamples
Number of legato samples per key in each direction (always 12)
Definition: gig.h:1014
gig::DimensionRegion::SetReleaseVelocityResponseDepth
void SetReleaseVelocityResponseDepth(uint8_t depth)
Updates the respective member variable and the lookup table / cache that depends on this value.
Definition: gig.cpp:3119
gig::Instrument::FineTune
int16_t FineTune
in cents
Definition: gig.h:1224
gig::vcf_res_ctrl_genpurpose5
@ vcf_res_ctrl_genpurpose5
General Purpose Controller 5 (Button, MIDI Controller 80)
Definition: gig.h:226
gig::Sample::SamplePeriod
uint32_t SamplePeriod
Specifies the duration of time that passes during the playback of one sample in nanoseconds (normally...
Definition: gig.h:765
gig::Sample::GetGroup
Group * GetGroup() const
Returns pointer to the Group this Sample belongs to.
Definition: gig.cpp:1407
gig::MidiRuleLegato::BypassUseController
bool BypassUseController
If a controller should be used to bypass the sustain note.
Definition: gig.h:1015
gig::Script::CopyAssign
void CopyAssign(const Script *orig)
Make a (semi) deep copy of the Script object given by orig and assign it to this object.
Definition: gig.cpp:4566
gig::DimensionRegion::VCFEnabled
bool VCFEnabled
If filter should be used.
Definition: gig.h:542
gig::DimensionRegion::EG2Decay2
double EG2Decay2
Only if EG2InfiniteSustain == false: 2nd stage decay time of the filter cutoff EG (0....
Definition: gig.h:518
gig::eg_opt_t::Decay2Cancel
bool Decay2Cancel
Whether the "decay 2" stage is cancelled when receiving a note-off (default: true).
Definition: gig.h:410
DLS::Instrument::MIDIBankCoarse
uint8_t MIDIBankCoarse
Reflects the MIDI Bank number for MIDI Control Change 0 (bank 1 - 128).
Definition: DLS.h:527
gig::DimensionRegion::SetVelocityResponseCurve
void SetVelocityResponseCurve(curve_type_t curve)
Updates the respective member variable and the lookup table / cache that depends on this value.
Definition: gig.cpp:3074
gig::sust_rel_trg_maxvelocity
@ sust_rel_trg_maxvelocity
Play release trigger sample(s) on sustain pedal up, and simply use 127 as MIDI velocity for playback.
Definition: gig.h:437
gig::enumKeys
const char ** enumKeys(String typeName)
All element names of enum type.
Definition: typeinfo.cpp:323
gig::MidiRuleCtrlTrigger::ControllerNumber
uint8_t ControllerNumber
MIDI controller number.
Definition: gig.h:973
gig::Sample::SMPTEFormat
smpte_format_t SMPTEFormat
Specifies the Society of Motion Pictures and Television E time format used in the following SMPTEOffs...
Definition: gig.h:768
RIFF::Chunk
Ordinary RIFF Chunk.
Definition: RIFF.h:232
gig::DimensionRegion::EG1Release
double EG1Release
Release time of the sample amplitude EG (0.000 - 60.000s).
Definition: gig.h:501
gig::MidiRuleUnknown
A MIDI rule not yet implemented by libgig.
Definition: gig.h:1097
gig::leverage_ctrl_t::type_channelaftertouch
@ type_channelaftertouch
Channel Key Pressure.
Definition: gig.h:246
gig::DimensionRegion::VelocityResponseCurve
curve_type_t VelocityResponseCurve
Defines a transformation curve to the incoming velocity values affecting amplitude (usually you don't...
Definition: gig.h:556
gig::DimensionRegion::LFO2Frequency
double LFO2Frequency
Frequency of the filter cutoff LFO (0.10 - 10.00 Hz).
Definition: gig.h:527
Serialization::Archive
Destination container for serialization, and source container for deserialization.
Definition: Serialization.h:709
gig::vcf_cutoff_ctrl_breath
@ vcf_cutoff_ctrl_breath
Breath Controller (Coarse, MIDI Controller 2)
Definition: gig.h:214
gig::Region::GetDimensionDefinition
dimension_def_t * GetDimensionDefinition(dimension_t type)
Searches in the current Region for a dimension of the given dimension type and returns the precise co...
Definition: gig.cpp:4010
gig::dimension_softpedal
@ dimension_softpedal
Soft Pedal (MIDI Controller 67)
Definition: gig.h:319
gig::lfo1_ctrl_internal_breath
@ lfo1_ctrl_internal_breath
Controlled internally and by external breath controller.
Definition: gig.h:195
gig::Script::UpdateChunks
void UpdateChunks(progress_t *pProgress)
Apply this script to the respective RIFF chunks.
Definition: gig.cpp:4504
gig::DimensionRegion::VCFType
vcf_type_t VCFType
Defines the general filter characteristic (lowpass, highpass, bandpass, etc.).
Definition: gig.h:543
gig::DimensionRegion::VCFVelocityScale
uint8_t VCFVelocityScale
(0-127) Amount velocity controls VCF cutoff frequency (only if no other VCF cutoff controller is defi...
Definition: gig.h:548
gig::DimensionRegion::DimensionUpperLimits
uint8_t DimensionUpperLimits[8]
gig3: defines the upper limit of the dimension values for this dimension region. In case you wondered...
Definition: gig.h:576
gig::dimension_effect1
@ dimension_effect1
Effect Controller 1 (Coarse, MIDI Controller 12)
Definition: gig.h:319
gig::DimensionRegion::EG1Options
eg_opt_t EG1Options
[gig extension]: Behavior options which should be used for envelope generator 1 (volume amplitude EG)...
Definition: gig.h:577
DLS::Resource::pInfo
Info * pInfo
Points (in any case) to an Info object, providing additional, optional infos and comments.
Definition: DLS.h:405
gig::Sample::LoadSampleDataWithNullSamplesExtension
buffer_t LoadSampleDataWithNullSamplesExtension(uint NullSamplesCount)
Loads (and uncompresses if needed) the whole sample wave into RAM.
Definition: gig.cpp:755
gig::dimension_effect4depth
@ dimension_effect4depth
Effect 4 Depth (MIDI Controller 94)
Definition: gig.h:319
gig::File::VERSION_4
static const DLS::version_t VERSION_4
Reflects Gigasampler file format version 4.0 (2007-10-12).
Definition: gig.h:1351
gig::smpte_format_30_frames
@ smpte_format_30_frames
30 frames per second
Definition: gig.h:138
gig::Script
Real-time instrument script (gig format extension).
Definition: gig.h:1124
gig::vcf_type_lowpassturbo
@ vcf_type_lowpassturbo
More poles than normal lowpass.
Definition: gig.h:351
gig::DimensionRegion::EG1ControllerDecayInfluence
uint8_t EG1ControllerDecayInfluence
Amount EG1 Controller has influence on the EG1 Decay time (0 - 3, where 0 means off).
Definition: gig.h:506
gig::Region::GetDimensionRegionByBit
DimensionRegion * GetDimensionRegionByBit(const uint8_t DimBits[8])
Returns the appropriate DimensionRegion for the given dimension bit numbers (zone index).
Definition: gig.cpp:4150
RIFF::stream_whence_t
stream_whence_t
File stream position dependent to these relations.
Definition: RIFF.h:177
gig::dimension_modwheel
@ dimension_modwheel
Modulation Wheel (MIDI Controller 1)
Definition: gig.h:319
gig::dimension_genpurpose8
@ dimension_genpurpose8
General Purpose Controller 8 (Button, MIDI Controller 83)
Definition: gig.h:319
gig::Sample::CreateDecompressionBuffer
static buffer_t CreateDecompressionBuffer(file_offset_t MaxReadSize)
Allocates a decompression buffer for streaming (compressed) samples with Sample::Read().
Definition: gig.cpp:1373
gig::Sample::LoopID
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:771
gig::DimensionRegion::GetVelocityAttenuation
double GetVelocityAttenuation(uint8_t MIDIKeyVelocity)
Returns the correct amplitude factor for the given MIDIKeyVelocity.
Definition: gig.cpp:3058
gig::vcf_type_t
vcf_type_t
Defines which frequencies are filtered by the VCF.
Definition: gig.h:351
gig::Script::LANGUAGE_NKSP
@ LANGUAGE_NKSP
NKSP stands for "Is Not KSP" (default). Refer to the NKSP Reference Manual for details about this scr...
Definition: gig.h:1133
gig::lfo1_ctrl_breath
@ lfo1_ctrl_breath
Only controlled by external breath controller.
Definition: gig.h:195
gig::crossfade_t::in_end
uint8_t in_end
End position of fade in.
Definition: gig.h:368
gig::dimension_genpurpose5
@ dimension_genpurpose5
General Purpose Controller 5 (Button, MIDI Controller 80)
Definition: gig.h:319
gig::vcf_res_ctrl_genpurpose6
@ vcf_res_ctrl_genpurpose6
General Purpose Controller 6 (Button, MIDI Controller 81)
Definition: gig.h:226
gig::crossfade_t::out_start
uint8_t out_start
Start position of fade out.
Definition: gig.h:369
gig::vcf_cutoff_ctrl_genpurpose7
@ vcf_cutoff_ctrl_genpurpose7
General Purpose Controller 7 (Button, MIDI Controller 82)
Definition: gig.h:214
gig::DimensionRegion::EG1PreAttack
uint16_t EG1PreAttack
Preattack value of the sample amplitude EG (0 - 1000 permille).
Definition: gig.h:495
gig::MidiRuleLegato::ThresholdTime
uint16_t ThresholdTime
Maximum time (ms) between two notes that should be played legato.
Definition: gig.h:1018
gig::buffer_t::pStart
void * pStart
Points to the beginning of the buffer.
Definition: gig.h:108
gig::Region::pDimensionRegions
DimensionRegion * pDimensionRegions[256]
Pointer array to the 32 (gig2) or 256 (gig3) possible dimension regions (reflects NULL for dimension ...
Definition: gig.h:879
gig::vcf_cutoff_ctrl_foot
@ vcf_cutoff_ctrl_foot
Foot Pedal (Coarse, MIDI Controller 4)
Definition: gig.h:214
gig::dimension_smartmidi
@ dimension_smartmidi
For MIDI tools like legato and repetition mode.
Definition: gig.h:319
gig::DimensionRegion::VCFKeyboardTracking
bool VCFKeyboardTracking
If true: VCF cutoff frequence will be dependend to the note key position relative to the defined brea...
Definition: gig.h:553
gig::MidiRuleAlternator::pPatterns
struct gig::MidiRuleAlternator::pattern_t pPatterns[32]
A pattern is a sequence of articulation numbers.
gig::playback_state_t::position
file_offset_t position
Current position within the sample.
Definition: gig.h:378
gig::leverage_ctrl_t::type_none
@ type_none
No controller defined.
Definition: gig.h:246
gig::DimensionRegion::LFO1Controller
lfo1_ctrl_t LFO1Controller
MIDI Controller which controls sample amplitude LFO.
Definition: gig.h:511
DLS::File::SetFileName
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...
Definition: DLS.cpp:1849
gig::Sample::SamplesPerFrame
file_offset_t SamplesPerFrame
For compressed samples only: number of samples in a full sample frame.
Definition: gig.h:814
gig::dimension_def_t::zones
uint8_t zones
Number of zones the dimension has.
Definition: gig.h:336
gig::lfo2_ctrl_modwheel
@ lfo2_ctrl_modwheel
Only controlled by external modulation wheel.
Definition: gig.h:183
gig::Sample::TruncatedBits
uint32_t TruncatedBits
For 24-bit compressed samples only: number of bits truncated during compression (0,...
Definition: gig.h:779
gig::vcf_cutoff_ctrl_none2
@ vcf_cutoff_ctrl_none2
The difference between none and none2 is unknown.
Definition: gig.h:214
gig::Sample::GetCache
buffer_t GetCache()
Returns current cached sample points.
Definition: gig.cpp:814
gig::sust_rel_trg_none
@ sust_rel_trg_none
No release triggered sample(s) are played on sustain pedal up (default).
Definition: gig.h:437
gig::Instrument::Attenuation
int32_t Attenuation
in dB
Definition: gig.h:1222
gig::vcf_type_bandpass
@ vcf_type_bandpass
Bandpass filter type.
Definition: gig.h:351
gig::DimensionRegion::EG1Attack
double EG1Attack
Attack time of the sample amplitude EG (0.000 - 60.000s).
Definition: gig.h:496
gig::Sample::crc
uint32_t crc
Reflects CRC-32 checksum of the raw sample data at the last time when the sample's raw wave form data...
Definition: gig.h:819
gig::Script::Compression
Compression_t Compression
Whether the script was/should be compressed, and if so, which compression algorithm shall be used.
Definition: gig.h:1137
gig::DimensionRegion::VelocityResponseCurveScaling
uint8_t VelocityResponseCurveScaling
0 - 127 (usually you don't have to interpret this parameter, use GetVelocityAttenuation() instead).
Definition: gig.h:558
gig::DimensionRegion::VCFVelocityDynamicRange
uint8_t VCFVelocityDynamicRange
0x04 = lowest, 0x00 = highest .
Definition: gig.h:549
gig::lfo2_ctrl_foot
@ lfo2_ctrl_foot
Only controlled by external foot controller.
Definition: gig.h:183
gig::eg1_ctrl_t
leverage_ctrl_t eg1_ctrl_t
Defines controller influencing envelope generator 1.
Definition: gig.h:266
gig::dimension_genpurpose4
@ dimension_genpurpose4
General Purpose Controller 4 (Slider, MIDI Controller 19)
Definition: gig.h:319
RIFF::File
RIFF File.
Definition: RIFF.h:358
gig::buffer_t
Pointer address and size of a buffer.
Definition: gig.h:107
gig::DimensionRegion::VCFResonance
uint8_t VCFResonance
Firm internal filter resonance weight.
Definition: gig.h:550
gig::DimensionRegion::LFO2FlipPhase
bool LFO2FlipPhase
Inverts phase of the filter cutoff LFO wave.
Definition: gig.h:531
gig::loop_type_bidirectional
@ loop_type_bidirectional
Alternating loop (forward/backward, also known as Ping Pong)
Definition: gig.h:126
gig::Sample::Product
uint32_t Product
Specifies the MIDI model ID defined by the manufacturer corresponding to the Manufacturer field....
Definition: gig.h:764
gig::Sample::RAMCache
buffer_t RAMCache
Buffers samples (already uncompressed) in RAM.
Definition: gig.h:815
gig::DimensionRegion::DimensionBypass
dim_bypass_ctrl_t DimensionBypass
If defined, the MIDI controller can switch on/off the dimension in realtime.
Definition: gig.h:565
gig::Sample::InternalDecompressionBuffer
static buffer_t InternalDecompressionBuffer
Buffer used for decompression as well as for truncation of 24 Bit -> 16 Bit samples.
Definition: gig.h:807
gig::DimensionRegion::EG1Decay1
double EG1Decay1
Decay time of the sample amplitude EG (0.000 - 60.000s).
Definition: gig.h:497
gig::dimension_random
@ dimension_random
Different samples triggered each time a note is played, random order.
Definition: gig.h:319
gig::smpte_format_30_frames_dropping
@ smpte_format_30_frames_dropping
30 frames per second with frame dropping (30 drop)
Definition: gig.h:138
gig::range_t::high
uint8_t high
High value of range.
Definition: gig.h:103
gig::Sample::DestroyDecompressionBuffer
static void DestroyDecompressionBuffer(buffer_t &DecompressionBuffer)
Free decompression buffer, previously created with CreateDecompressionBuffer().
Definition: gig.cpp:1390
DLS
DLS specific classes and definitions.
Definition: DLS.h:108
gig::Region::~Region
~Region()
Destructor.
Definition: gig.cpp:4017
gig::dimension_foot
@ dimension_foot
Foot Pedal (Coarse, MIDI Controller 4)
Definition: gig.h:319
gig::curve_type_linear
@ curve_type_linear
Linear curve type.
Definition: gig.h:149
gig::enumValue
size_t enumValue(String key)
Numeric value of enum constant.
Definition: typeinfo.cpp:219
gig::DimensionRegion::SampleStartOffset
uint16_t SampleStartOffset
Number of samples the sample start should be moved (0 - 2000).
Definition: gig.h:574
gig::DimensionRegion::SetVCFVelocityScale
void SetVCFVelocityScale(uint8_t scaling)
Updates the respective member variable and the lookup table / cache that depends on this value.
Definition: gig.cpp:3155
gig::DimensionRegion::ReleaseVelocityResponseDepth
uint8_t ReleaseVelocityResponseDepth
Dynamic range of release velocity affecting envelope time (0 - 4).
Definition: gig.h:560
Serialization
Serialization / deserialization framework.
Definition: gig.h:91
gig::MidiRuleLegato::ReleaseTime
uint16_t ReleaseTime
Release time.
Definition: gig.h:1019
DLS::Resource::pDLSID
dlsid_t * pDLSID
Points to a dlsid_t structure if the file provided a DLS ID else is NULL.
Definition: DLS.h:406
gig::MidiRuleAlternator::Chained
bool Chained
If all patterns should be chained together.
Definition: gig.h:1075
gig::DimensionRegion::VelocityUpperLimit
uint8_t VelocityUpperLimit
Defines the upper velocity value limit of a velocity split (only if an user defined limit was set,...
Definition: gig.h:492
gig::vcf_cutoff_ctrl_t
vcf_cutoff_ctrl_t
Defines how the filter cutoff frequency is controlled by.
Definition: gig.h:214
gig::DimensionRegion::ReleaseTriggerDecay
uint8_t ReleaseTriggerDecay
0 - 8
Definition: gig.h:561
gig::Sample::Compressed
bool Compressed
If the sample wave is compressed (probably just interesting for instrument and sample editors,...
Definition: gig.h:778
gig::dimension_roundrobin
@ dimension_roundrobin
Different samples triggered each time a note is played, dimension regions selected in sequence.
Definition: gig.h:319
gig::vcf_res_ctrl_genpurpose3
@ vcf_res_ctrl_genpurpose3
General Purpose Controller 3 (Slider, MIDI Controller 18)
Definition: gig.h:226
gig::dimension_genpurpose7
@ dimension_genpurpose7
General Purpose Controller 7 (Button, MIDI Controller 82)
Definition: gig.h:319
DLS::Instrument::MIDIProgram
uint32_t MIDIProgram
Specifies the MIDI Program Change Number this Instrument should be assigned to.
Definition: DLS.h:529
DLS::Sampler::SampleLoops
uint32_t SampleLoops
Reflects the number of sample loops.
Definition: DLS.h:431
gig::DimensionRegion::LFO1ControlDepth
uint16_t LFO1ControlDepth
Controller depth influencing sample amplitude LFO pitch (0 - 1200 cents).
Definition: gig.h:510
gig::loop_type_backward
@ loop_type_backward
Loop backward (reverse)
Definition: gig.h:126
gig::vcf_cutoff_ctrl_softpedal
@ vcf_cutoff_ctrl_softpedal
Soft Pedal (MIDI Controller 67)
Definition: gig.h:214
gig::eg_opt_t::AttackCancel
bool AttackCancel
Whether the "attack" stage is cancelled when receiving a note-off (default: true).
Definition: gig.h:407
gig::MidiRuleLegato
MIDI rule for instruments with legato samples.
Definition: gig.h:1012
gig::Region
Defines Region information of a Gigasampler/GigaStudio instrument.
Definition: gig.h:874
gig::DimensionRegion::EG1Hold
bool EG1Hold
If true, Decay1 stage should be postponed until the sample reached the sample loop start.
Definition: gig.h:502
gig::dimension_keyboard
@ dimension_keyboard
Dimension for keyswitching.
Definition: gig.h:319
gig::Region::GetDimensionRegionByValue
DimensionRegion * GetDimensionRegionByValue(const uint DimValues[8])
Use this method in your audio engine to get the appropriate dimension region with it's articulation d...
Definition: gig.cpp:4041
gig::DimensionRegion::VCFResonanceDynamic
bool VCFResonanceDynamic
If true: Increases the resonance Q according to changes of controllers that actually control the VCF ...
Definition: gig.h:551
gig::lfo1_ctrl_internal
@ lfo1_ctrl_internal
Only internally controlled.
Definition: gig.h:195
gig::buffer_t::NullExtensionSize
file_offset_t NullExtensionSize
The buffer might be bigger than the actual data, if that's the case that unused space at the end of t...
Definition: gig.h:110
gig::DimensionRegion::SampleAttenuation
double SampleAttenuation
Sample volume (calculated from DLS::Sampler::Gain)
Definition: gig.h:575
gig::dimension_def_t::zone_size
float zone_size
Intended for internal usage: reflects the size of each zone (128/zones) for normal split types only,...
Definition: gig.h:338
gig::File::VERSION_3
static const DLS::version_t VERSION_3
Reflects Gigasampler file format version 3.0 (2003-03-31).
Definition: gig.h:1350
gig::sust_rel_trg_t
sust_rel_trg_t
Defines behaviour of release triggered sample(s) on sustain pedal up event.
Definition: gig.h:437
gig::dimension_channelaftertouch
@ dimension_channelaftertouch
Channel Key Pressure.
Definition: gig.h:319
gig::leverage_ctrl_t::controller_number
uint controller_number
MIDI controller number if this controller is a control change controller, 0 otherwise.
Definition: gig.h:249
gig::Sample::SMPTEOffset
uint32_t SMPTEOffset
The SMPTE Offset value specifies the time offset to be used for the synchronization / calibration to ...
Definition: gig.h:769
gig::split_type_normal
@ split_type_normal
dimension value between 0-127
Definition: gig.h:330
gig::curve_type_special
@ curve_type_special
Special curve type.
Definition: gig.h:149
gig::vcf_cutoff_ctrl_sustainpedal
@ vcf_cutoff_ctrl_sustainpedal
Sustain Pedal (MIDI Controller 64)
Definition: gig.h:214
gig::Sample::pGroup
Group * pGroup
pointer to the Group this sample belongs to (always not-NULL)
Definition: gig.h:808
gig::DimensionRegion::LFO2Controller
lfo2_ctrl_t LFO2Controller
MIDI Controlle which controls the filter cutoff LFO.
Definition: gig.h:530
gig::Region::DimensionRegions
uint32_t DimensionRegions
Total number of DimensionRegions this Region contains, do not alter!
Definition: gig.h:878
gig::Sample::Instances
static size_t Instances
Number of instances of class Sample.
Definition: gig.h:806
gig::playback_state_t::reverse
bool reverse
If playback direction is currently backwards (in case there is a pingpong or reverse loop defined).
Definition: gig.h:379
DLS::Region
Defines Region information of an Instrument.
Definition: DLS.h:492
gig::Script::Language
Language_t Language
Programming language and dialect the script is written in.
Definition: gig.h:1139
DLS::Sampler::pSampleLoops
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:432
gig::DimensionRegion::LFO3Controller
lfo3_ctrl_t LFO3Controller
MIDI Controller which controls the sample pitch LFO.
Definition: gig.h:539
gig::vcf_res_ctrl_genpurpose4
@ vcf_res_ctrl_genpurpose4
General Purpose Controller 4 (Slider, MIDI Controller 19)
Definition: gig.h:226
gig::DimensionRegion::SetVCFCutoffController
void SetVCFCutoffController(vcf_cutoff_ctrl_t controller)
Updates the respective member variable and the lookup table / cache that depends on this value.
Definition: gig.cpp:3128
gig::dimension_none
@ dimension_none
Dimension not in use.
Definition: gig.h:319
gig::dimension_sustainpedal
@ dimension_sustainpedal
Sustain Pedal (MIDI Controller 64)
Definition: gig.h:319
gig::lfo3_ctrl_internal_aftertouch
@ lfo3_ctrl_internal_aftertouch
Controlled internally and by aftertouch controller.
Definition: gig.h:171
gig::MidiRuleAlternator
MIDI rule to automatically cycle through specified sequences of different articulations.
Definition: gig.h:1044
gig::lfo3_ctrl_internal_modwheel
@ lfo3_ctrl_internal_modwheel
Controlled internally and by external modulation wheel.
Definition: gig.h:171
gig::DimensionRegion::ChannelOffset
uint8_t ChannelOffset
Audio output where the audio signal of the dimension region should be routed to (0 - 9).
Definition: gig.h:571
gig::leverage_ctrl_t
Defines a controller that has a certain contrained influence on a particular synthesis parameter (use...
Definition: gig.h:236
DLS::File::Instruments
uint32_t Instruments
Reflects the number of available Instrument objects.
Definition: DLS.h:564
gig::DimensionRegion::SetVCFVelocityCurve
void SetVCFVelocityCurve(curve_type_t curve)
Updates the respective member variable and the lookup table / cache that depends on this value.
Definition: gig.cpp:3137
gig::leverage_ctrl_t::type_controlchange
@ type_controlchange
Ordinary MIDI control change controller, see field 'controller_number'.
Definition: gig.h:246
DLS::File::pVersion
version_t * pVersion
Points to a version_t structure if the file provided a version number else is set to NULL.
Definition: DLS.h:563
gig::DimensionRegion::EG1ControllerAttackInfluence
uint8_t EG1ControllerAttackInfluence
Amount EG1 Controller has influence on the EG1 Attack time (0 - 3, where 0 means off).
Definition: gig.h:505
gig::eg2_ctrl_t
leverage_ctrl_t eg2_ctrl_t
Defines controller influencing envelope generator 2.
Definition: gig.h:273
gig::dimension_genpurpose1
@ dimension_genpurpose1
General Purpose Controller 1 (Slider, MIDI Controller 16)
Definition: gig.h:319
gig::dimension_samplechannel
@ dimension_samplechannel
If used sample has more than one channel (thus is not mono).
Definition: gig.h:319
gig::dimension_layer
@ dimension_layer
For layering of up to 8 instruments (and eventually crossfading of 2 or 4 layers).
Definition: gig.h:319
gig::eg_opt_t::AttackHoldCancel
bool AttackHoldCancel
Whether the "attack hold" stage is cancelled when receiving a note-off (default: true).
Definition: gig.h:408
gig::DimensionRegion::MSDecode
bool MSDecode
Gigastudio flag: defines if Mid Side Recordings should be decoded.
Definition: gig.h:573
gig::dim_bypass_ctrl_t
dim_bypass_ctrl_t
Dimensions allow to bypass one of the following controllers.
Definition: gig.h:159
gig::Sample::Read
file_offset_t Read(void *pBuffer, file_offset_t SampleCount, buffer_t *pExternalDecompressionBuffer=NULL)
Reads SampleCount number of sample points from the current position into the buffer pointed by pBuffe...
Definition: gig.cpp:1140
gig::dim_bypass_ctrl_none
@ dim_bypass_ctrl_none
No controller bypass.
Definition: gig.h:159
gig::MidiRuleLegato::ReleaseTriggerKey
uint8_t ReleaseTriggerKey
Key triggering release samples.
Definition: gig.h:1021
gig::Group
Group of Gigasampler samples.
Definition: gig.h:1292
gig::MidiRuleAlternator::KeySwitchRange
range_t KeySwitchRange
Key range for key switch selector.
Definition: gig.h:1071
gig::libraryName
String libraryName()
Returns the name of this C++ library.
Definition: gig.cpp:6785
gig::Sample::FrameOffset
file_offset_t FrameOffset
Current offset (sample points) in current sample frame (for decompression only).
Definition: gig.h:809
gig::dimension_sostenutopedal
@ dimension_sostenutopedal
Sostenuto Pedal (MIDI Controller 66)
Definition: gig.h:319
gig::dimension_effect5depth
@ dimension_effect5depth
Effect 5 Depth (MIDI Controller 95)
Definition: gig.h:319
gig::Sample::SamplePos
file_offset_t SamplePos
For compressed samples only: stores the current position (in sample points).
Definition: gig.h:811
gig::DimensionRegion::VCFCutoffController
vcf_cutoff_ctrl_t VCFCutoffController
Specifies which external controller has influence on the filter cutoff frequency.
Definition: gig.h:544
DLS::Instrument::MIDIBankFine
uint8_t MIDIBankFine
Reflects the MIDI Bank number for MIDI Control Change 32 (bank 1 - 128).
Definition: DLS.h:528
gig::attenuation_ctrl_t
leverage_ctrl_t attenuation_ctrl_t
Defines controller influencing attenuation.
Definition: gig.h:259
gig::dimension_t
dimension_t
Defines the type of dimension, that is how the dimension zones (and thus how the dimension regions ar...
Definition: gig.h:319
gig::MidiRule
Abstract base class for all MIDI rules.
Definition: gig.h:950
gig::DimensionRegion::AttenuationController
attenuation_ctrl_t AttenuationController
MIDI Controller which has influence on the volume level of the sample (or entire sample group).
Definition: gig.h:568
gig::vcf_res_ctrl_t
vcf_res_ctrl_t
Defines how the filter resonance is controlled by.
Definition: gig.h:226
gig::DimensionRegion
Encapsulates articulation informations of a dimension region.
Definition: gig.h:490
gig::Sample::LoopFraction
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:776
gig::Region::DeleteDimension
void DeleteDimension(dimension_def_t *pDimDef)
Delete an existing dimension.
Definition: gig.cpp:3615
gig::leverage_ctrl_t::type_t
type_t
Defines possible controllers.
Definition: gig.h:246
DLS::File::GetFileName
String GetFileName()
File name of this DLS file.
Definition: DLS.cpp:1841
gig::Instrument::DimensionKeyRange
range_t DimensionKeyRange
0-127 (where 0 means C1 and 127 means G9)
Definition: gig.h:1227
gig::curve_type_unknown
@ curve_type_unknown
Unknown curve type.
Definition: gig.h:149
gig::MidiRuleAlternator::Selector
selector_t Selector
Method by which pattern is chosen.
Definition: gig.h:1070
gig::eg_opt_t
Defines behavior options for envelope generators (gig format extension).
Definition: gig.h:406
gig::Region::Dimensions
unsigned int Dimensions
Number of defined dimensions, do not alter!
Definition: gig.h:876
gig::DimensionRegion::EG2ControllerInvert
bool EG2ControllerInvert
Invert values coming from defined EG2 controller.
Definition: gig.h:523
gig::lfo2_ctrl_internal_modwheel
@ lfo2_ctrl_internal_modwheel
Controlled internally and by external modulation wheel.
Definition: gig.h:183
gig::Region::UpdateChunks
virtual void UpdateChunks(progress_t *pProgress)
Apply Region settings and all its DimensionRegions to the respective RIFF chunks.
Definition: gig.cpp:3328
gig::DimensionRegion::LFO3ControlDepth
int16_t LFO3ControlDepth
Controller depth of the sample pitch LFO (-1200 - +1200 cents).
Definition: gig.h:538
gig::MidiRuleLegato::BypassKey
uint8_t BypassKey
Key to be used to bypass the sustain note.
Definition: gig.h:1016
gig::DimensionRegion::EG2Options
eg_opt_t EG2Options
[gig extension]: Behavior options which should be used for envelope generator 2 (filter cutoff EG).
Definition: gig.h:578
gig::MidiRuleAlternator::Polyphonic
bool Polyphonic
If alternator should step forward only when all notes are off.
Definition: gig.h:1074
gig::MidiRuleAlternator::Patterns
uint8_t Patterns
Number of alternator patterns.
Definition: gig.h:1051
gig::DimensionRegion::EG3Attack
double EG3Attack
Attack time of the sample pitch EG (0.000 - 10.000s).
Definition: gig.h:534
gig::vcf_type_highpass
@ vcf_type_highpass
Highpass filter type.
Definition: gig.h:351
RIFF::file_offset_t
uint64_t file_offset_t
Type used by libgig for handling file positioning during file I/O tasks.
Definition: RIFF.h:160
gig::Sample::Sample
Sample(File *pFile, RIFF::List *waveList, file_offset_t WavePoolOffset, unsigned long fileNo=0, int index=-1)
Constructor.
Definition: gig.cpp:390
gig::Sample::LoopSize
uint32_t LoopSize
Caution: Use the respective fields in the DimensionRegion instead of this one! (Intended purpose: Len...
Definition: gig.h:775
gig::dimension_def_t::dimension
dimension_t dimension
Specifies which source (usually a MIDI controller) is associated with the dimension.
Definition: gig.h:334
gig::dimension_portamentotime
@ dimension_portamentotime
Portamento Time (Coarse, MIDI Controller 5)
Definition: gig.h:319
gig::DimensionRegion::LFO1FlipPhase
bool LFO1FlipPhase
Inverts phase of the sample amplitude LFO wave.
Definition: gig.h:512
gig::lfo1_ctrl_internal_modwheel
@ lfo1_ctrl_internal_modwheel
Controlled internally and by external modulation wheel.
Definition: gig.h:195
DLS::Storage
Abstract base class for all classes using RIFF::Chunks for persistency.
Definition: DLS.h:283
gig::Script::ENCODING_ASCII
@ ENCODING_ASCII
Standard 8 bit US ASCII character encoding (default).
Definition: gig.h:1127
gig::vcf_cutoff_ctrl_none
@ vcf_cutoff_ctrl_none
No MIDI controller assigned for filter cutoff frequency.
Definition: gig.h:214
RIFF
RIFF specific classes and definitions.
Definition: RIFF.h:150
gig::Sample::GetPos
file_offset_t GetPos() const
Returns the current position in the sample (in sample points).
Definition: gig.cpp:926
gig::libraryVersion
String libraryVersion()
Returns version of this C++ library.
Definition: gig.cpp:6793
gig::Sample::UpdateChunks
virtual void UpdateChunks(progress_t *pProgress)
Apply sample and its settings to the respective RIFF chunks.
Definition: gig.cpp:574
gig::Sample::LoopStart
uint32_t LoopStart
Caution: Use the respective field in the DimensionRegion instead of this one! (Intended purpose: The ...
Definition: gig.h:773
gig::enumKey
const char * enumKey(String typeName, size_t value)
Enum constant name of numeric value.
Definition: typeinfo.cpp:280
gig::dimension_effect2
@ dimension_effect2
Effect Controller 2 (Coarse, MIDI Controller 13)
Definition: gig.h:319
gig::dim_bypass_ctrl_94
@ dim_bypass_ctrl_94
Effect 4 Depth (MIDI Controller 94)
Definition: gig.h:159
gig::eg_opt_t::Decay1Cancel
bool Decay1Cancel
Whether the "decay 1" stage is cancelled when receiving a note-off (default: true).
Definition: gig.h:409
gig::DimensionRegion::LFO2InternalDepth
uint16_t LFO2InternalDepth
Firm pitch of the filter cutoff LFO (0 - 1200 cents).
Definition: gig.h:528
gig::DimensionRegion::EG1Decay2
double EG1Decay2
Only if EG1InfiniteSustain == false: 2nd decay stage time of the sample amplitude EG (0....
Definition: gig.h:498
gig::Sample::Dithered
bool Dithered
For 24-bit compressed samples only: if dithering was used during compression with bit reduction.
Definition: gig.h:780
gig::Script::Name
String Name
Arbitrary name of the script, which may be displayed i.e. in an instrument editor.
Definition: gig.h:1136
gig::crossfade_t
Defines the envelope of a crossfade.
Definition: gig.h:360
DLS::Instrument::Regions
uint32_t Regions
Reflects the number of Region defintions this Instrument has.
Definition: DLS.h:530
gig::lfo2_ctrl_internal_foot
@ lfo2_ctrl_internal_foot
Controlled internally and by external foot controller.
Definition: gig.h:183
gig::MidiRuleAlternator::pArticulations
String pArticulations[32]
Names of the articulations.
Definition: gig.h:1047
gig::Sample::LoadSampleData
buffer_t LoadSampleData()
Loads (and uncompresses if needed) the whole sample wave into RAM.
Definition: gig.cpp:706
gig::Sample::Manufacturer
uint32_t Manufacturer
Specifies the MIDI Manufacturer's Association (MMA) Manufacturer code for the sampler intended to rec...
Definition: gig.h:763
gig::DimensionRegion::LFO1Sync
bool LFO1Sync
If set to true only one LFO should be used for all voices.
Definition: gig.h:513
gig::Sample::CopyAssignMeta
void CopyAssignMeta(const Sample *orig)
Make a (semi) deep copy of the Sample object given by orig (without the actual waveform data) and ass...
Definition: gig.cpp:510
gig::sust_rel_trg_keyvelocity
@ sust_rel_trg_keyvelocity
Play release trigger sample(s) on sustain pedal up, and use the key`s last MIDI note-on velocity for ...
Definition: gig.h:437
DLS::Sampler::AddSampleLoop
void AddSampleLoop(sample_loop_t *pLoopDef)
Adds a new sample loop with the provided loop definition.
Definition: DLS.cpp:706
gig::dimension_effect3depth
@ dimension_effect3depth
Effect 3 Depth (MIDI Controller 93)
Definition: gig.h:319
gig::Sample::ReleaseSampleData
void ReleaseSampleData()
Frees the cached sample from RAM if loaded with LoadSampleData() previously.
Definition: gig.cpp:829
gig::vcf_type_bandreject
@ vcf_type_bandreject
Band reject filter type.
Definition: gig.h:351
gig::dimension_genpurpose2
@ dimension_genpurpose2
General Purpose Controller 2 (Slider, MIDI Controller 17)
Definition: gig.h:319
gig::DimensionRegion::pSample
Sample * pSample
Points to the Sample which is assigned to the dimension region.
Definition: gig.h:493
gig::lfo2_ctrl_t
lfo2_ctrl_t
Defines how LFO2 is controlled by.
Definition: gig.h:183