libgig  4.0.0.6svn2980
gig.h
Go to the documentation of this file.
1 /***************************************************************************
2  * *
3  * libgig - C++ cross-platform Gigasampler format file access library *
4  * *
5  * Copyright (C) 2003-2016 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 #if WORDS_BIGENDIAN
31 # define LIST_TYPE_3PRG 0x33707267
32 # define LIST_TYPE_3EWL 0x3365776C
33 # define LIST_TYPE_3GRI 0x33677269
34 # define LIST_TYPE_3GNL 0x33676E6C
35 # define LIST_TYPE_3LS 0x334c5320 // own gig format extension
36 # define LIST_TYPE_RTIS 0x52544953 // own gig format extension
37 # define CHUNK_ID_3GIX 0x33676978
38 # define CHUNK_ID_3EWA 0x33657761
39 # define CHUNK_ID_3LNK 0x336C6E6B
40 # define CHUNK_ID_3EWG 0x33657767
41 # define CHUNK_ID_EWAV 0x65776176
42 # define CHUNK_ID_3GNM 0x33676E6D
43 # define CHUNK_ID_EINF 0x65696E66
44 # define CHUNK_ID_3CRC 0x33637263
45 # define CHUNK_ID_SCRI 0x53637269 // own gig format extension
46 # define CHUNK_ID_LSNM 0x4c534e4d // own gig format extension
47 # define CHUNK_ID_SCSL 0x5343534c // own gig format extension
48 #else // little endian
49 # define LIST_TYPE_3PRG 0x67727033
50 # define LIST_TYPE_3EWL 0x6C776533
51 # define LIST_TYPE_3GRI 0x69726733
52 # define LIST_TYPE_3GNL 0x6C6E6733
53 # define LIST_TYPE_3LS 0x20534c33 // own gig format extension
54 # define LIST_TYPE_RTIS 0x53495452 // own gig format extension
55 # define CHUNK_ID_3GIX 0x78696733
56 # define CHUNK_ID_3EWA 0x61776533
57 # define CHUNK_ID_3LNK 0x6B6E6C33
58 # define CHUNK_ID_3EWG 0x67776533
59 # define CHUNK_ID_EWAV 0x76617765
60 # define CHUNK_ID_3GNM 0x6D6E6733
61 # define CHUNK_ID_EINF 0x666E6965
62 # define CHUNK_ID_3CRC 0x63726333
63 # define CHUNK_ID_SCRI 0x69726353 // own gig format extension
64 # define CHUNK_ID_LSNM 0x4d4e534c // own gig format extension
65 # define CHUNK_ID_SCSL 0x4c534353 // own gig format extension
66 #endif // WORDS_BIGENDIAN
67 
69 namespace gig {
70 
71  typedef std::string String;
74 
76  struct range_t {
77  uint8_t low;
78  uint8_t high;
79  };
80 
82  struct buffer_t {
83  void* pStart;
84  file_offset_t Size;
85  file_offset_t NullExtensionSize;
87  pStart = NULL;
88  Size = 0;
89  NullExtensionSize = 0;
90  }
91  };
92 
94  typedef enum {
95  loop_type_normal = 0x00000000,
96  loop_type_bidirectional = 0x00000001,
97  loop_type_backward = 0x00000002
98  } loop_type_t;
99 
101  typedef enum {
102  smpte_format_no_offset = 0x00000000,
103  smpte_format_24_frames = 0x00000018,
104  smpte_format_25_frames = 0x00000019,
107  } smpte_format_t;
108 
110  typedef enum {
114  curve_type_unknown = 0xffffffff
115  } curve_type_t;
116 
118  typedef enum {
123 
125  typedef enum {
131  } lfo3_ctrl_t;
132 
134  typedef enum {
137  lfo2_ctrl_foot = 0x02,
140  } lfo2_ctrl_t;
141 
143  typedef enum {
149  } lfo1_ctrl_t;
150 
152  typedef enum {
166 
168  typedef enum {
169  vcf_res_ctrl_none = 0xffffffff,
174  } vcf_res_ctrl_t;
175 
185  typedef enum {
186  type_none = 0x00,
187  type_channelaftertouch = 0x2f,
188  type_velocity = 0xff,
189  type_controlchange = 0xfe
190  } type_t;
191 
194  };
195 
202 
209 
216 
224  typedef enum {
225  dimension_none = 0x00,
238  dimension_foot = 0x04,
259  } dimension_t;
260 
265  typedef enum {
268  } split_type_t;
269 
273  uint8_t bits;
274  uint8_t zones;
275  split_type_t split_type;
276  float zone_size;
277  };
278 
280  typedef enum {
286  } vcf_type_t;
287 
295  struct crossfade_t {
296  #if WORDS_BIGENDIAN
297  uint8_t out_end;
298  uint8_t out_start;
299  uint8_t in_end;
300  uint8_t in_start;
301  #else // little endian
302  uint8_t in_start;
303  uint8_t in_end;
304  uint8_t out_start;
305  uint8_t out_end;
306  #endif // WORDS_BIGENDIAN
307  };
308 
311  file_offset_t position;
312  bool reverse;
313  file_offset_t loop_cycles_left;
314  };
315 
316  // just symbol prototyping
317  class File;
318  class Instrument;
319  class Sample;
320  class Region;
321  class Group;
322  class Script;
323  class ScriptGroup;
324 
367  class DimensionRegion : protected DLS::Sampler {
368  public:
371  // Sample Amplitude EG/LFO
372  uint16_t EG1PreAttack;
373  double EG1Attack;
374  double EG1Decay1;
375  double EG1Decay2;
377  uint16_t EG1Sustain;
378  double EG1Release;
379  bool EG1Hold;
380  eg1_ctrl_t EG1Controller;
385  double LFO1Frequency;
386  uint16_t LFO1InternalDepth;
387  uint16_t LFO1ControlDepth;
390  bool LFO1Sync;
391  // Filter Cutoff Frequency EG/LFO
392  uint16_t EG2PreAttack;
393  double EG2Attack;
394  double EG2Decay1;
395  double EG2Decay2;
397  uint16_t EG2Sustain;
398  double EG2Release;
399  eg2_ctrl_t EG2Controller;
404  double LFO2Frequency;
405  uint16_t LFO2InternalDepth;
406  uint16_t LFO2ControlDepth;
409  bool LFO2Sync;
410  // Sample Pitch EG/LFO
411  double EG3Attack;
412  int16_t EG3Depth;
413  double LFO3Frequency;
417  bool LFO3Sync;
418  // Filter
419  bool VCFEnabled;
423  uint8_t VCFCutoff;
427  uint8_t VCFResonance;
432  // Key Velocity Transformations
439  // Mix / Layer
441  bool PitchTrack;
442  dim_bypass_ctrl_t DimensionBypass;
443  int8_t Pan;
444  bool SelfMask;
445  attenuation_ctrl_t AttenuationController;
448  uint8_t ChannelOffset;
450  bool MSDecode;
451  uint16_t SampleStartOffset;
453  uint8_t DimensionUpperLimits[8];
454 
455  // derived attributes from DLS::Sampler
458  using DLS::Sampler::Gain;
461 
462  // own methods
463  double GetVelocityAttenuation(uint8_t MIDIKeyVelocity);
464  double GetVelocityRelease(uint8_t MIDIKeyVelocity);
465  double GetVelocityCutoff(uint8_t MIDIKeyVelocity);
466  void SetVelocityResponseCurve(curve_type_t curve);
467  void SetVelocityResponseDepth(uint8_t depth);
468  void SetVelocityResponseCurveScaling(uint8_t scaling);
469  void SetReleaseVelocityResponseCurve(curve_type_t curve);
470  void SetReleaseVelocityResponseDepth(uint8_t depth);
471  void SetVCFCutoffController(vcf_cutoff_ctrl_t controller);
472  void SetVCFVelocityCurve(curve_type_t curve);
473  void SetVCFVelocityDynamicRange(uint8_t range);
474  void SetVCFVelocityScale(uint8_t scaling);
475  Region* GetParent() const;
476  // derived methods
479  // overridden methods
480  virtual void SetGain(int32_t gain);
481  virtual void UpdateChunks(progress_t* pProgress);
482  virtual void CopyAssign(const DimensionRegion* orig);
483  protected:
484  uint8_t* VelocityTable;
485  DimensionRegion(Region* pParent, RIFF::List* _3ewl);
486  DimensionRegion(RIFF::List* _3ewl, const DimensionRegion& src);
487  ~DimensionRegion();
488  void CopyAssign(const DimensionRegion* orig, const std::map<Sample*,Sample*>* mSamples);
489  friend class Region;
490  private:
491  typedef enum {
492  // official leverage controllers as they were defined in the original Gigasampler/GigaStudio format:
493  _lev_ctrl_none = 0x00,
494  _lev_ctrl_modwheel = 0x03,
495  _lev_ctrl_breath = 0x05,
496  _lev_ctrl_foot = 0x07,
497  _lev_ctrl_effect1 = 0x0d,
498  _lev_ctrl_effect2 = 0x0f,
499  _lev_ctrl_genpurpose1 = 0x11,
500  _lev_ctrl_genpurpose2 = 0x13,
501  _lev_ctrl_genpurpose3 = 0x15,
502  _lev_ctrl_genpurpose4 = 0x17,
503  _lev_ctrl_portamentotime = 0x0b,
504  _lev_ctrl_sustainpedal = 0x01,
505  _lev_ctrl_portamento = 0x19,
506  _lev_ctrl_sostenutopedal = 0x1b,
507  _lev_ctrl_softpedal = 0x09,
508  _lev_ctrl_genpurpose5 = 0x1d,
509  _lev_ctrl_genpurpose6 = 0x1f,
510  _lev_ctrl_genpurpose7 = 0x21,
511  _lev_ctrl_genpurpose8 = 0x23,
512  _lev_ctrl_effect1depth = 0x25,
513  _lev_ctrl_effect2depth = 0x27,
514  _lev_ctrl_effect3depth = 0x29,
515  _lev_ctrl_effect4depth = 0x2b,
516  _lev_ctrl_effect5depth = 0x2d,
517  _lev_ctrl_channelaftertouch = 0x2f,
518  _lev_ctrl_velocity = 0xff,
519 
520  // format extension (these controllers are so far only supported by LinuxSampler & gigedit) they will *NOT* work with Gigasampler/GigaStudio !
521  // (the assigned values here are their official MIDI CC number plus the highest bit set):
522  _lev_ctrl_CC3_EXT = 0x83,
523 
524  _lev_ctrl_CC6_EXT = 0x86,
525  _lev_ctrl_CC7_EXT = 0x87,
526  _lev_ctrl_CC8_EXT = 0x88,
527  _lev_ctrl_CC9_EXT = 0x89,
528  _lev_ctrl_CC10_EXT = 0x8a,
529  _lev_ctrl_CC11_EXT = 0x8b,
530 
531  _lev_ctrl_CC14_EXT = 0x8e,
532  _lev_ctrl_CC15_EXT = 0x8f,
533 
534  _lev_ctrl_CC20_EXT = 0x94,
535  _lev_ctrl_CC21_EXT = 0x95,
536  _lev_ctrl_CC22_EXT = 0x96,
537  _lev_ctrl_CC23_EXT = 0x97,
538  _lev_ctrl_CC24_EXT = 0x98,
539  _lev_ctrl_CC25_EXT = 0x99,
540  _lev_ctrl_CC26_EXT = 0x9a,
541  _lev_ctrl_CC27_EXT = 0x9b,
542  _lev_ctrl_CC28_EXT = 0x9c,
543  _lev_ctrl_CC29_EXT = 0x9d,
544  _lev_ctrl_CC30_EXT = 0x9e,
545  _lev_ctrl_CC31_EXT = 0x9f,
546 
547  _lev_ctrl_CC68_EXT = 0xc4,
548  _lev_ctrl_CC69_EXT = 0xc5,
549  _lev_ctrl_CC70_EXT = 0xc6,
550  _lev_ctrl_CC71_EXT = 0xc7,
551  _lev_ctrl_CC72_EXT = 0xc8,
552  _lev_ctrl_CC73_EXT = 0xc9,
553  _lev_ctrl_CC74_EXT = 0xca,
554  _lev_ctrl_CC75_EXT = 0xcb,
555  _lev_ctrl_CC76_EXT = 0xcc,
556  _lev_ctrl_CC77_EXT = 0xcd,
557  _lev_ctrl_CC78_EXT = 0xce,
558  _lev_ctrl_CC79_EXT = 0xcf,
559 
560  _lev_ctrl_CC84_EXT = 0xd4,
561  _lev_ctrl_CC85_EXT = 0xd5,
562  _lev_ctrl_CC86_EXT = 0xd6,
563  _lev_ctrl_CC87_EXT = 0xd7,
564 
565  _lev_ctrl_CC89_EXT = 0xd9,
566  _lev_ctrl_CC90_EXT = 0xda,
567 
568  _lev_ctrl_CC96_EXT = 0xe0,
569  _lev_ctrl_CC97_EXT = 0xe1,
570 
571  _lev_ctrl_CC102_EXT = 0xe6,
572  _lev_ctrl_CC103_EXT = 0xe7,
573  _lev_ctrl_CC104_EXT = 0xe8,
574  _lev_ctrl_CC105_EXT = 0xe9,
575  _lev_ctrl_CC106_EXT = 0xea,
576  _lev_ctrl_CC107_EXT = 0xeb,
577  _lev_ctrl_CC108_EXT = 0xec,
578  _lev_ctrl_CC109_EXT = 0xed,
579  _lev_ctrl_CC110_EXT = 0xee,
580  _lev_ctrl_CC111_EXT = 0xef,
581  _lev_ctrl_CC112_EXT = 0xf0,
582  _lev_ctrl_CC113_EXT = 0xf1,
583  _lev_ctrl_CC114_EXT = 0xf2,
584  _lev_ctrl_CC115_EXT = 0xf3,
585  _lev_ctrl_CC116_EXT = 0xf4,
586  _lev_ctrl_CC117_EXT = 0xf5,
587  _lev_ctrl_CC118_EXT = 0xf6,
588  _lev_ctrl_CC119_EXT = 0xf7
589  } _lev_ctrl_t;
590  typedef std::map<uint32_t, double*> VelocityTableMap;
591 
592  static size_t Instances;
593  static VelocityTableMap* pVelocityTables;
594  double* pVelocityAttenuationTable;
595  double* pVelocityReleaseTable;
596  double* pVelocityCutoffTable;
597  Region* pRegion;
598 
599  leverage_ctrl_t DecodeLeverageController(_lev_ctrl_t EncodedController);
600  _lev_ctrl_t EncodeLeverageController(leverage_ctrl_t DecodedController);
601  double* GetReleaseVelocityTable(curve_type_t releaseVelocityResponseCurve, uint8_t releaseVelocityResponseDepth);
602  double* GetCutoffVelocityTable(curve_type_t vcfVelocityCurve, uint8_t vcfVelocityDynamicRange, uint8_t vcfVelocityScale, vcf_cutoff_ctrl_t vcfCutoffController);
603  double* GetVelocityTable(curve_type_t curveType, uint8_t depth, uint8_t scaling);
604  double* CreateVelocityTable(curve_type_t curveType, uint8_t depth, uint8_t scaling);
605  };
606 
632  class Sample : public DLS::Sample {
633  public:
634  uint32_t Manufacturer;
635  uint32_t Product;
636  uint32_t SamplePeriod;
637  uint32_t MIDIUnityNote;
638  uint32_t FineTune;
640  uint32_t SMPTEOffset;
641  uint32_t Loops;
642  uint32_t LoopID;
644  uint32_t LoopStart;
645  uint32_t LoopEnd;
646  uint32_t LoopSize;
647  uint32_t LoopFraction;
648  uint32_t LoopPlayCount;
649  bool Compressed;
650  uint32_t TruncatedBits;
651  bool Dithered;
652 
653  // own methods
654  buffer_t LoadSampleData();
655  buffer_t LoadSampleData(file_offset_t SampleCount);
656  buffer_t LoadSampleDataWithNullSamplesExtension(uint NullSamplesCount);
657  buffer_t LoadSampleDataWithNullSamplesExtension(file_offset_t SampleCount, uint NullSamplesCount);
658  buffer_t GetCache();
659  // own static methods
660  static buffer_t CreateDecompressionBuffer(file_offset_t MaxReadSize);
661  static void DestroyDecompressionBuffer(buffer_t& DecompressionBuffer);
662  // overridden methods
663  void ReleaseSampleData();
664  void Resize(file_offset_t NewSize);
665  file_offset_t SetPos(file_offset_t SampleCount, RIFF::stream_whence_t Whence = RIFF::stream_start);
666  file_offset_t GetPos() const;
667  file_offset_t Read(void* pBuffer, file_offset_t SampleCount, buffer_t* pExternalDecompressionBuffer = NULL);
668  file_offset_t ReadAndLoop(void* pBuffer, file_offset_t SampleCount, playback_state_t* pPlaybackState, DimensionRegion* pDimRgn, buffer_t* pExternalDecompressionBuffer = NULL);
669  file_offset_t Write(void* pBuffer, file_offset_t SampleCount);
670  Group* GetGroup() const;
671  virtual void UpdateChunks(progress_t* pProgress);
672  void CopyAssignMeta(const Sample* orig);
673  void CopyAssignWave(const Sample* orig);
674  protected:
675  static size_t Instances;
678  file_offset_t FrameOffset;
679  file_offset_t* FrameTable;
680  file_offset_t SamplePos;
681  file_offset_t SamplesInLastFrame;
682  file_offset_t WorstCaseFrameSize;
683  file_offset_t SamplesPerFrame;
685  unsigned long FileNo;
688  uint32_t crc;
689 
690  Sample(File* pFile, RIFF::List* waveList, file_offset_t WavePoolOffset, unsigned long fileNo = 0);
691  ~Sample();
692 
693  // Guess size (in bytes) of a compressed sample
694  inline file_offset_t GuessSize(file_offset_t samples) {
695  // 16 bit: assume all frames are compressed - 1 byte
696  // per sample and 5 bytes header per 2048 samples
697 
698  // 24 bit: assume next best compression rate - 1.5
699  // bytes per sample and 13 bytes header per 256
700  // samples
701  const file_offset_t size =
702  BitDepth == 24 ? samples + (samples >> 1) + (samples >> 8) * 13
703  : samples + (samples >> 10) * 5;
704  // Double for stereo and add one worst case sample
705  // frame
706  return (Channels == 2 ? size << 1 : size) + WorstCaseFrameSize;
707  }
708 
709  // Worst case amount of sample points that can be read with the
710  // given decompression buffer.
711  inline file_offset_t WorstCaseMaxSamples(buffer_t* pDecompressionBuffer) {
712  return (file_offset_t) ((float)pDecompressionBuffer->Size / (float)WorstCaseFrameSize * (float)SamplesPerFrame);
713  }
714  private:
715  void ScanCompressedSample();
716  friend class File;
717  friend class Region;
718  friend class Group; // allow to modify protected member pGroup
719  };
720 
721  // TODO: <3dnl> list not used yet - not important though (just contains optional descriptions for the dimensions)
742  class Region : public DLS::Region {
743  public:
744  unsigned int Dimensions;
745  dimension_def_t pDimensionDefinitions[8];
746  uint32_t DimensionRegions;
747  DimensionRegion* pDimensionRegions[256];
748  unsigned int Layers;
749 
750  // own methods
751  DimensionRegion* GetDimensionRegionByValue(const uint DimValues[8]);
752  DimensionRegion* GetDimensionRegionByBit(const uint8_t DimBits[8]);
753  int GetDimensionRegionIndexByValue(const uint DimValues[8]);
754  Sample* GetSample();
755  void AddDimension(dimension_def_t* pDimDef);
756  void DeleteDimension(dimension_def_t* pDimDef);
757  dimension_def_t* GetDimensionDefinition(dimension_t type);
758  void DeleteDimensionZone(dimension_t type, int zone);
759  void SplitDimensionZone(dimension_t type, int zone);
760  void SetDimensionType(dimension_t oldType, dimension_t newType);
761  // overridden methods
762  virtual void SetKeyRange(uint16_t Low, uint16_t High);
763  virtual void UpdateChunks(progress_t* pProgress);
764  virtual void CopyAssign(const Region* orig);
765  protected:
766  Region(Instrument* pInstrument, RIFF::List* rgnList);
767  void LoadDimensionRegions(RIFF::List* rgn);
768  void UpdateVelocityTable();
769  Sample* GetSampleFromWavePool(unsigned int WavePoolTableIndex, progress_t* pProgress = NULL);
770  void CopyAssign(const Region* orig, const std::map<Sample*,Sample*>* mSamples);
771  DimensionRegion* GetDimensionRegionByBit(const std::map<dimension_t,int>& DimCase);
772  ~Region();
773  friend class Instrument;
774  };
775 
818  class MidiRule {
819  public:
820  virtual ~MidiRule() { }
821  protected:
822  virtual void UpdateChunks(uint8_t* pData) const = 0;
823  friend class Instrument;
824  };
825 
839  class MidiRuleCtrlTrigger : public MidiRule {
840  public:
842  uint8_t Triggers;
843  struct trigger_t {
844  uint8_t TriggerPoint;
845  bool Descending;
846  uint8_t VelSensitivity;
847  uint8_t Key;
848  bool NoteOff;
849  uint8_t Velocity;
851  } pTriggers[32];
852 
853  protected:
856  void UpdateChunks(uint8_t* pData) const;
857  friend class Instrument;
858  };
859 
880  class MidiRuleLegato : public MidiRule {
881  public:
882  uint8_t LegatoSamples;
884  uint8_t BypassKey;
886  uint16_t ThresholdTime;
887  uint16_t ReleaseTime;
890  uint8_t AltSustain1Key;
891  uint8_t AltSustain2Key;
892 
893  protected:
894  MidiRuleLegato(RIFF::Chunk* _3ewg);
895  MidiRuleLegato();
896  void UpdateChunks(uint8_t* pData) const;
897  friend class Instrument;
898  };
899 
912  class MidiRuleAlternator : public MidiRule {
913  public:
914  uint8_t Articulations;
915  String pArticulations[32];
916 
918 
919  uint8_t Patterns;
920  struct pattern_t {
921  String Name;
922  int Size;
923  const uint8_t& operator[](int i) const {
924  return data[i];
925  }
926  uint8_t& operator[](int i) {
927  return data[i];
928  }
929  private:
930  uint8_t data[32];
931  } pPatterns[32];
932 
933  typedef enum {
936  selector_controller
937  } selector_t;
938  selector_t Selector;
940  uint8_t Controller;
941 
942  bool Polyphonic;
943  bool Chained;
944 
945  protected:
948  void UpdateChunks(uint8_t* pData) const;
949  friend class Instrument;
950  };
951 
965  class MidiRuleUnknown : public MidiRule {
966  protected:
968  void UpdateChunks(uint8_t* pData) const { }
969  friend class Instrument;
970  };
971 
992  class Script {
993  public:
994  enum Encoding_t {
995  ENCODING_ASCII = 0
996  };
998  COMPRESSION_NONE = 0
999  };
1000  enum Language_t {
1001  LANGUAGE_NKSP = 0
1002  };
1003 
1004  String Name;
1008  bool Bypass;
1009 
1010  String GetScriptAsText();
1011  void SetScriptAsText(const String& text);
1012  void SetGroup(ScriptGroup* pGroup);
1013  ScriptGroup* GetGroup() const;
1014  protected:
1015  Script(ScriptGroup* group, RIFF::Chunk* ckScri);
1016  virtual ~Script();
1017  void UpdateChunks(progress_t* pProgress);
1018  void RemoveAllScriptReferences();
1019  friend class ScriptGroup;
1020  friend class Instrument;
1021  private:
1022  ScriptGroup* pGroup;
1023  RIFF::Chunk* pChunk;
1024  std::vector<uint8_t> data;
1025  uint32_t crc;
1026  };
1027 
1039  class ScriptGroup {
1040  public:
1041  String Name;
1042 
1043  Script* GetScript(uint index);
1044  Script* AddScript();
1045  void DeleteScript(Script* pScript);
1046  protected:
1047  ScriptGroup(File* file, RIFF::List* lstRTIS);
1048  virtual ~ScriptGroup();
1049  void LoadScripts();
1050  void UpdateChunks(progress_t* pProgress);
1051  friend class Script;
1052  friend class File;
1053  private:
1054  File* pFile;
1055  RIFF::List* pList;
1056  std::list<Script*>* pScripts;
1057  };
1058 
1074  class Instrument : protected DLS::Instrument {
1075  public:
1076  // derived attributes from DLS::Resource
1077  using DLS::Resource::pInfo;
1078  using DLS::Resource::pDLSID;
1079  // derived attributes from DLS::Instrument
1086  // own attributes
1087  int32_t Attenuation;
1088  uint16_t EffectSend;
1089  int16_t FineTune;
1090  uint16_t PitchbendRange;
1093 
1094 
1095  // derived methods from DLS::Resource
1097  // overridden methods
1098  Region* GetFirstRegion();
1099  Region* GetNextRegion();
1100  Region* AddRegion();
1101  void DeleteRegion(Region* pRegion);
1102  void MoveTo(Instrument* dst);
1103  virtual void UpdateChunks(progress_t* pProgress);
1104  virtual void CopyAssign(const Instrument* orig);
1105  // own methods
1106  Region* GetRegion(unsigned int Key);
1107  MidiRule* GetMidiRule(int i);
1108  MidiRuleCtrlTrigger* AddMidiRuleCtrlTrigger();
1109  MidiRuleLegato* AddMidiRuleLegato();
1110  MidiRuleAlternator* AddMidiRuleAlternator();
1111  void DeleteMidiRule(int i);
1112  // real-time instrument script methods
1113  Script* GetScriptOfSlot(uint index);
1114  void AddScriptSlot(Script* pScript, bool bypass = false);
1115  void SwapScriptSlots(uint index1, uint index2);
1116  void RemoveScriptSlot(uint index);
1117  void RemoveScript(Script* pScript);
1118  uint ScriptSlotCount() const;
1119  bool IsScriptSlotBypassed(uint index);
1120  void SetScriptSlotBypassed(uint index, bool bBypass);
1121  protected:
1122  Region* RegionKeyTable[128];
1123 
1124  Instrument(File* pFile, RIFF::List* insList, progress_t* pProgress = NULL);
1125  ~Instrument();
1126  void CopyAssign(const Instrument* orig, const std::map<Sample*,Sample*>* mSamples);
1127  void UpdateRegionKeyTable();
1128  void LoadScripts();
1129  void UpdateScriptFileOffsets();
1130  friend class File;
1131  friend class Region; // so Region can call UpdateRegionKeyTable()
1132  private:
1133  struct _ScriptPooolEntry {
1134  uint32_t fileOffset;
1135  bool bypass;
1136  };
1137  struct _ScriptPooolRef {
1138  Script* script;
1139  bool bypass;
1140  };
1141  MidiRule** pMidiRules;
1142  std::vector<_ScriptPooolEntry> scriptPoolFileOffsets;
1143  std::vector<_ScriptPooolRef>* pScriptRefs;
1144  };
1145 
1157  class Group {
1158  public:
1159  String Name;
1160 
1161  Sample* GetFirstSample();
1162  Sample* GetNextSample();
1163  void AddSample(Sample* pSample);
1164  protected:
1165  Group(File* file, RIFF::Chunk* ck3gnm);
1166  virtual ~Group();
1167  virtual void UpdateChunks(progress_t* pProgress);
1168  void MoveAll();
1169  friend class File;
1170  private:
1171  File* pFile;
1172  RIFF::Chunk* pNameChunk;
1173  };
1174 
1211  class File : protected DLS::File {
1212  public:
1215 
1216  // derived attributes from DLS::Resource
1217  using DLS::Resource::pInfo;
1218  using DLS::Resource::pDLSID;
1219  // derived attributes from DLS::File
1220  using DLS::File::pVersion;
1221  using DLS::File::Instruments;
1222 
1223  // derived methods from DLS::Resource
1225  // derived methods from DLS::File
1226  using DLS::File::Save;
1227  using DLS::File::GetFileName;
1228  using DLS::File::SetFileName;
1229  // overridden methods
1230  File();
1231  File(RIFF::File* pRIFF);
1232  Sample* GetFirstSample(progress_t* pProgress = NULL);
1233  Sample* GetNextSample();
1234  Sample* GetSample(uint index);
1235  Sample* AddSample();
1236  void DeleteSample(Sample* pSample);
1237  Instrument* GetFirstInstrument();
1238  Instrument* GetNextInstrument();
1239  Instrument* GetInstrument(uint index, progress_t* pProgress = NULL);
1240  Instrument* AddInstrument();
1241  Instrument* AddDuplicateInstrument(const Instrument* orig);
1242  void DeleteInstrument(Instrument* pInstrument);
1243  Group* GetFirstGroup();
1244  Group* GetNextGroup();
1245  Group* GetGroup(uint index);
1246  Group* GetGroup(String name);
1247  Group* AddGroup();
1248  void DeleteGroup(Group* pGroup);
1249  void DeleteGroupOnly(Group* pGroup);
1250  void SetAutoLoad(bool b);
1251  bool GetAutoLoad();
1252  void AddContentOf(File* pFile);
1253  ScriptGroup* GetScriptGroup(uint index);
1254  ScriptGroup* GetScriptGroup(const String& name);
1255  ScriptGroup* AddScriptGroup();
1256  void DeleteScriptGroup(ScriptGroup* pGroup);
1257  virtual ~File();
1258  virtual void UpdateChunks(progress_t* pProgress);
1259  protected:
1260  // overridden protected methods from DLS::File
1261  virtual void LoadSamples();
1262  virtual void LoadInstruments();
1263  virtual void LoadGroups();
1264  virtual void UpdateFileOffsets();
1265  // own protected methods
1266  virtual void LoadSamples(progress_t* pProgress);
1267  virtual void LoadInstruments(progress_t* pProgress);
1268  virtual void LoadScriptGroups();
1269  void SetSampleChecksum(Sample* pSample, uint32_t crc);
1270  friend class Region;
1271  friend class Sample;
1272  friend class Instrument;
1273  friend class Group; // so Group can access protected member pRIFF
1274  friend class ScriptGroup; // so ScriptGroup can access protected member pRIFF
1275  private:
1276  std::list<Group*>* pGroups;
1277  std::list<Group*>::iterator GroupsIterator;
1278  bool bAutoLoad;
1279  std::list<ScriptGroup*>* pScriptGroups;
1280  };
1281 
1290  class Exception : public DLS::Exception {
1291  public:
1292  Exception(String Message);
1293  void PrintMessage();
1294  };
1295 
1296  String libraryName();
1297  String libraryVersion();
1298 
1299 } // namespace gig
1300 
1301 #endif // __GIG_H__
range_t KeySwitchRange
Key range for key switch selector.
Definition: gig.h:939
bool LFO2FlipPhase
Inverts phase of the filter cutoff LFO wave.
Definition: gig.h:408
General Purpose Controller 4 (Slider, MIDI Controller 19)
Definition: gig.h:245
dim_bypass_ctrl_t DimensionBypass
If defined, the MIDI controller can switch on/off the dimension in realtime.
Definition: gig.h:442
file_offset_t position
Current position within the sample.
Definition: gig.h:311
Encapsulates articulation informations of a dimension region.
Definition: gig.h:367
range_t DimensionKeyRange
0-127 (where 0 means C1 and 127 means G9)
Definition: gig.h:1092
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:425
bool reverse
If playback direction is currently backwards (in case there is a pingpong or reverse loop defined)...
Definition: gig.h:312
Only controlled by aftertouch controller.
Definition: gig.h:128
25 frames per second
Definition: gig.h:104
uint8_t AltSustain2Key
Key triggering a second set of alternate sustain samples.
Definition: gig.h:891
file_offset_t FrameOffset
Current offset (sample points) in current sample frame (for decompression only).
Definition: gig.h:678
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:680
Effect Controller 2 (Coarse, MIDI Controller 13)
Definition: gig.h:157
bool VCFEnabled
If filter should be used.
Definition: gig.h:419
Controlled internally and by external modulation wheel.
Definition: gig.h:129
Controlled internally and by aftertouch controller.
Definition: gig.h:130
Parses DLS Level 1 and 2 compliant files and provides abstract access to the data.
Definition: DLS.h:498
no SMPTE offset
Definition: gig.h:102
stream_whence_t
File stream position dependent to these relations.
Definition: RIFF.h:164
Soft Pedal (MIDI Controller 67)
Definition: gig.h:161
uint32_t FineTune
Specifies the fraction of a semitone up from the specified MIDI unity note field. A value of 0x800000...
Definition: gig.h:638
uint8_t BypassKey
Key to be used to bypass the sustain note.
Definition: gig.h:884
uint16_t LFO1ControlDepth
Controller depth influencing sample amplitude LFO pitch (0 - 1200 cents).
Definition: gig.h:387
file_offset_t SamplesPerFrame
For compressed samples only: number of samples in a full sample frame.
Definition: gig.h:683
lfo1_ctrl_t
Defines how LFO1 is controlled by.
Definition: gig.h:143
Group of Gigasampler samples.
Definition: gig.h:1157
uint8_t VCFVelocityDynamicRange
0x04 = lowest, 0x00 = highest .
Definition: gig.h:426
String Name
Stores the name of this Group.
Definition: gig.h:1159
Special dimension for triggering samples on releasing a key.
Definition: gig.h:230
uint16_t PitchbendRange
Number of semitones pitchbend controller can pitch (default is 2).
Definition: gig.h:1090
double EG1Release
Release time of the sample amplitude EG (0.000 - 60.000s).
Definition: gig.h:378
Only internally controlled.
Definition: gig.h:126
uint8_t Triggers
Number of triggers.
Definition: gig.h:842
vcf_type_t VCFType
Defines the general filter characteristic (lowpass, highpass, bandpass, etc.).
Definition: gig.h:420
Effect Controller 1 (Coarse, MIDI Controller 12)
Definition: gig.h:240
uint32_t LoopSize
Caution: Use the respective fields in the DimensionRegion instead of this one! (Intended purpose: Len...
Definition: gig.h:646
Controlled internally and by external modulation wheel.
Definition: gig.h:138
loop_type_t LoopType
Caution: Use the respective field in the DimensionRegion instead of this one! (Intended purpose: The ...
Definition: gig.h:643
lfo1_ctrl_t LFO1Controller
MIDI Controller which controls sample amplitude LFO.
Definition: gig.h:388
Effect 2 Depth (MIDI Controller 92)
Definition: gig.h:255
Effect Controller 1 (Coarse, MIDI Controller 12)
Definition: gig.h:156
Only internally controlled.
Definition: gig.h:135
uint8_t low
Low value of range.
Definition: gig.h:77
Modulation Wheel (MIDI Controller 1)
Definition: gig.h:236
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:451
MIDI rule for triggering notes by control change events.
Definition: gig.h:839
30 frames per second
Definition: gig.h:106
uint8_t Key
Key to trigger.
Definition: gig.h:847
file_offset_t WorstCaseFrameSize
For compressed samples only: size (in bytes) of the largest possible sample frame.
Definition: gig.h:682
file_offset_t Size
Size of the actual data in the buffer in bytes.
Definition: gig.h:84
bool EG1Hold
If true, Decay1 stage should be postponed until the sample reached the sample loop start...
Definition: gig.h:379
range_t PlayRange
Key range of the playable keys in the instrument.
Definition: gig.h:917
void UpdateChunks(uint8_t *pData) const
Definition: gig.h:968
uint16_t ThresholdTime
Maximum time (ms) between two notes that should be played legato.
Definition: gig.h:886
const uint8_t & operator[](int i) const
Definition: gig.h:923
RIFF::Chunk * pCk3gix
Definition: gig.h:686
static size_t Instances
Number of instances of class Sample.
Definition: gig.h:675
dimension values are already the sought bit number
Definition: gig.h:267
uint8_t VelocityResponseCurveScaling
0 - 127 (usually you don&#39;t have to interpret this parameter, use GetVelocityAttenuation() instead)...
Definition: gig.h:435
bool Descending
If the change in CC value should be downwards.
Definition: gig.h:845
Effect 1 Depth (MIDI Controller 91)
Definition: gig.h:254
Breath Controller (Coarse, MIDI Controller 2)
Definition: gig.h:158
uint8_t ReleaseTriggerKey
Key triggering release samples.
Definition: gig.h:889
For MIDI tools like legato and repetition mode.
Definition: gig.h:234
bool VCFKeyboardTracking
If true: VCF cutoff frequence will be dependend to the note key position relative to the defined brea...
Definition: gig.h:430
uint8_t Velocity
Velocity of the note to trigger. 255 means that velocity should depend on the speed of the controller...
Definition: gig.h:849
uint32_t crc
CRC-32 checksum of the raw sample data.
Definition: gig.h:688
Defines a controller that has a certain contrained influence on a particular synthesis parameter (use...
Definition: gig.h:184
uint8_t Controller
CC number for controller selector.
Definition: gig.h:940
Defines Region information of a Gigasampler/GigaStudio instrument.
Definition: gig.h:742
Only controlled by external modulation wheel.
Definition: gig.h:136
uint32_t LoopPlayCount
Number of times the loop should be played (a value of 0 = infinite).
Definition: gig.h:648
uint8_t ReleaseTriggerDecay
0 - 8
Definition: gig.h:438
lfo3_ctrl_t LFO3Controller
MIDI Controller which controls the sample pitch LFO.
Definition: gig.h:416
bool Chained
If all patterns should be chained together.
Definition: gig.h:943
uint32_t MIDIUnityNote
Specifies the musical note at which the sample will be played at it&#39;s original sample rate...
Definition: gig.h:637
int16_t FineTune
Definition: DLS.h:368
uint8_t ControllerNumber
MIDI controller number.
Definition: gig.h:841
Portamento (MIDI Controller 65)
Definition: gig.h:247
uint8_t ChannelOffset
Audio output where the audio signal of the dimension region should be routed to (0 - 9)...
Definition: gig.h:448
General Purpose Controller 6 (Button, MIDI Controller 81)
Definition: gig.h:251
uint8_t VCFResonance
Firm internal filter resonance weight.
Definition: gig.h:427
bool VCFResonanceDynamic
If true: Increases the resonance Q according to changes of controllers that actually control the VCF ...
Definition: gig.h:428
Language_t Language
Programming language and dialect the script is written in.
Definition: gig.h:1007
unsigned int Dimensions
Number of defined dimensions, do not alter!
Definition: gig.h:744
Only controlled by external modulation wheel.
Definition: gig.h:127
vcf_cutoff_ctrl_t VCFCutoffController
Specifies which external controller has influence on the filter cutoff frequency. ...
Definition: gig.h:421
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:313
uint16_t MIDIBank
Reflects combination of MIDIBankCoarse and MIDIBankFine (bank 1 - bank 16384). Do not change this val...
Definition: DLS.h:464
Foot Pedal (Coarse, MIDI Controller 4)
Definition: gig.h:159
double EG1Decay1
Decay time of the sample amplitude EG (0.000 - 60.000s).
Definition: gig.h:374
lfo2_ctrl_t LFO2Controller
MIDI Controlle which controls the filter cutoff LFO.
Definition: gig.h:407
Compression_t Compression
Whether the script was/should be compressed, and if so, which compression algorithm shall be used...
Definition: gig.h:1005
Different samples triggered each time a note is played, any key advances the counter.
Definition: gig.h:235
bool Dithered
For 24-bit compressed samples only: if dithering was used during compression with bit reduction...
Definition: gig.h:651
String libraryVersion()
Returns version of this C++ library.
Definition: gig.cpp:6132
uint8_t VelocityUpperLimit
Defines the upper velocity value limit of a velocity split (only if an user defined limit was set...
Definition: gig.h:369
uint8_t ReleaseVelocityResponseDepth
Dynamic range of release velocity affecting envelope time (0 - 4).
Definition: gig.h:437
Will be thrown whenever a gig specific error occurs while trying to access a Gigasampler File...
Definition: gig.h:1290
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:303
static const DLS::version_t VERSION_2
Reflects Gigasampler file format version 2.0 (1998-06-28).
Definition: gig.h:1213
Sample * pSample
Points to the Sample which is assigned to the dimension region.
Definition: gig.h:370
uint16_t ReleaseTime
Release time.
Definition: gig.h:887
smpte_format_t
Society of Motion Pictures and Television E time format.
Definition: gig.h:101
uint32_t LoopStart
Caution: Use the respective field in the DimensionRegion instead of this one! (Intended purpose: The ...
Definition: gig.h:644
Loop forward (normal)
Definition: gig.h:95
double EG2Decay1
Decay time of the filter cutoff EG (0.000 - 60.000s).
Definition: gig.h:394
uint8_t EG1ControllerAttackInfluence
Amount EG1 Controller has influence on the EG1 Attack time (0 - 3, where 0 means off).
Definition: gig.h:382
Only controlled by external foot controller.
Definition: gig.h:137
crossfade_t Crossfade
Definition: gig.h:440
Compression_t
Definition: gig.h:997
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:639
double SampleAttenuation
Sample volume (calculated from DLS::Sampler::Gain)
Definition: gig.h:452
lfo3_ctrl_t
Defines how LFO3 is controlled by.
Definition: gig.h:125
Channel Key Pressure.
Definition: gig.h:229
file_offset_t GuessSize(file_offset_t samples)
Definition: gig.h:694
RIFF List Chunk.
Definition: RIFF.h:293
Sustain Pedal (MIDI Controller 64)
Definition: gig.h:160
double EG1Decay2
Only if EG1InfiniteSustain == false: 2nd decay stage time of the sample amplitude EG (0...
Definition: gig.h:375
bool PianoReleaseMode
Definition: gig.h:1091
uint8_t BypassController
Controller to be used to bypass the sustain note.
Definition: gig.h:885
attenuation_ctrl_t AttenuationController
MIDI Controller which has influence on the volume level of the sample (or entire sample group)...
Definition: gig.h:445
static buffer_t InternalDecompressionBuffer
Buffer used for decompression as well as for truncation of 24 Bit -> 16 Bit samples.
Definition: gig.h:676
Pointer address and size of a buffer.
Definition: gig.h:82
uint8_t in_start
Start position of fade in.
Definition: gig.h:302
file_offset_t WorstCaseMaxSamples(buffer_t *pDecompressionBuffer)
Definition: gig.h:711
uint8_t Patterns
Number of alternator patterns.
Definition: gig.h:919
dimension_t dimension
Specifies which source (usually a MIDI controller) is associated with the dimension.
Definition: gig.h:272
bool Bypass
Global bypass: if enabled, this script shall not be executed by the sampler for any instrument...
Definition: gig.h:1008
Abstract base class which provides mandatory informations about sample players in general...
Definition: DLS.h:365
loop_type_t
Standard types of sample loops.
Definition: gig.h:94
range_t KeyRange
Key range for legato notes.
Definition: gig.h:888
Sustain Pedal (MIDI Controller 64)
Definition: gig.h:246
bool EG2ControllerInvert
Invert values coming from defined EG2 controller.
Definition: gig.h:400
uint8_t Articulations
Number of articulations in the instrument.
Definition: gig.h:914
buffer_t()
Definition: gig.h:86
uint8_t VelSensitivity
How sensitive the velocity should be to the speed of the controller change.
Definition: gig.h:846
String Name
Arbitrary name of the script, which may be displayed i.e. in an instrument editor.
Definition: gig.h:1004
uint32_t DimensionRegions
Total number of DimensionRegions this Region contains, do not alter!
Definition: gig.h:746
std::string String
Definition: gig.h:71
bool MSDecode
Gigastudio flag: defines if Mid Side Recordings should be decoded.
Definition: gig.h:450
Key Velocity (this is the only dimension in gig2 where the ranges can exactly be defined).
Definition: gig.h:228
bool EG1InfiniteSustain
If true, instead of going into Decay2 phase, Decay1 level will be hold until note will be released...
Definition: gig.h:376
bool Compressed
If the sample wave is compressed (probably just interesting for instrument and sample editors...
Definition: gig.h:649
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
General Purpose Controller 3 (Slider, MIDI Controller 18)
Definition: gig.h:244
uint32_t SampleLoops
Reflects the number of sample loops.
Definition: DLS.h:372
More poles than normal lowpass.
Definition: gig.h:282
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:405
uint16_t LFO1InternalDepth
Firm pitch of the sample amplitude LFO (0 - 1200 cents).
Definition: gig.h:386
The difference between none and none2 is unknown.
Definition: gig.h:154
Controlled internally and by external breath controller.
Definition: gig.h:148
float zone_size
Intended for internal usage: reflects the size of each zone (128/zones) for normal split types only...
Definition: gig.h:276
Only controlled by external breath controller.
Definition: gig.h:146
bool PitchTrack
If true: sample will be pitched according to the key position (this will be disabled for drums for ex...
Definition: gig.h:441
Encoding_t
Definition: gig.h:994
uint64_t file_offset_t
Type used by libgig for handling file positioning during file I/O tasks.
Definition: RIFF.h:147
bool BypassUseController
If a controller should be used to bypass the sustain note.
Definition: gig.h:883
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:748
void * pStart
Points to the beginning of the buffer.
Definition: gig.h:83
bool EG2InfiniteSustain
If true, instead of going into Decay2 phase, Decay1 level will be hold until note will be released...
Definition: gig.h:396
General Purpose Controller 4 (Slider, MIDI Controller 19)
Definition: gig.h:171
Group * pGroup
pointer to the Group this sample belongs to (always not-NULL)
Definition: gig.h:677
virtual ~MidiRule()
Definition: gig.h:820
Effect 4 Depth (MIDI Controller 94)
Definition: gig.h:257
Breath Controller (Coarse, MIDI Controller 2)
Definition: gig.h:237
uint8_t EG2ControllerAttackInfluence
Amount EG2 Controller has influence on the EG2 Attack time (0 - 3, where 0 means off).
Definition: gig.h:401
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:444
int16_t LFO3ControlDepth
Controller depth of the sample pitch LFO (-1200 - +1200 cents).
Definition: gig.h:415
RIFF::Chunk * pCkSmpl
Definition: gig.h:687
Only controlled by external modulation wheel.
Definition: gig.h:145
double EG3Attack
Attack time of the sample pitch EG (0.000 - 10.000s).
Definition: gig.h:411
uint8_t LegatoSamples
Number of legato samples per key in each direction (always 12)
Definition: gig.h:882
uint8_t out_end
End postition of fade out.
Definition: gig.h:305
double EG2Attack
Attack time of the filter cutoff EG (0.000 - 60.000s).
Definition: gig.h:393
bool InvertAttenuationController
Inverts the values coming from the defined Attenuation Controller.
Definition: gig.h:446
double LFO1Frequency
Frequency of the sample amplitude LFO (0.10 - 10.00 Hz).
Definition: gig.h:385
Ordinary RIFF Chunk.
Definition: RIFF.h:217
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:642
uint16_t EffectSend
Definition: gig.h:1088
bool LFO1FlipPhase
Inverts phase of the sample amplitude LFO wave.
Definition: gig.h:389
uint8_t AltSustain1Key
Key triggering alternate sustain samples.
Definition: gig.h:890
int16_t FineTune
in cents
Definition: gig.h:1089
uint8_t UnityNote
Definition: DLS.h:367
Effect 5 Depth (MIDI Controller 95)
Definition: gig.h:258
bool LFO3Sync
If set to true only one LFO should be used for all voices.
Definition: gig.h:417
uint32_t MIDIProgram
Specifies the MIDI Program Change Number this Instrument should be assigned to.
Definition: DLS.h:467
double LFO3Frequency
Frequency of the sample pitch LFO (0.10 - 10.00 Hz).
Definition: gig.h:413
static const DLS::version_t VERSION_3
Reflects Gigasampler file format version 3.0 (2003-03-31).
Definition: gig.h:1214
Soft Pedal (MIDI Controller 67)
Definition: gig.h:249
uint32_t Product
Specifies the MIDI model ID defined by the manufacturer corresponding to the Manufacturer field...
Definition: gig.h:635
bool LFO1Sync
If set to true only one LFO should be used for all voices.
Definition: gig.h:390
split_type_t
Intended for internal usage: will be used to convert a dimension value into the corresponding dimensi...
Definition: gig.h:265
Alternating loop (forward/backward, also known as Ping Pong)
Definition: gig.h:96
leverage_ctrl_t eg2_ctrl_t
Defines controller influencing envelope generator 2.
Definition: gig.h:215
uint8_t EG2ControllerReleaseInfluence
Amount EG2 Controller has influence on the EG2 Release time (0 - 3, where 0 means off)...
Definition: gig.h:403
Used for indicating the progress of a certain task.
Definition: RIFF.h:203
uint16_t EG2PreAttack
Preattack value of the filter cutoff EG (0 - 1000 permille).
Definition: gig.h:392
leverage_ctrl_t attenuation_ctrl_t
Defines controller influencing attenuation.
Definition: gig.h:201
uint32_t Loops
Caution: Use the respective field in the DimensionRegion instead of this one! (Intended purpose: Numb...
Definition: gig.h:641
String Name
Name of the pattern.
Definition: gig.h:921
bool LFO2Sync
If set to true only one LFO should be used for all voices.
Definition: gig.h:409
uint32_t SMPTEOffset
The SMPTE Offset value specifies the time offset to be used for the synchronization / calibration to ...
Definition: gig.h:640
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:685
bool EG1ControllerInvert
Invert values coming from defined EG1 controller.
Definition: gig.h:381
30 frames per second with frame dropping (30 drop)
Definition: gig.h:105
vcf_res_ctrl_t
Defines how the filter resonance is controlled by.
Definition: gig.h:168
vcf_type_t
Defines which frequencies are filtered by the VCF.
Definition: gig.h:280
General Purpose Controller 5 (Button, MIDI Controller 80)
Definition: gig.h:250
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:406
String Name
Name of this script group. For example to be displayed in an instrument editor.
Definition: gig.h:1041
file_offset_t * FrameTable
For positioning within compressed samples only: stores the offset values for each frame...
Definition: gig.h:679
Loop backward (reverse)
Definition: gig.h:97
int16_t EG3Depth
Depth of the sample pitch EG (-1200 - +1200).
Definition: gig.h:412
uint8_t VCFKeyboardTrackingBreakpoint
See VCFKeyboardTracking (0 - 127).
Definition: gig.h:431
eg2_ctrl_t EG2Controller
MIDI Controller which has influence on filter cutoff EG parameters (attack, decay, release).
Definition: gig.h:399
For layering of up to 8 instruments (and eventually crossfading of 2 or 4 layers).
Definition: gig.h:227
bool VCFCutoffControllerInvert
Inverts values coming from the defined cutoff controller.
Definition: gig.h:422
General Purpose Controller 7 (Button, MIDI Controller 82)
Definition: gig.h:162
Controlled internally and by external foot controller.
Definition: gig.h:139
Different samples triggered each time a note is played, random order.
Definition: gig.h:233
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:85
double EG2Release
Release time of the filter cutoff EG (0.000 - 60.000s).
Definition: gig.h:398
uint8_t EG1ControllerReleaseInfluence
Amount EG1 Controller has influence on the EG1 Release time (0 - 3, where 0 means off)...
Definition: gig.h:384
uint8_t EG2ControllerDecayInfluence
Amount EG2 Controller has influence on the EG2 Decay time (0 - 3, where 0 means off).
Definition: gig.h:402
bool Polyphonic
If alternator should step forward only when all notes are off.
Definition: gig.h:942
Abstract base class for all MIDI rules.
Definition: gig.h:818
General Purpose Controller 2 (Slider, MIDI Controller 17)
Definition: gig.h:243
dimension_t
Defines the type of dimension, that is how the dimension zones (and thus how the dimension regions ar...
Definition: gig.h:224
file_offset_t SamplesInLastFrame
For compressed samples only: length of the last sample frame.
Definition: gig.h:681
uint32_t LoopEnd
Caution: Use the respective field in the DimensionRegion instead of this one! (Intended purpose: The ...
Definition: gig.h:645
Defines the envelope of a crossfade.
Definition: gig.h:295
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:436
Different samples triggered each time a note is played, dimension regions selected in sequence...
Definition: gig.h:232
uint8_t zones
Number of zones the dimension has.
Definition: gig.h:274
Effect 5 Depth (MIDI Controller 95)
Definition: gig.h:121
General Purpose Controller 3 (Slider, MIDI Controller 18)
Definition: gig.h:170
uint8_t & operator[](int i)
Definition: gig.h:926
General Purpose Controller 8 (Button, MIDI Controller 83)
Definition: gig.h:163
uint8_t AttenuationControllerThreshold
0-127
Definition: gig.h:447
vcf_cutoff_ctrl_t
Defines how the filter cutoff frequency is controlled by.
Definition: gig.h:152
Encapsulates sample waves of Gigasampler/GigaStudio files used for playback.
Definition: gig.h:632
RIFF File.
Definition: RIFF.h:343
General Purpose Controller 8 (Button, MIDI Controller 83)
Definition: gig.h:253
dimension value between 0-127
Definition: gig.h:266
24 frames per second
Definition: gig.h:103
Modulation Wheel (MIDI Controller 1)
Definition: gig.h:155
int16_t LFO3InternalDepth
Firm depth of the sample pitch LFO (-1200 - +1200 cents).
Definition: gig.h:414
General Purpose Controller 5 (Button, MIDI Controller 80)
Definition: gig.h:172
Lower and upper limit of a range.
Definition: gig.h:76
General Purpose Controller 1 (Slider, MIDI Controller 16)
Definition: gig.h:242
double EG2Decay2
Only if EG2InfiniteSustain == false: 2nd stage decay time of the filter cutoff EG (0...
Definition: gig.h:395
Portamento Time (Coarse, MIDI Controller 5)
Definition: gig.h:239
int32_t Attenuation
in dB
Definition: gig.h:1087
Encapsulates sample waves used for playback.
Definition: DLS.h:396
type_t type
Controller type.
Definition: gig.h:192
uint controller_number
MIDI controller number if this controller is a control change controller, 0 otherwise.
Definition: gig.h:193
uint8_t * VelocityTable
For velocity dimensions with custom defined zone ranges only: used for fast converting from velocity ...
Definition: gig.h:484
curve_type_t VelocityResponseCurve
Defines a transformation curve to the incoming velocity values affecting amplitude (usually you don&#39;t...
Definition: gig.h:433
Effect Controller 2 (Coarse, MIDI Controller 13)
Definition: gig.h:241
A MIDI rule not yet implemented by libgig.
Definition: gig.h:965
Foot Pedal (Coarse, MIDI Controller 4)
Definition: gig.h:238
uint16_t EG1Sustain
Sustain value of the sample amplitude EG (0 - 1000 permille).
Definition: gig.h:377
String GetFileName()
File name of this DLS file.
Definition: DLS.cpp:1678
Real-time instrument script (gig format extension).
Definition: gig.h:992
General Purpose Controller 6 (Button, MIDI Controller 81)
Definition: gig.h:173
Gigasampler/GigaStudio specific classes and definitions.
Definition: gig.h:69
uint8_t TriggerPoint
The CC value to pass for the note to be triggered.
Definition: gig.h:844
uint8_t VelocityResponseDepth
Dynamic range of velocity affecting amplitude (0 - 4) (usually you don&#39;t have to interpret this param...
Definition: gig.h:434
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:647
RIFF::progress_t progress_t
Definition: gig.h:72
uint32_t TruncatedBits
For 24-bit compressed samples only: number of bits truncated during compression (0, 4 or 6)
Definition: gig.h:650
Resource * GetParent()
Definition: DLS.h:351
Group of instrument scripts (gig format extension).
Definition: gig.h:1039
Language_t
Definition: gig.h:1000
int8_t Pan
Panorama / Balance (-64..0..63 <-> left..middle..right)
Definition: gig.h:443
Provides convenient access to Gigasampler/GigaStudio .gig files.
Definition: gig.h:1211
Only internally controlled.
Definition: gig.h:144
lfo2_ctrl_t
Defines how LFO2 is controlled by.
Definition: gig.h:134
Effect 3 Depth (MIDI Controller 93)
Definition: gig.h:256
Dimension for keyswitching.
Definition: gig.h:231
MIDI rule for instruments with legato samples.
Definition: gig.h:880
RIFF::file_offset_t file_offset_t
Definition: gig.h:73
leverage_ctrl_t eg1_ctrl_t
Defines controller influencing envelope generator 1.
Definition: gig.h:208
uint16_t EG2Sustain
Sustain value of the filter cutoff EG (0 - 1000 permille).
Definition: gig.h:397
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:1074
bool SustainDefeat
If true: Sustain pedal will not hold a note.
Definition: gig.h:449
Encoding_t Encoding
Format the script&#39;s source code text is encoded with.
Definition: gig.h:1006
buffer_t RAMCache
Buffers samples (already uncompressed) in RAM.
Definition: gig.h:684
bool NoteOff
If a note off should be triggered instead of a note on.
Definition: gig.h:848
String libraryName()
Returns the name of this C++ library.
Definition: gig.cpp:6124
int32_t Gain
Definition: DLS.h:369
Controlled internally and by external modulation wheel.
Definition: gig.h:147
Quadtuple version number ("major.minor.release.build").
Definition: DLS.h:111
double LFO2Frequency
Frequency of the filter cutoff LFO (0.10 - 10.00 Hz).
Definition: gig.h:404
uint32_t SamplePeriod
Specifies the duration of time that passes during the playback of one sample in nanoseconds (normally...
Definition: gig.h:636
uint16_t EG1PreAttack
Preattack value of the sample amplitude EG (0 - 1000 permille).
Definition: gig.h:372
Dimension not in use.
Definition: gig.h:225
curve_type_t
Defines the shape of a function graph.
Definition: gig.h:110
uint8_t bits
Number of "bits" (1 bit = 2 splits/zones, 2 bit = 4 splits/zones, 3 bit = 8 splits/zones,...).
Definition: gig.h:273
selector_t Selector
Method by which pattern is chosen.
Definition: gig.h:938
uint8_t out_start
Start position of fade out.
Definition: gig.h:304
uint8_t VCFCutoff
Max. cutoff frequency.
Definition: gig.h:423
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:634
uint8_t high
High value of range.
Definition: gig.h:78
bool OverridePedal
If a note off should be triggered even if the sustain pedal is down.
Definition: gig.h:850
MIDI rule to automatically cycle through specified sequences of different articulations.
Definition: gig.h:912
Reflects the current playback state for a sample.
Definition: gig.h:310
General dimension definition.
Definition: gig.h:271
int Size
Number of steps in the pattern.
Definition: gig.h:922
eg1_ctrl_t EG1Controller
MIDI Controller which has influence on sample amplitude EG parameters (attack, decay, release).
Definition: gig.h:380
Sostenuto Pedal (MIDI Controller 66)
Definition: gig.h:248
split_type_t split_type
Intended for internal usage: will be used to convert a dimension value into the corresponding dimensi...
Definition: gig.h:275
If used sample has more than one channel (thus is not mono).
Definition: gig.h:226
dim_bypass_ctrl_t
Dimensions allow to bypass one of the following controllers.
Definition: gig.h:118
vcf_res_ctrl_t VCFResonanceController
Specifies which external controller has influence on the filter resonance Q.
Definition: gig.h:429
curve_type_t VCFVelocityCurve
Defines a transformation curve for the incoming velocity values, affecting the VCF.
Definition: gig.h:424
uint8_t EG1ControllerDecayInfluence
Amount EG1 Controller has influence on the EG1 Decay time (0 - 3, where 0 means off).
Definition: gig.h:383
Defines Region information of an Instrument.
Definition: DLS.h:431
Effect 4 Depth (MIDI Controller 94)
Definition: gig.h:120
General Purpose Controller 7 (Button, MIDI Controller 82)
Definition: gig.h:252
double EG1Attack
Attack time of the sample amplitude EG (0.000 - 60.000s).
Definition: gig.h:373
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