libgig  3.3.0.19svn2660
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-2014 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;
72 
74  struct range_t {
75  uint8_t low;
76  uint8_t high;
77  };
78 
80  struct buffer_t {
81  void* pStart;
82  unsigned long Size;
83  unsigned long NullExtensionSize;
85  pStart = NULL;
86  Size = 0;
88  }
89  };
90 
92  typedef enum {
93  loop_type_normal = 0x00000000,
94  loop_type_bidirectional = 0x00000001,
95  loop_type_backward = 0x00000002
96  } loop_type_t;
97 
99  typedef enum {
100  smpte_format_no_offset = 0x00000000,
101  smpte_format_24_frames = 0x00000018,
102  smpte_format_25_frames = 0x00000019,
105  } smpte_format_t;
106 
108  typedef enum {
112  curve_type_unknown = 0xffffffff
113  } curve_type_t;
114 
116  typedef enum {
121 
123  typedef enum {
129  } lfo3_ctrl_t;
130 
132  typedef enum {
135  lfo2_ctrl_foot = 0x02,
138  } lfo2_ctrl_t;
139 
141  typedef enum {
147  } lfo1_ctrl_t;
148 
150  typedef enum {
164 
166  typedef enum {
167  vcf_res_ctrl_none = 0xffffffff,
172  } vcf_res_ctrl_t;
173 
183  typedef enum {
184  type_none = 0x00,
186  type_velocity = 0xff,
188  } type_t;
189 
192  };
193 
200 
207 
214 
222  typedef enum {
223  dimension_none = 0x00,
236  dimension_foot = 0x04,
257  } dimension_t;
258 
263  typedef enum {
266  } split_type_t;
267 
271  uint8_t bits;
272  uint8_t zones;
274  float zone_size;
275  };
276 
278  typedef enum {
284  } vcf_type_t;
285 
293  struct crossfade_t {
294  #if WORDS_BIGENDIAN
295  uint8_t out_end;
296  uint8_t out_start;
297  uint8_t in_end;
298  uint8_t in_start;
299  #else // little endian
300  uint8_t in_start;
301  uint8_t in_end;
302  uint8_t out_start;
303  uint8_t out_end;
304  #endif // WORDS_BIGENDIAN
305  };
306 
309  unsigned long position;
310  bool reverse;
311  unsigned long loop_cycles_left;
312  };
313 
326  struct progress_t {
327  void (*callback)(progress_t*);
328  float factor;
329  void* custom;
330  float __range_min;
331  float __range_max;
332  progress_t();
333  };
334 
335  // just symbol prototyping
336  class File;
337  class Instrument;
338  class Sample;
339  class Region;
340  class Group;
341  class Script;
342  class ScriptGroup;
343 
356  class DimensionRegion : protected DLS::Sampler {
357  public:
360  // Sample Amplitude EG/LFO
361  uint16_t EG1PreAttack;
362  double EG1Attack;
363  double EG1Decay1;
364  double EG1Decay2;
366  uint16_t EG1Sustain;
367  double EG1Release;
368  bool EG1Hold;
374  double LFO1Frequency;
375  uint16_t LFO1InternalDepth;
376  uint16_t LFO1ControlDepth;
379  bool LFO1Sync;
380  // Filter Cutoff Frequency EG/LFO
381  uint16_t EG2PreAttack;
382  double EG2Attack;
383  double EG2Decay1;
384  double EG2Decay2;
386  uint16_t EG2Sustain;
387  double EG2Release;
393  double LFO2Frequency;
394  uint16_t LFO2InternalDepth;
395  uint16_t LFO2ControlDepth;
398  bool LFO2Sync;
399  // Sample Pitch EG/LFO
400  double EG3Attack;
401  int16_t EG3Depth;
402  double LFO3Frequency;
406  bool LFO3Sync;
407  // Filter
408  bool VCFEnabled;
412  uint8_t VCFCutoff;
416  uint8_t VCFResonance;
421  // Key Velocity Transformations
428  // Mix / Layer
430  bool PitchTrack;
432  int8_t Pan;
433  bool SelfMask;
437  uint8_t ChannelOffset;
439  bool MSDecode;
440  uint16_t SampleStartOffset;
442  uint8_t DimensionUpperLimits[8];
443 
444  // derived attributes from DLS::Sampler
447  using DLS::Sampler::Gain;
450 
451  // own methods
452  double GetVelocityAttenuation(uint8_t MIDIKeyVelocity);
453  double GetVelocityRelease(uint8_t MIDIKeyVelocity);
454  double GetVelocityCutoff(uint8_t MIDIKeyVelocity);
456  void SetVelocityResponseDepth(uint8_t depth);
457  void SetVelocityResponseCurveScaling(uint8_t scaling);
459  void SetReleaseVelocityResponseDepth(uint8_t depth);
460  void SetVCFCutoffController(vcf_cutoff_ctrl_t controller);
461  void SetVCFVelocityCurve(curve_type_t curve);
462  void SetVCFVelocityDynamicRange(uint8_t range);
463  void SetVCFVelocityScale(uint8_t scaling);
464  Region* GetParent() const;
465  // derived methods
468  // overridden methods
469  virtual void SetGain(int32_t gain);
470  virtual void UpdateChunks();
471  virtual void CopyAssign(const DimensionRegion* orig);
472  protected:
473  uint8_t* VelocityTable;
474  DimensionRegion(Region* pParent, RIFF::List* _3ewl);
475  DimensionRegion(RIFF::List* _3ewl, const DimensionRegion& src);
477  void CopyAssign(const DimensionRegion* orig, const std::map<Sample*,Sample*>* mSamples);
478  friend class Region;
479  private:
480  typedef enum {
481  // official leverage controllers as they were defined in the original Gigasampler/GigaStudio format:
482  _lev_ctrl_none = 0x00,
483  _lev_ctrl_modwheel = 0x03,
484  _lev_ctrl_breath = 0x05,
485  _lev_ctrl_foot = 0x07,
486  _lev_ctrl_effect1 = 0x0d,
487  _lev_ctrl_effect2 = 0x0f,
488  _lev_ctrl_genpurpose1 = 0x11,
489  _lev_ctrl_genpurpose2 = 0x13,
490  _lev_ctrl_genpurpose3 = 0x15,
491  _lev_ctrl_genpurpose4 = 0x17,
492  _lev_ctrl_portamentotime = 0x0b,
493  _lev_ctrl_sustainpedal = 0x01,
494  _lev_ctrl_portamento = 0x19,
495  _lev_ctrl_sostenutopedal = 0x1b,
496  _lev_ctrl_softpedal = 0x09,
497  _lev_ctrl_genpurpose5 = 0x1d,
498  _lev_ctrl_genpurpose6 = 0x1f,
499  _lev_ctrl_genpurpose7 = 0x21,
500  _lev_ctrl_genpurpose8 = 0x23,
501  _lev_ctrl_effect1depth = 0x25,
502  _lev_ctrl_effect2depth = 0x27,
503  _lev_ctrl_effect3depth = 0x29,
504  _lev_ctrl_effect4depth = 0x2b,
505  _lev_ctrl_effect5depth = 0x2d,
506  _lev_ctrl_channelaftertouch = 0x2f,
507  _lev_ctrl_velocity = 0xff,
508 
509  // format extension (these controllers are so far only supported by LinuxSampler & gigedit) they will *NOT* work with Gigasampler/GigaStudio !
510  // (the assigned values here are their official MIDI CC number plus the highest bit set):
511  _lev_ctrl_CC3_EXT = 0x83,
512 
513  _lev_ctrl_CC6_EXT = 0x86,
514  _lev_ctrl_CC7_EXT = 0x87,
515  _lev_ctrl_CC8_EXT = 0x88,
516  _lev_ctrl_CC9_EXT = 0x89,
517  _lev_ctrl_CC10_EXT = 0x8a,
518  _lev_ctrl_CC11_EXT = 0x8b,
519 
520  _lev_ctrl_CC14_EXT = 0x8e,
521  _lev_ctrl_CC15_EXT = 0x8f,
522 
523  _lev_ctrl_CC20_EXT = 0x94,
524  _lev_ctrl_CC21_EXT = 0x95,
525  _lev_ctrl_CC22_EXT = 0x96,
526  _lev_ctrl_CC23_EXT = 0x97,
527  _lev_ctrl_CC24_EXT = 0x98,
528  _lev_ctrl_CC25_EXT = 0x99,
529  _lev_ctrl_CC26_EXT = 0x9a,
530  _lev_ctrl_CC27_EXT = 0x9b,
531  _lev_ctrl_CC28_EXT = 0x9c,
532  _lev_ctrl_CC29_EXT = 0x9d,
533  _lev_ctrl_CC30_EXT = 0x9e,
534  _lev_ctrl_CC31_EXT = 0x9f,
535 
536  _lev_ctrl_CC68_EXT = 0xc4,
537  _lev_ctrl_CC69_EXT = 0xc5,
538  _lev_ctrl_CC70_EXT = 0xc6,
539  _lev_ctrl_CC71_EXT = 0xc7,
540  _lev_ctrl_CC72_EXT = 0xc8,
541  _lev_ctrl_CC73_EXT = 0xc9,
542  _lev_ctrl_CC74_EXT = 0xca,
543  _lev_ctrl_CC75_EXT = 0xcb,
544  _lev_ctrl_CC76_EXT = 0xcc,
545  _lev_ctrl_CC77_EXT = 0xcd,
546  _lev_ctrl_CC78_EXT = 0xce,
547  _lev_ctrl_CC79_EXT = 0xcf,
548 
549  _lev_ctrl_CC84_EXT = 0xd4,
550  _lev_ctrl_CC85_EXT = 0xd5,
551  _lev_ctrl_CC86_EXT = 0xd6,
552  _lev_ctrl_CC87_EXT = 0xd7,
553 
554  _lev_ctrl_CC89_EXT = 0xd9,
555  _lev_ctrl_CC90_EXT = 0xda,
556 
557  _lev_ctrl_CC96_EXT = 0xe0,
558  _lev_ctrl_CC97_EXT = 0xe1,
559 
560  _lev_ctrl_CC102_EXT = 0xe6,
561  _lev_ctrl_CC103_EXT = 0xe7,
562  _lev_ctrl_CC104_EXT = 0xe8,
563  _lev_ctrl_CC105_EXT = 0xe9,
564  _lev_ctrl_CC106_EXT = 0xea,
565  _lev_ctrl_CC107_EXT = 0xeb,
566  _lev_ctrl_CC108_EXT = 0xec,
567  _lev_ctrl_CC109_EXT = 0xed,
568  _lev_ctrl_CC110_EXT = 0xee,
569  _lev_ctrl_CC111_EXT = 0xef,
570  _lev_ctrl_CC112_EXT = 0xf0,
571  _lev_ctrl_CC113_EXT = 0xf1,
572  _lev_ctrl_CC114_EXT = 0xf2,
573  _lev_ctrl_CC115_EXT = 0xf3,
574  _lev_ctrl_CC116_EXT = 0xf4,
575  _lev_ctrl_CC117_EXT = 0xf5,
576  _lev_ctrl_CC118_EXT = 0xf6,
577  _lev_ctrl_CC119_EXT = 0xf7
578  } _lev_ctrl_t;
579  typedef std::map<uint32_t, double*> VelocityTableMap;
580 
581  static uint Instances;
582  static VelocityTableMap* pVelocityTables;
583  double* pVelocityAttenuationTable;
584  double* pVelocityReleaseTable;
585  double* pVelocityCutoffTable;
586  Region* pRegion;
587 
588  leverage_ctrl_t DecodeLeverageController(_lev_ctrl_t EncodedController);
589  _lev_ctrl_t EncodeLeverageController(leverage_ctrl_t DecodedController);
590  double* GetReleaseVelocityTable(curve_type_t releaseVelocityResponseCurve, uint8_t releaseVelocityResponseDepth);
591  double* GetCutoffVelocityTable(curve_type_t vcfVelocityCurve, uint8_t vcfVelocityDynamicRange, uint8_t vcfVelocityScale, vcf_cutoff_ctrl_t vcfCutoffController);
592  double* GetVelocityTable(curve_type_t curveType, uint8_t depth, uint8_t scaling);
593  double* CreateVelocityTable(curve_type_t curveType, uint8_t depth, uint8_t scaling);
594  };
595 
611  class Sample : public DLS::Sample {
612  public:
613  uint32_t Manufacturer;
614  uint32_t Product;
615  uint32_t SamplePeriod;
616  uint32_t MIDIUnityNote;
617  uint32_t FineTune;
619  uint32_t SMPTEOffset;
620  uint32_t Loops;
621  uint32_t LoopID;
623  uint32_t LoopStart;
624  uint32_t LoopEnd;
625  uint32_t LoopSize;
626  uint32_t LoopFraction;
627  uint32_t LoopPlayCount;
628  bool Compressed;
629  uint32_t TruncatedBits;
630  bool Dithered;
631 
632  // own methods
634  buffer_t LoadSampleData(unsigned long SampleCount);
635  buffer_t LoadSampleDataWithNullSamplesExtension(uint NullSamplesCount);
636  buffer_t LoadSampleDataWithNullSamplesExtension(unsigned long SampleCount, uint NullSamplesCount);
637  buffer_t GetCache();
638  // own static methods
639  static buffer_t CreateDecompressionBuffer(unsigned long MaxReadSize);
640  static void DestroyDecompressionBuffer(buffer_t& DecompressionBuffer);
641  // overridden methods
642  void ReleaseSampleData();
643  void Resize(int iNewSize);
644  unsigned long SetPos(unsigned long SampleCount, RIFF::stream_whence_t Whence = RIFF::stream_start);
645  unsigned long GetPos() const;
646  unsigned long Read(void* pBuffer, unsigned long SampleCount, buffer_t* pExternalDecompressionBuffer = NULL);
647  unsigned long ReadAndLoop(void* pBuffer, unsigned long SampleCount, playback_state_t* pPlaybackState, DimensionRegion* pDimRgn, buffer_t* pExternalDecompressionBuffer = NULL);
648  unsigned long Write(void* pBuffer, unsigned long SampleCount);
649  Group* GetGroup() const;
650  virtual void UpdateChunks();
651  void CopyAssignMeta(const Sample* orig);
652  void CopyAssignWave(const Sample* orig);
653  protected:
654  static unsigned int Instances;
657  unsigned long FrameOffset;
658  unsigned long* FrameTable;
659  unsigned long SamplePos;
660  unsigned long SamplesInLastFrame;
661  unsigned long WorstCaseFrameSize;
662  unsigned long SamplesPerFrame;
664  unsigned long FileNo;
667  uint32_t crc;
668 
669  Sample(File* pFile, RIFF::List* waveList, unsigned long WavePoolOffset, unsigned long fileNo = 0);
670  ~Sample();
671 
672  // Guess size (in bytes) of a compressed sample
673  inline unsigned long GuessSize(unsigned long samples) {
674  // 16 bit: assume all frames are compressed - 1 byte
675  // per sample and 5 bytes header per 2048 samples
676 
677  // 24 bit: assume next best compression rate - 1.5
678  // bytes per sample and 13 bytes header per 256
679  // samples
680  const unsigned long size =
681  BitDepth == 24 ? samples + (samples >> 1) + (samples >> 8) * 13
682  : samples + (samples >> 10) * 5;
683  // Double for stereo and add one worst case sample
684  // frame
685  return (Channels == 2 ? size << 1 : size) + WorstCaseFrameSize;
686  }
687 
688  // Worst case amount of sample points that can be read with the
689  // given decompression buffer.
690  inline unsigned long WorstCaseMaxSamples(buffer_t* pDecompressionBuffer) {
691  return (unsigned long) ((float)pDecompressionBuffer->Size / (float)WorstCaseFrameSize * (float)SamplesPerFrame);
692  }
693  private:
694  void ScanCompressedSample();
695  friend class File;
696  friend class Region;
697  friend class Group; // allow to modify protected member pGroup
698  };
699 
700  // TODO: <3dnl> list not used yet - not important though (just contains optional descriptions for the dimensions)
717  class Region : public DLS::Region {
718  public:
719  unsigned int Dimensions;
721  uint32_t DimensionRegions;
723  unsigned int Layers;
724 
725  // own methods
726  DimensionRegion* GetDimensionRegionByValue(const uint DimValues[8]);
727  DimensionRegion* GetDimensionRegionByBit(const uint8_t DimBits[8]);
728  int GetDimensionRegionIndexByValue(const uint DimValues[8]);
729  Sample* GetSample();
730  void AddDimension(dimension_def_t* pDimDef);
731  void DeleteDimension(dimension_def_t* pDimDef);
733  void DeleteDimensionZone(dimension_t type, int zone);
734  void SplitDimensionZone(dimension_t type, int zone);
735  void SetDimensionType(dimension_t oldType, dimension_t newType);
736  // overridden methods
737  virtual void SetKeyRange(uint16_t Low, uint16_t High);
738  virtual void UpdateChunks();
739  virtual void CopyAssign(const Region* orig);
740  protected:
741  Region(Instrument* pInstrument, RIFF::List* rgnList);
742  void LoadDimensionRegions(RIFF::List* rgn);
743  void UpdateVelocityTable();
744  Sample* GetSampleFromWavePool(unsigned int WavePoolTableIndex, progress_t* pProgress = NULL);
745  void CopyAssign(const Region* orig, const std::map<Sample*,Sample*>* mSamples);
746  DimensionRegion* GetDimensionRegionByBit(const std::map<dimension_t,int>& DimCase);
747  ~Region();
748  friend class Instrument;
749  };
750 
752  class MidiRule {
753  public:
754  virtual ~MidiRule() { }
755  protected:
756  virtual void UpdateChunks(uint8_t* pData) const = 0;
757  friend class Instrument;
758  };
759 
761  class MidiRuleCtrlTrigger : public MidiRule {
762  public:
764  uint8_t Triggers;
765  struct trigger_t {
766  uint8_t TriggerPoint;
767  bool Descending;
768  uint8_t VelSensitivity;
769  uint8_t Key;
770  bool NoteOff;
771  uint8_t Velocity;
773  } pTriggers[32];
774 
775  protected:
778  void UpdateChunks(uint8_t* pData) const;
779  friend class Instrument;
780  };
781 
783  class MidiRuleLegato : public MidiRule {
784  public:
785  uint8_t LegatoSamples;
787  uint8_t BypassKey;
789  uint16_t ThresholdTime;
790  uint16_t ReleaseTime;
793  uint8_t AltSustain1Key;
794  uint8_t AltSustain2Key;
795 
796  protected:
797  MidiRuleLegato(RIFF::Chunk* _3ewg);
798  MidiRuleLegato();
799  void UpdateChunks(uint8_t* pData) const;
800  friend class Instrument;
801  };
802 
804  class MidiRuleAlternator : public MidiRule {
805  public:
806  uint8_t Articulations;
808 
810 
811  uint8_t Patterns;
812  struct pattern_t {
814  int Size;
815  const uint8_t& operator[](int i) const {
816  return data[i];
817  }
818  uint8_t& operator[](int i) {
819  return data[i];
820  }
821  private:
822  uint8_t data[32];
823  } pPatterns[32];
824 
825  typedef enum {
829  } selector_t;
832  uint8_t Controller;
833 
834  bool Polyphonic;
835  bool Chained;
836 
837  protected:
840  void UpdateChunks(uint8_t* pData) const;
841  friend class Instrument;
842  };
843 
845  class MidiRuleUnknown : public MidiRule {
846  protected:
848  void UpdateChunks(uint8_t* pData) const { }
849  friend class Instrument;
850  };
851 
863  class Script {
864  public:
865  enum Encoding_t {
867  };
870  };
871  enum Language_t {
873  };
874 
879  bool Bypass;
880 
882  void SetScriptAsText(const String& text);
883  void SetGroup(ScriptGroup* pGroup);
884  ScriptGroup* GetGroup() const;
885  protected:
886  Script(ScriptGroup* group, RIFF::Chunk* ckScri);
887  virtual ~Script();
888  void UpdateChunks();
890  friend class ScriptGroup;
891  friend class Instrument;
892  private:
893  ScriptGroup* pGroup;
894  RIFF::Chunk* pChunk;
895  std::vector<uint8_t> data;
896  uint32_t crc;
897  };
898 
910  class ScriptGroup {
911  public:
913 
914  Script* GetScript(uint index);
915  Script* AddScript();
916  void DeleteScript(Script* pScript);
917  protected:
918  ScriptGroup(File* file, RIFF::List* lstRTIS);
919  virtual ~ScriptGroup();
920  void LoadScripts();
921  void UpdateChunks();
922  friend class Script;
923  friend class File;
924  private:
925  File* pFile;
926  RIFF::List* pList;
927  std::list<Script*>* pScripts;
928  };
929 
931  class Instrument : protected DLS::Instrument {
932  public:
933  // derived attributes from DLS::Resource
934  using DLS::Resource::pInfo;
935  using DLS::Resource::pDLSID;
936  // derived attributes from DLS::Instrument
943  // own attributes
944  int32_t Attenuation;
945  uint16_t EffectSend;
946  int16_t FineTune;
947  uint16_t PitchbendRange;
950 
951 
952  // derived methods from DLS::Resource
954  // overridden methods
957  Region* AddRegion();
958  void DeleteRegion(Region* pRegion);
959  virtual void UpdateChunks();
960  virtual void CopyAssign(const Instrument* orig);
961  // own methods
962  Region* GetRegion(unsigned int Key);
963  MidiRule* GetMidiRule(int i);
967  void DeleteMidiRule(int i);
968  // real-time instrument script methods
969  Script* GetScriptOfSlot(uint index);
970  void AddScriptSlot(Script* pScript, bool bypass = false);
971  void SwapScriptSlots(uint index1, uint index2);
972  void RemoveScriptSlot(uint index);
973  void RemoveScript(Script* pScript);
974  uint ScriptSlotCount() const;
975  bool IsScriptSlotBypassed(uint index);
976  void SetScriptSlotBypassed(uint index, bool bBypass);
977  protected:
979 
980  Instrument(File* pFile, RIFF::List* insList, progress_t* pProgress = NULL);
981  ~Instrument();
982  void CopyAssign(const Instrument* orig, const std::map<Sample*,Sample*>* mSamples);
983  void UpdateRegionKeyTable();
984  void LoadScripts();
986  friend class File;
987  friend class Region; // so Region can call UpdateRegionKeyTable()
988  private:
989  struct _ScriptPooolEntry {
990  uint32_t fileOffset;
991  bool bypass;
992  };
993  struct _ScriptPooolRef {
994  Script* script;
995  bool bypass;
996  };
997  MidiRule** pMidiRules;
998  std::vector<_ScriptPooolEntry> scriptPoolFileOffsets;
999  std::vector<_ScriptPooolRef>* pScriptRefs;
1000  };
1001 
1017  class Group {
1018  public:
1020 
1022  Sample* GetNextSample();
1023  void AddSample(Sample* pSample);
1024  protected:
1025  Group(File* file, RIFF::Chunk* ck3gnm);
1026  virtual ~Group();
1027  virtual void UpdateChunks();
1028  void MoveAll();
1029  friend class File;
1030  private:
1031  File* pFile;
1032  RIFF::Chunk* pNameChunk;
1033  };
1034 
1036  class File : protected DLS::File {
1037  public:
1040 
1041  // derived attributes from DLS::Resource
1042  using DLS::Resource::pInfo;
1043  using DLS::Resource::pDLSID;
1044  // derived attributes from DLS::File
1045  using DLS::File::pVersion;
1046  using DLS::File::Instruments;
1047 
1048  // derived methods from DLS::Resource
1050  // derived methods from DLS::File
1051  using DLS::File::Save;
1052  using DLS::File::GetFileName;
1053  using DLS::File::SetFileName;
1054  // overridden methods
1055  File();
1056  File(RIFF::File* pRIFF);
1057  Sample* GetFirstSample(progress_t* pProgress = NULL);
1058  Sample* GetNextSample();
1059  Sample* GetSample(uint index);
1060  Sample* AddSample();
1061  void DeleteSample(Sample* pSample);
1064  Instrument* GetInstrument(uint index, progress_t* pProgress = NULL);
1067  void DeleteInstrument(Instrument* pInstrument);
1068  Group* GetFirstGroup();
1069  Group* GetNextGroup();
1070  Group* GetGroup(uint index);
1071  Group* GetGroup(String name);
1072  Group* AddGroup();
1073  void DeleteGroup(Group* pGroup);
1074  void DeleteGroupOnly(Group* pGroup);
1075  void SetAutoLoad(bool b);
1076  bool GetAutoLoad();
1077  void AddContentOf(File* pFile);
1078  ScriptGroup* GetScriptGroup(uint index);
1079  ScriptGroup* GetScriptGroup(const String& name);
1081  void DeleteScriptGroup(ScriptGroup* pGroup);
1082  virtual ~File();
1083  virtual void UpdateChunks();
1084  protected:
1085  // overridden protected methods from DLS::File
1086  virtual void LoadSamples();
1087  virtual void LoadInstruments();
1088  virtual void LoadGroups();
1089  virtual void UpdateFileOffsets();
1090  // own protected methods
1091  virtual void LoadSamples(progress_t* pProgress);
1092  virtual void LoadInstruments(progress_t* pProgress);
1093  virtual void LoadScriptGroups();
1094  void SetSampleChecksum(Sample* pSample, uint32_t crc);
1095  friend class Region;
1096  friend class Sample;
1097  friend class Group; // so Group can access protected member pRIFF
1098  friend class ScriptGroup; // so ScriptGroup can access protected member pRIFF
1099  private:
1100  std::list<Group*>* pGroups;
1101  std::list<Group*>::iterator GroupsIterator;
1102  bool bAutoLoad;
1103  std::list<ScriptGroup*>* pScriptGroups;
1104  };
1105 
1114  class Exception : public DLS::Exception {
1115  public:
1117  void PrintMessage();
1118  };
1119 
1120  String libraryName();
1122 
1123 } // namespace gig
1124 
1125 #endif // __GIG_H__
range_t KeySwitchRange
Key range for key switch selector.
Definition: gig.h:831
bool LFO2FlipPhase
Inverts phase of the filter cutoff LFO wave.
Definition: gig.h:397
void UpdateRegionKeyTable()
Definition: gig.cpp:4448
void SetScriptAsText(const String &text)
Replaces the current script with the new script source code text given by text.
Definition: gig.cpp:4159
void AddContentOf(File *pFile)
Add content of another existing file.
Definition: gig.cpp:5438
General Purpose Controller 4 (Slider, MIDI Controller 19)
Definition: gig.h:243
void MoveAll()
Move all members of this group to another group (preferably the 1st one except this).
Definition: gig.cpp:5082
dim_bypass_ctrl_t DimensionBypass
If defined, the MIDI controller can switch on/off the dimension in realtime.
Definition: gig.h:431
~Instrument()
Destructor.
Definition: gig.cpp:4460
Encapsulates articulation information of a dimension region.
Definition: gig.h:356
void LoadScripts()
Definition: gig.cpp:4710
range_t DimensionKeyRange
0-127 (where 0 means C1 and 127 means G9)
Definition: gig.h:949
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:371
uint8_t VCFVelocityScale
(0-127) Amount velocity controls VCF cutoff frequency (only if no other VCF cutoff controller is defi...
Definition: gig.h:414
void SetDimensionType(dimension_t oldType, dimension_t newType)
Change type of an existing dimension.
Definition: gig.cpp:3669
unsigned long FrameOffset
Current offset (sample points) in current sample frame (for decompression only).
Definition: gig.h:657
bool reverse
If playback direction is currently backwards (in case there is a pingpong or reverse loop defined)...
Definition: gig.h:310
Only controlled by aftertouch controller.
Definition: gig.h:126
25 frames per second
Definition: gig.h:102
uint8_t AltSustain2Key
Key triggering a second set of alternate sustain samples.
Definition: gig.h:794
uint32_t Regions
Reflects the number of Region defintions this Instrument has.
Definition: DLS.h:465
Region * GetRegion(unsigned int Key)
Returns the appropriate Region for a triggered note.
Definition: gig.cpp:4588
void AddSample(Sample *pSample)
Move Sample given by pSample from another Group to this Group.
Definition: gig.cpp:5072
String GetScriptAsText()
Returns the current script (i.e.
Definition: gig.cpp:4146
virtual void UpdateChunks()
Apply dimension region settings to the respective RIFF chunks.
Definition: gig.cpp:1756
Effect Controller 2 (Coarse, MIDI Controller 13)
Definition: gig.h:155
MidiRuleAlternator * AddMidiRuleAlternator()
Adds the alternator MIDI rule to the instrument.
Definition: gig.cpp:4692
Sample * AddSample()
Add a new sample.
Definition: gig.cpp:5216
bool VCFEnabled
If filter should be used.
Definition: gig.h:408
Controlled internally and by external modulation wheel.
Definition: gig.h:127
Controlled internally and by aftertouch controller.
Definition: gig.h:128
Parses DLS Level 1 and 2 compliant files and provides abstract access to the data.
Definition: DLS.h:495
no SMPTE offset
Definition: gig.h:100
void AddDimension(dimension_def_t *pDimDef)
Einstein would have dreamed of it - create a new dimension.
Definition: gig.cpp:3204
stream_whence_t
File stream position dependent to these relations.
Definition: RIFF.h:158
Soft Pedal (MIDI Controller 67)
Definition: gig.h:159
void LoadScripts()
Definition: gig.cpp:4326
uint32_t FineTune
Specifies the fraction of a semitone up from the specified MIDI unity note field. A value of 0x800000...
Definition: gig.h:617
uint8_t BypassKey
Key to be used to bypass the sustain note.
Definition: gig.h:787
uint16_t LFO1ControlDepth
Controller depth influencing sample amplitude LFO pitch (0 - 1200 cents).
Definition: gig.h:376
lfo1_ctrl_t
Defines how LFO1 is controlled by.
Definition: gig.h:141
Group of Gigasampler objects.
Definition: gig.h:1017
uint8_t VCFVelocityDynamicRange
0x04 = lowest, 0x00 = highest .
Definition: gig.h:415
String Name
Stores the name of this Group.
Definition: gig.h:1019
DimensionRegion * GetDimensionRegionByBit(const uint8_t DimBits[8])
Returns the appropriate DimensionRegion for the given dimension bit numbers (zone index)...
Definition: gig.cpp:3849
Special dimension for triggering samples on releasing a key.
Definition: gig.h:228
uint16_t PitchbendRange
Number of semitones pitchbend controller can pitch (default is 2).
Definition: gig.h:947
virtual void UpdateChunks()
Apply all the gig file&#39;s current instruments, samples, groups and settings to the respective RIFF chu...
Definition: gig.cpp:5786
double EG1Release
Release time of the sample amplitude EG (0.000 - 60.000s).
Definition: gig.h:367
unsigned long ReadAndLoop(void *pBuffer, unsigned long 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:926
virtual ~File()
Definition: gig.cpp:5158
Only internally controlled.
Definition: gig.h:124
uint8_t Triggers
Number of triggers.
Definition: gig.h:764
uint ScriptSlotCount() const
Instrument&#39;s amount of script slots.
Definition: gig.cpp:4870
virtual void UpdateChunks()
Apply Instrument with all its Regions to the respective RIFF chunks.
Definition: gig.cpp:4477
vcf_type_t VCFType
Defines the general filter characteristic (lowpass, highpass, bandpass, etc.).
Definition: gig.h:409
Effect Controller 1 (Coarse, MIDI Controller 12)
Definition: gig.h:238
Script * AddScript()
Add new instrument script.
Definition: gig.cpp:4296
uint32_t LoopSize
Caution: Use the respective fields in the DimensionRegion instead of this one! (Intended purpose: Len...
Definition: gig.h:625
void(* callback)(progress_t *)
Callback function pointer which has to be assigned to a function for progress notification.
Definition: gig.h:327
Instrument * AddInstrument()
Add a new instrument definition.
Definition: gig.cpp:5384
Controlled internally and by external modulation wheel.
Definition: gig.h:136
virtual void LoadScriptGroups()
Definition: gig.cpp:5761
Script * GetScript(uint index)
Get instrument script.
Definition: gig.cpp:4277
loop_type_t LoopType
Caution: Use the respective field in the DimensionRegion instead of this one! (Intended purpose: The ...
Definition: gig.h:622
lfo1_ctrl_t LFO1Controller
MIDI Controller which controls sample amplitude LFO.
Definition: gig.h:377
Group * AddGroup()
Definition: gig.cpp:5609
Effect 2 Depth (MIDI Controller 92)
Definition: gig.h:253
Effect Controller 1 (Coarse, MIDI Controller 12)
Definition: gig.h:154
Only internally controlled.
Definition: gig.h:133
Sample * GetFirstSample()
Returns a pointer to the first Sample object of the file, NULL otherwise.
Definition: DLS.cpp:1493
uint8_t low
Low value of range.
Definition: gig.h:75
Modulation Wheel (MIDI Controller 1)
Definition: gig.h:234
Will be thrown whenever a DLS specific error occurs while trying to access a DLS File.
Definition: DLS.h:550
uint16_t SampleStartOffset
Number of samples the sample start should be moved (0 - 2000).
Definition: gig.h:440
MIDI rule for triggering notes by control change events.
Definition: gig.h:761
30 frames per second
Definition: gig.h:104
void UpdateChunks()
Definition: gig.cpp:4254
NKSP stands for &quot;Is Not KSP&quot; (default).
Definition: gig.h:872
uint8_t Key
Key to trigger.
Definition: gig.h:769
unsigned long WorstCaseFrameSize
For compressed samples only: size (in bytes) of the largest possible sample frame.
Definition: gig.h:661
void AddScriptSlot(Script *pScript, bool bypass=false)
Add new instrument script slot (gig format extension).
Definition: gig.cpp:4794
bool EG1Hold
If true, Decay1 stage should be postponed until the sample reached the sample loop start...
Definition: gig.h:368
range_t PlayRange
Key range of the playable keys in the instrument.
Definition: gig.h:809
void UpdateChunks(uint8_t *pData) const
Definition: gig.h:848
uint16_t ThresholdTime
Maximum time (ms) between two notes that should be played legato.
Definition: gig.h:789
const uint8_t & operator[](int i) const
Definition: gig.h:815
RIFF::Chunk * pCk3gix
Definition: gig.h:665
dimension values are already the sought bit number
Definition: gig.h:265
uint8_t VelocityResponseCurveScaling
0 - 127 (usually you don&#39;t have to interpret this parameter, use GetVelocityAttenuation() instead)...
Definition: gig.h:424
bool Descending
If the change in CC value should be downwards.
Definition: gig.h:767
double GetVelocityCutoff(uint8_t MIDIKeyVelocity)
Definition: gig.cpp:2773
unsigned long Size
Size of the actual data in the buffer in bytes.
Definition: gig.h:82
Effect 1 Depth (MIDI Controller 91)
Definition: gig.h:252
Instrument * GetFirstInstrument()
Returns a pointer to the first Instrument object of the file, NULL otherwise.
Definition: gig.cpp:5327
Breath Controller (Coarse, MIDI Controller 2)
Definition: gig.h:156
Region * RegionKeyTable[128]
fast lookup for the corresponding Region of a MIDI key
Definition: gig.h:978
uint8_t ReleaseTriggerKey
Key triggering release samples.
Definition: gig.h:792
Sample(File *pFile, RIFF::List *waveList, unsigned long WavePoolOffset, unsigned long fileNo=0)
Constructor.
Definition: gig.cpp:370
void UpdateChunks()
Definition: gig.cpp:4164
For MIDI tools like legato and repetition mode.
Definition: gig.h:232
bool VCFKeyboardTracking
If true: VCF cutoff frequence will be dependend to the note key position relative to the defined brea...
Definition: gig.h:419
uint32_t WavePoolTableIndex
Definition: DLS.h:447
uint8_t Velocity
Velocity of the note to trigger. 255 means that velocity should depend on the speed of the controller...
Definition: gig.h:771
void CopyAssignWave(const Sample *orig)
Should be called after CopyAssignMeta() and File::Save() sequence.
Definition: gig.cpp:508
uint32_t crc
CRC-32 checksum of the raw sample data.
Definition: gig.h:667
Defines a controller that has a certain contrained influence on a particular synthesis parameter (use...
Definition: gig.h:182
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:397
uint8_t Controller
CC number for controller selector.
Definition: gig.h:832
void SetVCFVelocityScale(uint8_t scaling)
Updates the respective member variable and the lookup table / cache that depends on this value...
Definition: gig.cpp:2862
Defines Region information of an Instrument.
Definition: gig.h:717
Only controlled by external modulation wheel.
Definition: gig.h:134
void UpdateVelocityTable()
Definition: gig.cpp:3119
unsigned long SamplesPerFrame
For compressed samples only: number of samples in a full sample frame.
Definition: gig.h:662
uint32_t LoopPlayCount
Number of times the loop should be played (a value of 0 = infinite).
Definition: gig.h:627
uint8_t ReleaseTriggerDecay
0 - 8
Definition: gig.h:427
lfo3_ctrl_t LFO3Controller
MIDI Controller which controls the sample pitch LFO.
Definition: gig.h:405
static unsigned int Instances
Number of instances of class Sample.
Definition: gig.h:654
bool Chained
If all patterns should be chained together.
Definition: gig.h:835
uint32_t MIDIUnityNote
Specifies the musical note at which the sample will be played at it&#39;s original sample rate...
Definition: gig.h:616
int16_t FineTune
Definition: DLS.h:366
uint8_t ControllerNumber
MIDI controller number.
Definition: gig.h:763
Portamento (MIDI Controller 65)
Definition: gig.h:245
uint8_t ChannelOffset
Audio output where the audio signal of the dimension region should be routed to (0 - 9)...
Definition: gig.h:437
void Resize(int iNewSize)
Resize sample.
Definition: gig.cpp:827
General Purpose Controller 6 (Button, MIDI Controller 81)
Definition: gig.h:249
uint8_t VCFResonance
Firm internal filter resonance weight.
Definition: gig.h:416
Standard 8 bit US ASCII character encoding (default).
Definition: gig.h:866
bool VCFResonanceDynamic
If true: Increases the resonance Q according to changes of controllers that actually control the VCF ...
Definition: gig.h:417
Language_t Language
Programming language and dialect the script is written in.
Definition: gig.h:878
void DeleteMidiRule(int i)
Deletes a MIDI rule from the instrument.
Definition: gig.cpp:4705
unsigned int Dimensions
Number of defined dimensions, do not alter!
Definition: gig.h:719
Only controlled by external modulation wheel.
Definition: gig.h:125
void UpdateChunks(uint8_t *pData) const
Definition: gig.cpp:4074
vcf_cutoff_ctrl_t VCFCutoffController
Specifies which external controller has influence on the filter cutoff frequency. ...
Definition: gig.h:410
uint16_t MIDIBank
Reflects combination of MIDIBankCoarse and MIDIBankFine (bank 1 - bank 16384). Do not change this val...
Definition: DLS.h:461
MidiRuleCtrlTrigger * AddMidiRuleCtrlTrigger()
Adds the &quot;controller trigger&quot; MIDI rule to the instrument.
Definition: gig.cpp:4666
Foot Pedal (Coarse, MIDI Controller 4)
Definition: gig.h:157
double EG1Decay1
Decay time of the sample amplitude EG (0.000 - 60.000s).
Definition: gig.h:363
float __range_min
Only for internal usage, do not modify!
Definition: gig.h:330
DimensionRegion * GetDimensionRegionByValue(const uint DimValues[8])
Use this method in your audio engine to get the appropriate dimension region with it&#39;s articulation d...
Definition: gig.cpp:3740
void UpdateScriptFileOffsets()
Definition: gig.cpp:4561
virtual void UpdateChunks()
Apply Region settings and all its DimensionRegions to the respective RIFF chunks. ...
Definition: gig.cpp:3031
lfo2_ctrl_t LFO2Controller
MIDI Controlle which controls the filter cutoff LFO.
Definition: gig.h:396
Compression_t Compression
Whether the script was/should be compressed, and if so, which compression algorithm shall be used...
Definition: gig.h:876
void LoadDimensionRegions(RIFF::List *rgn)
Definition: gig.cpp:3096
Different samples triggered each time a note is played, any key advances the counter.
Definition: gig.h:233
bool Dithered
For 24-bit compressed samples only: if dithering was used during compression with bit reduction...
Definition: gig.h:630
Region * GetFirstRegion()
Returns the first Region of the instrument.
Definition: gig.cpp:4606
String libraryVersion()
Returns version of this C++ library.
Definition: gig.cpp:6051
uint8_t VelocityUpperLimit
Defines the upper velocity value limit of a velocity split (only if an user defined limit was set...
Definition: gig.h:358
uint8_t ReleaseVelocityResponseDepth
Dynamic range of release velocity affecting envelope time (0 - 4).
Definition: gig.h:426
void RemoveAllScriptReferences()
Definition: gig.cpp:4219
Will be thrown whenever a gig specific error occurs while trying to access a Gigasampler File...
Definition: gig.h:1114
buffer_t LoadSampleDataWithNullSamplesExtension(uint NullSamplesCount)
Loads (and uncompresses if needed) the whole sample wave into RAM.
Definition: gig.cpp:716
Group * GetGroup() const
Returns pointer to the Group this Sample belongs to.
Definition: gig.cpp:1367
Instrument(File *pFile, RIFF::List *insList, progress_t *pProgress=NULL)
Definition: gig.cpp:4343
Used for indicating the progress of a certain task.
Definition: gig.h:326
uint8_t MIDIBankCoarse
Reflects the MIDI Bank number for MIDI Control Change 0 (bank 1 - 128).
Definition: DLS.h:462
uint8_t in_end
End position of fade in.
Definition: gig.h:301
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:2835
unsigned long WorstCaseMaxSamples(buffer_t *pDecompressionBuffer)
Definition: gig.h:690
static const DLS::version_t VERSION_2
Reflects Gigasampler file format version 2.0 (1998-06-28).
Definition: gig.h:1038
Sample * pSample
Points to the Sample which is assigned to the dimension region.
Definition: gig.h:359
buffer_t LoadSampleData()
Loads (and uncompresses if needed) the whole sample wave into RAM.
Definition: gig.cpp:667
uint16_t ReleaseTime
Release time.
Definition: gig.h:790
smpte_format_t
Society of Motion Pictures and Television E time format.
Definition: gig.h:99
uint32_t LoopStart
Caution: Use the respective field in the DimensionRegion instead of this one! (Intended purpose: The ...
Definition: gig.h:623
Group * GetNextGroup()
Returns a pointer to the next Group object of the file, NULL otherwise.
Definition: gig.cpp:5569
Loop forward (normal)
Definition: gig.h:93
void SetVCFVelocityCurve(curve_type_t curve)
Updates the respective member variable and the lookup table / cache that depends on this value...
Definition: gig.cpp:2844
double EG2Decay1
Decay time of the filter cutoff EG (0.000 - 60.000s).
Definition: gig.h:383
uint8_t EG1ControllerAttackInfluence
Amount EG1 Controller has influence on the EG1 Attack time (0 - 3, where 0 means off).
Definition: gig.h:371
unsigned long position
Current position within the sample.
Definition: gig.h:309
String pArticulations[32]
Names of the articulations.
Definition: gig.h:807
Only controlled by external foot controller.
Definition: gig.h:135
crossfade_t Crossfade
Definition: gig.h:429
Compression_t
Definition: gig.h:868
void SetAutoLoad(bool b)
Enable / disable automatic loading.
Definition: gig.cpp:6010
MidiRule * GetMidiRule(int i)
Returns a MIDI rule of the instrument.
Definition: gig.cpp:4657
void DeleteSampleLoop(sample_loop_t *pLoopDef)
Deletes an existing sample loop.
Definition: DLS.cpp:645
smpte_format_t SMPTEFormat
Specifies the Society of Motion Pictures and Television E time format used in the following SMPTEOffs...
Definition: gig.h:618
double SampleAttenuation
Sample volume (calculated from DLS::Sampler::Gain)
Definition: gig.h:441
File()
Definition: gig.cpp:5134
lfo3_ctrl_t
Defines how LFO3 is controlled by.
Definition: gig.h:123
Channel Key Pressure.
Definition: gig.h:227
RIFF List Chunk.
Definition: RIFF.h:280
ScriptGroup * GetGroup() const
Returns the script group this script currently belongs to.
Definition: gig.cpp:4215
Sustain Pedal (MIDI Controller 64)
Definition: gig.h:158
double EG1Decay2
Only if EG1InfiniteSustain == false: 2nd decay stage time of the sample amplitude EG (0...
Definition: gig.h:364
bool PianoReleaseMode
Definition: gig.h:948
void RemoveScript(Script *pScript)
Remove reference to given Script (gig format extension).
Definition: gig.cpp:4847
uint8_t BypassController
Controller to be used to bypass the sustain note.
Definition: gig.h:788
attenuation_ctrl_t AttenuationController
MIDI Controller which has influence on the volume level of the sample (or entire sample group)...
Definition: gig.h:434
float __range_max
Only for internal usage, do not modify!
Definition: gig.h:331
static buffer_t InternalDecompressionBuffer
Buffer used for decompression as well as for truncation of 24 Bit -&gt; 16 Bit samples.
Definition: gig.h:655
static void DestroyDecompressionBuffer(buffer_t &DecompressionBuffer)
Free decompression buffer, previously created with CreateDecompressionBuffer().
Definition: gig.cpp:1350
Pointer address and size of a buffer.
Definition: gig.h:80
virtual void LoadSamples()
Definition: gig.cpp:5267
uint8_t in_start
Start position of fade in.
Definition: gig.h:300
uint8_t Patterns
Number of alternator patterns.
Definition: gig.h:811
unsigned long Read(void *pBuffer, unsigned long SampleCount, buffer_t *pExternalDecompressionBuffer=NULL)
Reads SampleCount number of sample points from the current position into the buffer pointed by pBuffe...
Definition: gig.cpp:1101
dimension_t dimension
Specifies which source (usually a MIDI controller) is associated with the dimension.
Definition: gig.h:270
bool Bypass
Global bypass: if enabled, this script shall not be executed by the sampler for any instrument...
Definition: gig.h:879
Abstract base class which provides mandatory informations about sample players in general...
Definition: DLS.h:363
loop_type_t
Standard types of sample loops.
Definition: gig.h:92
range_t KeyRange
Key range for legato notes.
Definition: gig.h:791
Sustain Pedal (MIDI Controller 64)
Definition: gig.h:244
unsigned long SamplesInLastFrame
For compressed samples only: length of the last sample frame.
Definition: gig.h:660
bool EG2ControllerInvert
Invert values coming from defined EG2 controller.
Definition: gig.h:389
uint8_t Articulations
Number of articulations in the instrument.
Definition: gig.h:806
Group * GetFirstGroup()
Returns a pointer to the first Group object of the file, NULL otherwise.
Definition: gig.cpp:5562
Group * GetGroup(uint index)
Returns the group with the given index.
Definition: gig.cpp:5581
buffer_t()
Definition: gig.h:84
uint8_t VelSensitivity
How sensitive the velocity should be to the speed of the controller change.
Definition: gig.h:768
String Name
Arbitrary name of the script, which may be displayed i.e. in an instrument editor.
Definition: gig.h:875
uint32_t DimensionRegions
Total number of DimensionRegions this Region contains, do not alter!
Definition: gig.h:721
Instrument * AddDuplicateInstrument(const Instrument *orig)
Add a duplicate of an existing instrument.
Definition: gig.cpp:5421
std::string String
Definition: gig.h:71
bool MSDecode
Gigastudio flag: defines if Mid Side Recordings should be decoded.
Definition: gig.h:439
Key Velocity (this is the only dimension in gig2 where the ranges can exactly be defined).
Definition: gig.h:226
bool EG1InfiniteSustain
If true, instead of going into Decay2 phase, Decay1 level will be hold until note will be released...
Definition: gig.h:365
bool Compressed
If the sample wave is compressed (probably just interesting for instrument and sample editors...
Definition: gig.h:628
void ReleaseSampleData()
Frees the cached sample from RAM if loaded with LoadSampleData() previously.
Definition: gig.cpp:790
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:1665
General Purpose Controller 3 (Slider, MIDI Controller 18)
Definition: gig.h:242
uint32_t SampleLoops
Reflects the number of sample loops.
Definition: DLS.h:370
More poles than normal lowpass.
Definition: gig.h:280
uint16_t LFO2InternalDepth
Firm pitch of the filter cutoff LFO (0 - 1200 cents).
Definition: gig.h:394
void DeleteDimensionZone(dimension_t type, int zone)
Delete one split zone of a dimension (decrement zone amount).
Definition: gig.cpp:3406
uint16_t LFO1InternalDepth
Firm pitch of the sample amplitude LFO (0 - 1200 cents).
Definition: gig.h:375
The difference between none and none2 is unknown.
Definition: gig.h:152
Controlled internally and by external breath controller.
Definition: gig.h:146
virtual void LoadInstruments()
Definition: gig.cpp:5506
float zone_size
Intended for internal usage: reflects the size of each zone (128/zones) for normal split types only...
Definition: gig.h:274
virtual void UpdateFileOffsets()
Updates all file offsets stored all over the file.
Definition: gig.cpp:5985
String Message
Definition: RIFF.h:385
Only controlled by external breath controller.
Definition: gig.h:144
bool PitchTrack
If true: sample will be pitched according to the key position (this will be disabled for drums for ex...
Definition: gig.h:430
double GetVelocityRelease(uint8_t MIDIKeyVelocity)
Definition: gig.cpp:2769
unsigned long Write(void *pBuffer, unsigned long SampleCount)
Write sample wave data.
Definition: gig.cpp:1290
Encoding_t
Definition: gig.h:865
bool BypassUseController
If a controller should be used to bypass the sustain note.
Definition: gig.h:786
unsigned int Layers
Amount of defined layers (1 - 32). A value of 1 actually means no layering, a value &gt; 1 means there i...
Definition: gig.h:723
void * pStart
Points to the beginning of the buffer.
Definition: gig.h:81
bool EG2InfiniteSustain
If true, instead of going into Decay2 phase, Decay1 level will be hold until note will be released...
Definition: gig.h:385
Region * AddRegion()
Definition: gig.cpp:4626
General Purpose Controller 4 (Slider, MIDI Controller 19)
Definition: gig.h:169
unsigned long SamplePos
For compressed samples only: stores the current position (in sample points).
Definition: gig.h:659
Group * pGroup
pointer to the Group this sample belongs to (always not-NULL)
Definition: gig.h:656
Script(ScriptGroup *group, RIFF::Chunk *ckScri)
Definition: gig.cpp:4108
struct gig::MidiRuleAlternator::pattern_t pPatterns[32]
A pattern is a sequence of articulation numbers.
virtual ~MidiRule()
Definition: gig.h:754
Effect 4 Depth (MIDI Controller 94)
Definition: gig.h:255
Breath Controller (Coarse, MIDI Controller 2)
Definition: gig.h:235
MidiRuleLegato * AddMidiRuleLegato()
Adds the legato MIDI rule to the instrument.
Definition: gig.cpp:4679
uint8_t EG2ControllerAttackInfluence
Amount EG2 Controller has influence on the EG2 Attack time (0 - 3, where 0 means off).
Definition: gig.h:390
Exception(String Message)
Definition: gig.cpp:6027
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:433
int16_t LFO3ControlDepth
Controller depth of the sample pitch LFO (-1200 - +1200 cents).
Definition: gig.h:404
RIFF::Chunk * pCkSmpl
Definition: gig.h:666
void RemoveScriptSlot(uint index)
Remove script slot.
Definition: gig.cpp:4829
Only controlled by external modulation wheel.
Definition: gig.h:143
double EG3Attack
Attack time of the sample pitch EG (0.000 - 10.000s).
Definition: gig.h:400
void DeleteDimension(dimension_def_t *pDimDef)
Delete an existing dimension.
Definition: gig.cpp:3316
Instrument * GetNextInstrument()
Returns a pointer to the next Instrument object of the file, NULL otherwise.
Definition: gig.cpp:5334
uint8_t LegatoSamples
Number of legato samples per key in each direction (always 12)
Definition: gig.h:785
uint8_t out_end
End postition of fade out.
Definition: gig.h:303
void DeleteGroupOnly(Group *pGroup)
Delete a group.
Definition: gig.cpp:5651
double EG2Attack
Attack time of the filter cutoff EG (0.000 - 60.000s).
Definition: gig.h:382
uint16_t BitDepth
Size of each sample per channel (only if known sample data format is used, 0 otherwise).
Definition: DLS.h:401
bool InvertAttenuationController
Inverts the values coming from the defined Attenuation Controller.
Definition: gig.h:435
double LFO1Frequency
Frequency of the sample amplitude LFO (0.10 - 10.00 Hz).
Definition: gig.h:374
Ordinary RIFF Chunk.
Definition: RIFF.h:183
DimensionRegion(Region *pParent, RIFF::List *_3ewl)
Definition: gig.cpp:1390
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:621
uint16_t EffectSend
Definition: gig.h:945
virtual void UpdateChunks()
Update chunks with current group settings.
Definition: gig.cpp:5008
bool LFO1FlipPhase
Inverts phase of the sample amplitude LFO wave.
Definition: gig.h:378
uint8_t AltSustain1Key
Key triggering alternate sustain samples.
Definition: gig.h:793
void DeleteSample(Sample *pSample)
Delete a sample.
Definition: gig.cpp:5241
int16_t FineTune
in cents
Definition: gig.h:946
Region(Instrument *pInstrument, RIFF::List *rgnList)
Definition: gig.cpp:2938
uint8_t UnityNote
Definition: DLS.h:365
Effect 5 Depth (MIDI Controller 95)
Definition: gig.h:256
static buffer_t CreateDecompressionBuffer(unsigned long MaxReadSize)
Allocates a decompression buffer for streaming (compressed) samples with Sample::Read().
Definition: gig.cpp:1333
bool LFO3Sync
If set to true only one LFO should be used for all voices.
Definition: gig.h:406
uint32_t MIDIProgram
Specifies the MIDI Program Change Number this Instrument should be assigned to.
Definition: DLS.h:464
bool IsScriptSlotBypassed(uint index)
Whether script execution shall be skipped.
Definition: gig.cpp:4890
double LFO3Frequency
Frequency of the sample pitch LFO (0.10 - 10.00 Hz).
Definition: gig.h:402
static const DLS::version_t VERSION_3
Reflects Gigasampler file format version 3.0 (2003-03-31).
Definition: gig.h:1039
void DeleteRegion(Region *pRegion)
Definition: gig.cpp:4640
virtual ~ScriptGroup()
Definition: gig.cpp:4242
Soft Pedal (MIDI Controller 67)
Definition: gig.h:247
ScriptGroup * AddScriptGroup()
Add new instrument script group.
Definition: gig.cpp:5728
DimensionRegion * pDimensionRegions[256]
Pointer array to the 32 (gig2) or 256 (gig3) possible dimension regions (reflects NULL for dimension ...
Definition: gig.h:722
uint32_t Product
Specifies the MIDI model ID defined by the manufacturer corresponding to the Manufacturer field...
Definition: gig.h:614
bool LFO1Sync
If set to true only one LFO should be used for all voices.
Definition: gig.h:379
split_type_t
Intended for internal usage: will be used to convert a dimension value into the corresponding dimensi...
Definition: gig.h:263
Alternating loop (forward/backward, also known as Ping Pong)
Definition: gig.h:94
ScriptGroup * GetScriptGroup(uint index)
Get instrument script group (by index).
Definition: gig.cpp:5696
unsigned long 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:311
~Sample()
Destructor.
Definition: gig.cpp:1371
void SetSampleChecksum(Sample *pSample, uint32_t crc)
Updates the 3crc chunk with the checksum of a sample.
Definition: gig.cpp:5539
Sample * GetNextSample()
Returns the next Sample of the Group.
Definition: gig.cpp:5061
leverage_ctrl_t eg2_ctrl_t
Defines controller influencing envelope generator 2.
Definition: gig.h:213
uint8_t EG2ControllerReleaseInfluence
Amount EG2 Controller has influence on the EG2 Release time (0 - 3, where 0 means off)...
Definition: gig.h:392
uint16_t EG2PreAttack
Preattack value of the filter cutoff EG (0 - 1000 permille).
Definition: gig.h:381
leverage_ctrl_t attenuation_ctrl_t
Defines controller influencing attenuation.
Definition: gig.h:199
uint32_t Loops
Caution: Use the respective field in the DimensionRegion instead of this one! (Intended purpose: Numb...
Definition: gig.h:620
String Name
Name of the pattern.
Definition: gig.h:813
bool LFO2Sync
If set to true only one LFO should be used for all voices.
Definition: gig.h:398
uint32_t SMPTEOffset
The SMPTE Offset value specifies the time offset to be used for the synchronization / calibration to ...
Definition: gig.h:619
unsigned long FileNo
File number (&gt; 0 when sample is stored in an extension file, 0 when it&#39;s in the gig) ...
Definition: gig.h:664
void SplitDimensionZone(dimension_t type, int zone)
Divide split zone of a dimension in two (increment zone amount).
Definition: gig.cpp:3530
bool EG1ControllerInvert
Invert values coming from defined EG1 controller.
Definition: gig.h:370
void UpdateChunks(uint8_t *pData) const
Definition: gig.cpp:3965
Ordinary MIDI control change controller, see field &#39;controller_number&#39;.
Definition: gig.h:187
30 frames per second with frame dropping (30 drop)
Definition: gig.h:103
vcf_res_ctrl_t
Defines how the filter resonance is controlled by.
Definition: gig.h:166
vcf_type_t
Defines which frequencies are filtered by the VCF.
Definition: gig.h:278
General Purpose Controller 5 (Button, MIDI Controller 80)
Definition: gig.h:248
version_t * pVersion
Points to a version_t structure if the file provided a version number else is set to NULL...
Definition: DLS.h:497
void DeleteInstrument(Instrument *pInstrument)
Delete an instrument.
Definition: gig.cpp:5498
uint16_t LFO2ControlDepth
Controller depth influencing filter cutoff LFO pitch (0 - 1200).
Definition: gig.h:395
String Name
Name of this script group. For example to be displayed in an instrument editor.
Definition: gig.h:912
int GetDimensionRegionIndexByValue(const uint DimValues[8])
Definition: gig.cpp:3789
Loop backward (reverse)
Definition: gig.h:95
int16_t EG3Depth
Depth of the sample pitch EG (-1200 - +1200).
Definition: gig.h:401
bool GetAutoLoad()
Returns whether automatic loading is enabled.
Definition: gig.cpp:6018
uint8_t VCFKeyboardTrackingBreakpoint
See VCFKeyboardTracking (0 - 127).
Definition: gig.h:420
eg2_ctrl_t EG2Controller
MIDI Controller which has influence on filter cutoff EG parameters (attack, decay, release).
Definition: gig.h:388
For layering of up to 8 instruments (and eventually crossfading of 2 or 4 layers).
Definition: gig.h:225
bool VCFCutoffControllerInvert
Inverts values coming from the defined cutoff controller.
Definition: gig.h:411
General Purpose Controller 7 (Button, MIDI Controller 82)
Definition: gig.h:160
Controlled internally and by external foot controller.
Definition: gig.h:137
Different samples triggered each time a note is played, random order.
Definition: gig.h:231
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:3897
void * custom
This pointer can be used for arbitrary data.
Definition: gig.h:329
void SwapScriptSlots(uint index1, uint index2)
Flip two script slots with each other (gig format extension).
Definition: gig.cpp:4814
double EG2Release
Release time of the filter cutoff EG (0.000 - 60.000s).
Definition: gig.h:387
uint8_t EG1ControllerReleaseInfluence
Amount EG1 Controller has influence on the EG1 Release time (0 - 3, where 0 means off)...
Definition: gig.h:373
float factor
Reflects current progress as value between 0.0 and 1.0.
Definition: gig.h:328
uint8_t EG2ControllerDecayInfluence
Amount EG2 Controller has influence on the EG2 Decay time (0 - 3, where 0 means off).
Definition: gig.h:391
~Region()
Destructor.
Definition: gig.cpp:3716
unsigned long GetPos() const
Returns the current position in the sample (in sample points).
Definition: gig.cpp:887
bool Polyphonic
If alternator should step forward only when all notes are off.
Definition: gig.h:834
Abstract base class for all MIDI rules.
Definition: gig.h:752
void SetVelocityResponseCurveScaling(uint8_t scaling)
Updates the respective member variable and the lookup table / cache that depends on this value...
Definition: gig.cpp:2805
General Purpose Controller 2 (Slider, MIDI Controller 17)
Definition: gig.h:241
dimension_t
Defines the type of dimension, that is how the dimension zones (and thus how the dimension regions ar...
Definition: gig.h:222
ScriptGroup(File *file, RIFF::List *lstRTIS)
Definition: gig.cpp:4230
uint32_t LoopEnd
Caution: Use the respective field in the DimensionRegion instead of this one! (Intended purpose: The ...
Definition: gig.h:624
Defines the envelope of a crossfade.
Definition: gig.h:293
uint8_t MIDIBankFine
Reflects the MIDI Bank number for MIDI Control Change 32 (bank 1 - 128).
Definition: DLS.h:463
curve_type_t ReleaseVelocityResponseCurve
Defines a transformation curve to the incoming release veloctiy values affecting envelope times...
Definition: gig.h:425
Different samples triggered each time a note is played, dimension regions selected in sequence...
Definition: gig.h:230
dimension_def_t pDimensionDefinitions[8]
Defines the five (gig2) or eight (gig3) possible dimensions (the dimension&#39;s controller and number of...
Definition: gig.h:720
uint8_t zones
Number of zones the dimension has.
Definition: gig.h:272
Effect 5 Depth (MIDI Controller 95)
Definition: gig.h:119
General Purpose Controller 3 (Slider, MIDI Controller 18)
Definition: gig.h:168
uint8_t & operator[](int i)
Definition: gig.h:818
General Purpose Controller 8 (Button, MIDI Controller 83)
Definition: gig.h:161
uint8_t AttenuationControllerThreshold
0-127
Definition: gig.h:436
RIFF::File * pRIFF
Definition: DLS.h:521
buffer_t GetCache()
Returns current cached sample points.
Definition: gig.cpp:775
void SetVCFVelocityDynamicRange(uint8_t range)
Updates the respective member variable and the lookup table / cache that depends on this value...
Definition: gig.cpp:2853
vcf_cutoff_ctrl_t
Defines how the filter cutoff frequency is controlled by.
Definition: gig.h:150
No controller defined.
Definition: gig.h:184
Encapsulates sample waves used for playback.
Definition: gig.h:611
virtual void SetGain(int32_t gain)
Updates the respective member variable and updates SampleAttenuation which depends on this value...
Definition: gig.cpp:1744
RIFF File.
Definition: RIFF.h:328
Group(File *file, RIFF::Chunk *ck3gnm)
Constructor.
Definition: gig.cpp:4989
General Purpose Controller 8 (Button, MIDI Controller 83)
Definition: gig.h:251
unsigned long GuessSize(unsigned long samples)
Definition: gig.h:673
dimension value between 0-127
Definition: gig.h:264
24 frames per second
Definition: gig.h:101
Modulation Wheel (MIDI Controller 1)
Definition: gig.h:153
int16_t LFO3InternalDepth
Firm depth of the sample pitch LFO (-1200 - +1200 cents).
Definition: gig.h:403
General Purpose Controller 5 (Button, MIDI Controller 80)
Definition: gig.h:170
Lower and upper limit of a range.
Definition: gig.h:74
Sample * GetNextSample()
Returns a pointer to the next Sample object of the file, NULL otherwise.
Definition: gig.cpp:5186
virtual void Save()
Save changes to same file.
Definition: DLS.cpp:1758
General Purpose Controller 1 (Slider, MIDI Controller 16)
Definition: gig.h:240
virtual ~Script()
Definition: gig.cpp:4140
double EG2Decay2
Only if EG2InfiniteSustain == false: 2nd stage decay time of the filter cutoff EG (0...
Definition: gig.h:384
Portamento Time (Coarse, MIDI Controller 5)
Definition: gig.h:237
int32_t Attenuation
in dB
Definition: gig.h:944
Encapsulates sample waves used for playback.
Definition: DLS.h:394
type_t type
Controller type.
Definition: gig.h:190
uint controller_number
MIDI controller number if this controller is a control change controller, 0 otherwise.
Definition: gig.h:191
uint8_t * VelocityTable
For velocity dimensions with custom defined zone ranges only: used for fast converting from velocity ...
Definition: gig.h:473
curve_type_t VelocityResponseCurve
Defines a transformation curve to the incoming velocity values affecting amplitude (usually you don&#39;t...
Definition: gig.h:422
Effect Controller 2 (Coarse, MIDI Controller 13)
Definition: gig.h:239
A MIDI rule not yet implemented by libgig.
Definition: gig.h:845
Foot Pedal (Coarse, MIDI Controller 4)
Definition: gig.h:236
void PrintMessage()
Definition: gig.cpp:6030
uint16_t EG1Sustain
Sustain value of the sample amplitude EG (0 - 1000 permille).
Definition: gig.h:366
Sample * GetSample(uint index)
Returns Sample object of index.
Definition: gig.cpp:5197
String GetFileName()
File name of this DLS file.
Definition: DLS.cpp:1657
Real-time instrument script (gig format extension).
Definition: gig.h:863
unsigned long 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:83
void SetVelocityResponseDepth(uint8_t depth)
Updates the respective member variable and the lookup table / cache that depends on this value...
Definition: gig.cpp:2793
Sample * GetSampleFromWavePool(unsigned int WavePoolTableIndex, progress_t *pProgress=NULL)
Definition: gig.cpp:3873
General Purpose Controller 6 (Button, MIDI Controller 81)
Definition: gig.h:171
uint8_t DimensionUpperLimits[8]
gig3: defines the upper limit of the dimension values for this dimension region. In case you wondered...
Definition: gig.h:442
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:1686
uint8_t TriggerPoint
The CC value to pass for the note to be triggered.
Definition: gig.h:766
uint8_t VelocityResponseDepth
Dynamic range of velocity affecting amplitude (0 - 4) (usually you don&#39;t have to interpret this param...
Definition: gig.h:423
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:626
uint32_t TruncatedBits
For 24-bit compressed samples only: number of bits truncated during compression (0, 4 or 6)
Definition: gig.h:629
Instrument * GetInstrument(uint index, progress_t *pProgress=NULL)
Returns the instrument with the given index.
Definition: gig.cpp:5347
Resource * GetParent()
Definition: DLS.h:349
virtual void UpdateChunks(uint8_t *pData) const =0
Group of instrument scripts (gig format extension).
Definition: gig.h:910
Language_t
Definition: gig.h:871
virtual void UpdateChunks()
Apply sample and its settings to the respective RIFF chunks.
Definition: gig.cpp:535
int8_t Pan
Panorama / Balance (-64..0..63 &lt;-&gt; left..middle..right)
Definition: gig.h:432
Parses Gigasampler files and provides abstract access to the data.
Definition: gig.h:1036
Only internally controlled.
Definition: gig.h:142
void SetGroup(ScriptGroup *pGroup)
Move this script from its current ScriptGroup to another ScriptGroup given by pGroup.
Definition: gig.cpp:4202
lfo2_ctrl_t
Defines how LFO2 is controlled by.
Definition: gig.h:132
Effect 3 Depth (MIDI Controller 93)
Definition: gig.h:254
Dimension for keyswitching.
Definition: gig.h:229
MIDI rule for instruments with legato samples.
Definition: gig.h:783
virtual ~Group()
Definition: gig.cpp:4995
void SetReleaseVelocityResponseDepth(uint8_t depth)
Updates the respective member variable and the lookup table / cache that depends on this value...
Definition: gig.cpp:2826
Sample * GetFirstSample()
Returns the first Sample of this Group.
Definition: gig.cpp:5043
struct gig::MidiRuleCtrlTrigger::trigger_t pTriggers[32]
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:3709
leverage_ctrl_t eg1_ctrl_t
Defines controller influencing envelope generator 1.
Definition: gig.h:206
uint16_t EG2Sustain
Sustain value of the filter cutoff EG (0 - 1000 permille).
Definition: gig.h:386
dlsid_t * pDLSID
Points to a dlsid_t structure if the file provided a DLS ID else is NULL.
Definition: DLS.h:347
uint32_t Instruments
Reflects the number of available Instrument objects.
Definition: DLS.h:498
Provides all neccessary information for the synthesis of a DLS Instrument.
Definition: DLS.h:458
Provides all neccessary information for the synthesis of an Instrument.
Definition: gig.h:931
void SetScriptSlotBypassed(uint index, bool bBypass)
Defines whether execution shall be skipped.
Definition: gig.cpp:4910
void DeleteGroup(Group *pGroup)
Delete a group and its samples.
Definition: gig.cpp:5627
bool SustainDefeat
If true: Sustain pedal will not hold a note.
Definition: gig.h:438
Encoding_t Encoding
Format the script&#39;s source code text is encoded with.
Definition: gig.h:877
buffer_t RAMCache
Buffers samples (already uncompressed) in RAM.
Definition: gig.h:663
virtual void CopyAssign(const Instrument *orig)
Make a (semi) deep copy of the Instrument object given by orig and assign it to this object...
Definition: gig.cpp:4927
bool NoteOff
If a note off should be triggered instead of a note on.
Definition: gig.h:770
String libraryName()
Returns the name of this C++ library.
Definition: gig.cpp:6043
int32_t Gain
Definition: DLS.h:367
Controlled internally and by external modulation wheel.
Definition: gig.h:145
virtual void LoadGroups()
Definition: gig.cpp:5662
Quadtuple version number (&quot;major.minor.release.build&quot;).
Definition: DLS.h:109
double LFO2Frequency
Frequency of the filter cutoff LFO (0.10 - 10.00 Hz).
Definition: gig.h:393
uint32_t SamplePeriod
Specifies the duration of time that passes during the playback of one sample in nanoseconds (normally...
Definition: gig.h:615
uint16_t EG1PreAttack
Preattack value of the sample amplitude EG (0 - 1000 permille).
Definition: gig.h:361
Script * GetScriptOfSlot(uint index)
Get instrument script (gig format extension).
Definition: gig.cpp:4753
Dimension not in use.
Definition: gig.h:223
unsigned long * FrameTable
For positioning within compressed samples only: stores the offset values for each frame...
Definition: gig.h:658
curve_type_t
Defines the shape of a function graph.
Definition: gig.h:108
uint8_t bits
Number of &quot;bits&quot; (1 bit = 2 splits/zones, 2 bit = 4 splits/zones, 3 bit = 8 splits/zones,...).
Definition: gig.h:271
selector_t Selector
Method by which pattern is chosen.
Definition: gig.h:830
uint8_t out_start
Start position of fade out.
Definition: gig.h:302
uint8_t VCFCutoff
Max. cutoff frequency.
Definition: gig.h:412
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:3112
unsigned long SetPos(unsigned long SampleCount, RIFF::stream_whence_t Whence=RIFF::stream_start)
Sets the position within the sample (in sample points, not in bytes).
Definition: gig.cpp:853
Info * pInfo
Points (in any case) to an Info object, providing additional, optional infos and comments.
Definition: DLS.h:346
uint32_t Manufacturer
Specifies the MIDI Manufacturer&#39;s Association (MMA) Manufacturer code for the sampler intended to rec...
Definition: gig.h:613
uint8_t high
High value of range.
Definition: gig.h:76
bool OverridePedal
If a note off should be triggered even if the sustain pedal is down.
Definition: gig.h:772
MIDI rule to automatically cycle through specified sequences of different articulations.
Definition: gig.h:804
Reflects the current playback state for a sample.
Definition: gig.h:308
Region * GetParent() const
Definition: gig.cpp:2089
General dimension definition.
Definition: gig.h:269
int Size
Number of steps in the pattern.
Definition: gig.h:814
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:472
eg1_ctrl_t EG1Controller
MIDI Controller which has influence on sample amplitude EG parameters (attack, decay, release).
Definition: gig.h:369
Sostenuto Pedal (MIDI Controller 66)
Definition: gig.h:246
split_type_t split_type
Intended for internal usage: will be used to convert a dimension value into the corresponding dimensi...
Definition: gig.h:273
void DeleteScript(Script *pScript)
Delete an instrument script.
Definition: gig.cpp:4313
If used sample has more than one channel (thus is not mono).
Definition: gig.h:224
void SetReleaseVelocityResponseCurve(curve_type_t curve)
Updates the respective member variable and the lookup table / cache that depends on this value...
Definition: gig.cpp:2817
dim_bypass_ctrl_t
Dimensions allow to bypass one of the following controllers.
Definition: gig.h:116
vcf_res_ctrl_t VCFResonanceController
Specifies which external controller has influence on the filter resonance Q.
Definition: gig.h:418
Is not compressed at all (default).
Definition: gig.h:869
curve_type_t VCFVelocityCurve
Defines a transformation curve for the incoming velocity values, affecting the VCF.
Definition: gig.h:413
uint8_t EG1ControllerDecayInfluence
Amount EG1 Controller has influence on the EG1 Decay time (0 - 3, where 0 means off).
Definition: gig.h:372
Defines Region information of an Instrument.
Definition: DLS.h:428
Effect 4 Depth (MIDI Controller 94)
Definition: gig.h:118
General Purpose Controller 7 (Button, MIDI Controller 82)
Definition: gig.h:250
double GetVelocityAttenuation(uint8_t MIDIKeyVelocity)
Returns the correct amplitude factor for the given MIDIKeyVelocity.
Definition: gig.cpp:2765
void UpdateChunks(uint8_t *pData) const
Definition: gig.cpp:4014
Sample * GetSample()
Returns pointer address to the Sample referenced with this region.
Definition: gig.cpp:3868
void SetVelocityResponseCurve(curve_type_t curve)
Updates the respective member variable and the lookup table / cache that depends on this value...
Definition: gig.cpp:2781
double EG1Attack
Attack time of the sample amplitude EG (0.000 - 60.000s).
Definition: gig.h:362
bool IsDrum
Indicates if the Instrument is a drum type, as they differ in the synthesis model of DLS from melodic...
Definition: DLS.h:460
void DeleteScriptGroup(ScriptGroup *pGroup)
Delete an instrument script group.
Definition: gig.cpp:5747
Region * GetNextRegion()
Returns the next Region of the instrument.
Definition: gig.cpp:4620
void AddSampleLoop(sample_loop_t *pLoopDef)
Adds a new sample loop with the provided loop definition.
Definition: DLS.cpp:623