libgig  4.3.0
gig.h
1 /***************************************************************************
2  * *
3  * libgig - C++ cross-platform Gigasampler format file access library *
4  * *
5  * Copyright (C) 2003-2020 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 #include <array> // since C++11
30 
31 #ifndef __has_feature
32 # define __has_feature(x) 0
33 #endif
34 #ifndef HAVE_RTTI
35 # if __GXX_RTTI || __has_feature(cxx_rtti) || _CPPRTTI
36 # define HAVE_RTTI 1
37 # else
38 # define HAVE_RTTI 0
39 # endif
40 #endif
41 #if HAVE_RTTI
42 # include <typeinfo>
43 #else
44 # warning No RTTI available!
45 #endif
46 
47 #if WORDS_BIGENDIAN
48 # define LIST_TYPE_3PRG 0x33707267
49 # define LIST_TYPE_3EWL 0x3365776C
50 # define LIST_TYPE_3GRI 0x33677269
51 # define LIST_TYPE_3GNL 0x33676E6C
52 # define LIST_TYPE_3LS 0x334c5320 // own gig format extension
53 # define LIST_TYPE_RTIS 0x52544953 // own gig format extension
54 # define LIST_TYPE_3DNM 0x33646e6d
55 # define CHUNK_ID_3GIX 0x33676978
56 # define CHUNK_ID_3EWA 0x33657761
57 # define CHUNK_ID_3LNK 0x336C6E6B
58 # define CHUNK_ID_3EWG 0x33657767
59 # define CHUNK_ID_EWAV 0x65776176
60 # define CHUNK_ID_3GNM 0x33676E6D
61 # define CHUNK_ID_EINF 0x65696E66
62 # define CHUNK_ID_3CRC 0x33637263
63 # define CHUNK_ID_SCRI 0x53637269 // own gig format extension
64 # define CHUNK_ID_LSNM 0x4c534e4d // own gig format extension
65 # define CHUNK_ID_SCSL 0x5343534c // own gig format extension
66 # define CHUNK_ID_SCPV 0x53435056 // own gig format extension
67 # define CHUNK_ID_LSDE 0x4c534445 // own gig format extension
68 # define CHUNK_ID_3DDP 0x33646470
69 #else // little endian
70 # define LIST_TYPE_3PRG 0x67727033
71 # define LIST_TYPE_3EWL 0x6C776533
72 # define LIST_TYPE_3GRI 0x69726733
73 # define LIST_TYPE_3GNL 0x6C6E6733
74 # define LIST_TYPE_3LS 0x20534c33 // own gig format extension
75 # define LIST_TYPE_RTIS 0x53495452 // own gig format extension
76 # define LIST_TYPE_3DNM 0x6d6e6433
77 # define CHUNK_ID_3GIX 0x78696733
78 # define CHUNK_ID_3EWA 0x61776533
79 # define CHUNK_ID_3LNK 0x6B6E6C33
80 # define CHUNK_ID_3EWG 0x67776533
81 # define CHUNK_ID_EWAV 0x76617765
82 # define CHUNK_ID_3GNM 0x6D6E6733
83 # define CHUNK_ID_EINF 0x666E6965
84 # define CHUNK_ID_3CRC 0x63726333
85 # define CHUNK_ID_SCRI 0x69726353 // own gig format extension
86 # define CHUNK_ID_LSNM 0x4d4e534c // own gig format extension
87 # define CHUNK_ID_SCSL 0x4c534353 // own gig format extension
88 # define CHUNK_ID_SCPV 0x56504353 // own gig format extension
89 # define CHUNK_ID_LSDE 0x4544534c // own gig format extension
90 # define CHUNK_ID_3DDP 0x70646433
91 #endif // WORDS_BIGENDIAN
92 
93 #ifndef GIG_DECLARE_ENUM
94 # define GIG_DECLARE_ENUM(type, ...) enum type { __VA_ARGS__ }
95 #endif
96 
97 // just symbol prototyping (since Serialization.h not included by default here)
98 namespace Serialization { class Archive; }
99 
101 namespace gig {
102 
103  typedef std::string String;
104  typedef RIFF::progress_t progress_t;
105  typedef RIFF::file_offset_t file_offset_t;
106 
108  struct range_t {
109  uint8_t low;
110  uint8_t high;
111  };
112 
114  struct buffer_t {
115  void* pStart;
116  file_offset_t Size;
117  file_offset_t NullExtensionSize;
118  buffer_t() {
119  pStart = NULL;
120  Size = 0;
121  NullExtensionSize = 0;
122  }
123  };
124 
129  GIG_DECLARE_ENUM(loop_type_t,
130  loop_type_normal = 0x00000000,
131  loop_type_bidirectional = 0x00000001,
132  loop_type_backward = 0x00000002
133  );
134 
139  GIG_DECLARE_ENUM(smpte_format_t,
140  smpte_format_no_offset = 0x00000000,
141  smpte_format_24_frames = 0x00000018,
142  smpte_format_25_frames = 0x00000019,
143  smpte_format_30_frames_dropping = 0x0000001D,
144  smpte_format_30_frames = 0x0000001E
145  );
146 
151  GIG_DECLARE_ENUM(curve_type_t,
152  curve_type_nonlinear = 0,
153  curve_type_linear = 1,
154  curve_type_special = 2,
155  curve_type_unknown = 0xffffffff
156  );
157 
168  GIG_DECLARE_ENUM(lfo_wave_t,
169  lfo_wave_sine = 0,
170  lfo_wave_triangle = 1,
171  lfo_wave_saw = 2,
172  lfo_wave_square = 3,
173  );
174 
179  GIG_DECLARE_ENUM(dim_bypass_ctrl_t,
180  dim_bypass_ctrl_none,
181  dim_bypass_ctrl_94,
182  dim_bypass_ctrl_95
183  );
184 
189  GIG_DECLARE_ENUM(lfo3_ctrl_t,
190  lfo3_ctrl_internal = 0x00,
191  lfo3_ctrl_modwheel = 0x01,
192  lfo3_ctrl_aftertouch = 0x02,
193  lfo3_ctrl_internal_modwheel = 0x03,
194  lfo3_ctrl_internal_aftertouch = 0x04
195  );
196 
201  GIG_DECLARE_ENUM(lfo2_ctrl_t,
202  lfo2_ctrl_internal = 0x00,
203  lfo2_ctrl_modwheel = 0x01,
204  lfo2_ctrl_foot = 0x02,
205  lfo2_ctrl_internal_modwheel = 0x03,
206  lfo2_ctrl_internal_foot = 0x04
207  );
208 
213  GIG_DECLARE_ENUM(lfo1_ctrl_t,
214  lfo1_ctrl_internal = 0x00,
215  lfo1_ctrl_modwheel = 0x01,
216  lfo1_ctrl_breath = 0x02,
217  lfo1_ctrl_internal_modwheel = 0x03,
218  lfo1_ctrl_internal_breath = 0x04
219  );
220 
225  GIG_DECLARE_ENUM(vcf_cutoff_ctrl_t,
226  vcf_cutoff_ctrl_none = 0x00,
227  vcf_cutoff_ctrl_none2 = 0x01,
228  vcf_cutoff_ctrl_modwheel = 0x81,
229  vcf_cutoff_ctrl_effect1 = 0x8c,
230  vcf_cutoff_ctrl_effect2 = 0x8d,
231  vcf_cutoff_ctrl_breath = 0x82,
232  vcf_cutoff_ctrl_foot = 0x84,
233  vcf_cutoff_ctrl_sustainpedal = 0xc0,
234  vcf_cutoff_ctrl_softpedal = 0xc3,
235  vcf_cutoff_ctrl_genpurpose7 = 0xd2,
236  vcf_cutoff_ctrl_genpurpose8 = 0xd3,
237  vcf_cutoff_ctrl_aftertouch = 0x80
238  );
239 
244  GIG_DECLARE_ENUM(vcf_res_ctrl_t,
245  vcf_res_ctrl_none = 0xffffffff,
246  vcf_res_ctrl_genpurpose3 = 0,
247  vcf_res_ctrl_genpurpose4 = 1,
248  vcf_res_ctrl_genpurpose5 = 2,
249  vcf_res_ctrl_genpurpose6 = 3
250  );
251 
260  struct leverage_ctrl_t {
265  GIG_DECLARE_ENUM(type_t,
266  type_none = 0x00,
267  type_channelaftertouch = 0x2f,
268  type_velocity = 0xff,
269  type_controlchange = 0xfe
270  );
271 
272  type_t type;
273  uint controller_number;
274 
275  void serialize(Serialization::Archive* archive);
276  };
277 
283  typedef leverage_ctrl_t attenuation_ctrl_t;
284 
290  typedef leverage_ctrl_t eg1_ctrl_t;
291 
297  typedef leverage_ctrl_t eg2_ctrl_t;
298 
308  GIG_DECLARE_ENUM(dimension_t,
309  dimension_none = 0x00,
310  dimension_samplechannel = 0x80,
311  dimension_layer = 0x81,
312  dimension_velocity = 0x82,
313  dimension_channelaftertouch = 0x83,
314  dimension_releasetrigger = 0x84,
315  dimension_keyboard = 0x85,
316  dimension_roundrobin = 0x86,
317  dimension_random = 0x87,
318  dimension_smartmidi = 0x88,
319  dimension_roundrobinkeyboard = 0x89,
320  dimension_modwheel = 0x01,
321  dimension_breath = 0x02,
322  dimension_foot = 0x04,
323  dimension_portamentotime = 0x05,
324  dimension_effect1 = 0x0c,
325  dimension_effect2 = 0x0d,
326  dimension_genpurpose1 = 0x10,
327  dimension_genpurpose2 = 0x11,
328  dimension_genpurpose3 = 0x12,
329  dimension_genpurpose4 = 0x13,
330  dimension_sustainpedal = 0x40,
331  dimension_portamento = 0x41,
332  dimension_sostenutopedal = 0x42,
333  dimension_softpedal = 0x43,
334  dimension_genpurpose5 = 0x30,
335  dimension_genpurpose6 = 0x31,
336  dimension_genpurpose7 = 0x32,
337  dimension_genpurpose8 = 0x33,
338  dimension_effect1depth = 0x5b,
339  dimension_effect2depth = 0x5c,
340  dimension_effect3depth = 0x5d,
341  dimension_effect4depth = 0x5e,
342  dimension_effect5depth = 0x5f
343  );
344 
351  GIG_DECLARE_ENUM(split_type_t,
352  split_type_normal,
353  split_type_bit
354  );
355 
357  struct dimension_def_t {
358  dimension_t dimension;
359  uint8_t bits;
360  uint8_t zones;
361  split_type_t split_type;
362  float zone_size;
363  };
364 
380  GIG_DECLARE_ENUM(vcf_type_t,
381  vcf_type_lowpass = 0x00,
382  vcf_type_lowpassturbo = 0xff,
383  vcf_type_bandpass = 0x01,
384  vcf_type_highpass = 0x02,
385  vcf_type_bandreject = 0x03,
386  vcf_type_lowpass_1p = 0x11,
387  vcf_type_lowpass_2p = 0x12,
388  vcf_type_lowpass_4p = 0x14,
389  vcf_type_lowpass_6p = 0x16,
390  vcf_type_highpass_1p = 0x21,
391  vcf_type_highpass_2p = 0x22,
392  vcf_type_highpass_4p = 0x24,
393  vcf_type_highpass_6p = 0x26,
394  vcf_type_bandpass_2p = 0x32,
395  vcf_type_bandreject_2p = 0x42
396  );
397 
405  struct crossfade_t {
406  #if WORDS_BIGENDIAN
407  uint8_t out_end;
408  uint8_t out_start;
409  uint8_t in_end;
410  uint8_t in_start;
411  #else // little endian
412  uint8_t in_start;
413  uint8_t in_end;
414  uint8_t out_start;
415  uint8_t out_end;
416  #endif // WORDS_BIGENDIAN
417 
418  void serialize(Serialization::Archive* archive);
419  };
420 
422  struct playback_state_t {
423  file_offset_t position;
424  bool reverse;
425  file_offset_t loop_cycles_left;
426  };
427 
451  struct eg_opt_t {
452  bool AttackCancel;
453  bool AttackHoldCancel;
454  bool Decay1Cancel;
455  bool Decay2Cancel;
456  bool ReleaseCancel;
457 
458  eg_opt_t();
459  void serialize(Serialization::Archive* archive);
460  };
461 
478  GIG_DECLARE_ENUM(sust_rel_trg_t,
479  sust_rel_trg_none = 0x00,
480  sust_rel_trg_maxvelocity = 0x01,
481  sust_rel_trg_keyvelocity = 0x02
482  );
483 
484  // just symbol prototyping
485  class File;
486  class Instrument;
487  class Sample;
488  class Region;
489  class Group;
490  class Script;
491  class ScriptGroup;
492 
535  class DimensionRegion : protected DLS::Sampler {
536  public:
537  uint8_t VelocityUpperLimit;
538  Sample* pSample;
539  // Sample Amplitude EG/LFO
540  uint16_t EG1PreAttack;
541  double EG1Attack;
542  double EG1Decay1;
543  double EG1Decay2;
544  bool EG1InfiniteSustain;
545  uint16_t EG1Sustain;
546  double EG1Release;
547  bool EG1Hold;
548  eg1_ctrl_t EG1Controller;
549  bool EG1ControllerInvert;
550  uint8_t EG1ControllerAttackInfluence;
551  uint8_t EG1ControllerDecayInfluence;
552  uint8_t EG1ControllerReleaseInfluence;
553  lfo_wave_t LFO1WaveForm;
554  double LFO1Frequency;
555  double LFO1Phase;
556  uint16_t LFO1InternalDepth;
557  uint16_t LFO1ControlDepth;
558  lfo1_ctrl_t LFO1Controller;
559  bool LFO1FlipPhase;
560  bool LFO1Sync;
561  // Filter Cutoff Frequency EG/LFO
562  uint16_t EG2PreAttack;
563  double EG2Attack;
564  double EG2Decay1;
565  double EG2Decay2;
566  bool EG2InfiniteSustain;
567  uint16_t EG2Sustain;
568  double EG2Release;
569  eg2_ctrl_t EG2Controller;
570  bool EG2ControllerInvert;
571  uint8_t EG2ControllerAttackInfluence;
572  uint8_t EG2ControllerDecayInfluence;
573  uint8_t EG2ControllerReleaseInfluence;
574  lfo_wave_t LFO2WaveForm;
575  double LFO2Frequency;
576  double LFO2Phase;
577  uint16_t LFO2InternalDepth;
578  uint16_t LFO2ControlDepth;
579  lfo2_ctrl_t LFO2Controller;
580  bool LFO2FlipPhase;
581  bool LFO2Sync;
582  // Sample Pitch EG/LFO
583  double EG3Attack;
584  int16_t EG3Depth;
585  lfo_wave_t LFO3WaveForm;
586  double LFO3Frequency;
587  double LFO3Phase;
588  int16_t LFO3InternalDepth;
589  int16_t LFO3ControlDepth;
590  lfo3_ctrl_t LFO3Controller;
591  bool LFO3FlipPhase;
592  bool LFO3Sync;
593  // Filter
594  bool VCFEnabled;
595  vcf_type_t VCFType;
596  vcf_cutoff_ctrl_t VCFCutoffController;
597  bool VCFCutoffControllerInvert;
598  uint8_t VCFCutoff;
599  curve_type_t VCFVelocityCurve;
600  uint8_t VCFVelocityScale;
601  uint8_t VCFVelocityDynamicRange;
602  uint8_t VCFResonance;
603  bool VCFResonanceDynamic;
604  vcf_res_ctrl_t VCFResonanceController;
605  bool VCFKeyboardTracking;
606  uint8_t VCFKeyboardTrackingBreakpoint;
607  // Key Velocity Transformations
608  curve_type_t VelocityResponseCurve;
609  uint8_t VelocityResponseDepth;
610  uint8_t VelocityResponseCurveScaling;
611  curve_type_t ReleaseVelocityResponseCurve;
612  uint8_t ReleaseVelocityResponseDepth;
613  uint8_t ReleaseTriggerDecay;
614  // Mix / Layer
615  crossfade_t Crossfade;
616  bool PitchTrack;
617  dim_bypass_ctrl_t DimensionBypass;
618  int8_t Pan;
619  bool SelfMask;
620  attenuation_ctrl_t AttenuationController;
621  bool InvertAttenuationController;
622  uint8_t AttenuationControllerThreshold;
623  uint8_t ChannelOffset;
624  bool SustainDefeat;
625  bool MSDecode;
626  uint16_t SampleStartOffset;
627  double SampleAttenuation;
628  uint8_t DimensionUpperLimits[8];
629  eg_opt_t EG1Options;
630  eg_opt_t EG2Options;
631  sust_rel_trg_t SustainReleaseTrigger;
632  bool NoNoteOffReleaseTrigger;
633 
634  // derived attributes from DLS::Sampler
635  using DLS::Sampler::UnityNote;
636  using DLS::Sampler::FineTune;
637  using DLS::Sampler::Gain;
638  using DLS::Sampler::SampleLoops;
639  using DLS::Sampler::pSampleLoops;
640 
641  // own methods
642  double GetVelocityAttenuation(uint8_t MIDIKeyVelocity);
643  double GetVelocityRelease(uint8_t MIDIKeyVelocity);
644  double GetVelocityCutoff(uint8_t MIDIKeyVelocity);
645  void SetVelocityResponseCurve(curve_type_t curve);
646  void SetVelocityResponseDepth(uint8_t depth);
647  void SetVelocityResponseCurveScaling(uint8_t scaling);
648  void SetReleaseVelocityResponseCurve(curve_type_t curve);
649  void SetReleaseVelocityResponseDepth(uint8_t depth);
650  void SetVCFCutoffController(vcf_cutoff_ctrl_t controller);
651  void SetVCFVelocityCurve(curve_type_t curve);
652  void SetVCFVelocityDynamicRange(uint8_t range);
653  void SetVCFVelocityScale(uint8_t scaling);
654  Region* GetParent() const;
655  // derived methods
656  using DLS::Sampler::AddSampleLoop;
657  using DLS::Sampler::DeleteSampleLoop;
658  // overridden methods
659  virtual void SetGain(int32_t gain) OVERRIDE;
660  virtual void UpdateChunks(progress_t* pProgress) OVERRIDE;
661  virtual void CopyAssign(const DimensionRegion* orig);
662  protected:
663  uint8_t* VelocityTable;
664  DimensionRegion(Region* pParent, RIFF::List* _3ewl);
665  DimensionRegion(RIFF::List* _3ewl, const DimensionRegion& src);
666  ~DimensionRegion();
667  void CopyAssign(const DimensionRegion* orig, const std::map<Sample*,Sample*>* mSamples);
668  void serialize(Serialization::Archive* archive);
669  friend class Region;
670  friend class Serialization::Archive;
671  private:
672  typedef enum {
673  // official leverage controllers as they were defined in the original Gigasampler/GigaStudio format:
674  _lev_ctrl_none = 0x00,
675  _lev_ctrl_modwheel = 0x03,
676  _lev_ctrl_breath = 0x05,
677  _lev_ctrl_foot = 0x07,
678  _lev_ctrl_effect1 = 0x0d,
679  _lev_ctrl_effect2 = 0x0f,
680  _lev_ctrl_genpurpose1 = 0x11,
681  _lev_ctrl_genpurpose2 = 0x13,
682  _lev_ctrl_genpurpose3 = 0x15,
683  _lev_ctrl_genpurpose4 = 0x17,
684  _lev_ctrl_portamentotime = 0x0b,
685  _lev_ctrl_sustainpedal = 0x01,
686  _lev_ctrl_portamento = 0x19,
687  _lev_ctrl_sostenutopedal = 0x1b,
688  _lev_ctrl_softpedal = 0x09,
689  _lev_ctrl_genpurpose5 = 0x1d,
690  _lev_ctrl_genpurpose6 = 0x1f,
691  _lev_ctrl_genpurpose7 = 0x21,
692  _lev_ctrl_genpurpose8 = 0x23,
693  _lev_ctrl_effect1depth = 0x25,
694  _lev_ctrl_effect2depth = 0x27,
695  _lev_ctrl_effect3depth = 0x29,
696  _lev_ctrl_effect4depth = 0x2b,
697  _lev_ctrl_effect5depth = 0x2d,
698  _lev_ctrl_channelaftertouch = 0x2f,
699  _lev_ctrl_velocity = 0xff,
700 
701  // format extension (these controllers are so far only supported by LinuxSampler & gigedit) they will *NOT* work with Gigasampler/GigaStudio !
702  // (the assigned values here are their official MIDI CC number plus the highest bit set):
703  _lev_ctrl_CC3_EXT = 0x83,
704 
705  _lev_ctrl_CC6_EXT = 0x86,
706  _lev_ctrl_CC7_EXT = 0x87,
707  _lev_ctrl_CC8_EXT = 0x88,
708  _lev_ctrl_CC9_EXT = 0x89,
709  _lev_ctrl_CC10_EXT = 0x8a,
710  _lev_ctrl_CC11_EXT = 0x8b,
711 
712  _lev_ctrl_CC14_EXT = 0x8e,
713  _lev_ctrl_CC15_EXT = 0x8f,
714 
715  _lev_ctrl_CC20_EXT = 0x94,
716  _lev_ctrl_CC21_EXT = 0x95,
717  _lev_ctrl_CC22_EXT = 0x96,
718  _lev_ctrl_CC23_EXT = 0x97,
719  _lev_ctrl_CC24_EXT = 0x98,
720  _lev_ctrl_CC25_EXT = 0x99,
721  _lev_ctrl_CC26_EXT = 0x9a,
722  _lev_ctrl_CC27_EXT = 0x9b,
723  _lev_ctrl_CC28_EXT = 0x9c,
724  _lev_ctrl_CC29_EXT = 0x9d,
725  _lev_ctrl_CC30_EXT = 0x9e,
726  _lev_ctrl_CC31_EXT = 0x9f,
727 
728  _lev_ctrl_CC68_EXT = 0xc4,
729  _lev_ctrl_CC69_EXT = 0xc5,
730  _lev_ctrl_CC70_EXT = 0xc6,
731  _lev_ctrl_CC71_EXT = 0xc7,
732  _lev_ctrl_CC72_EXT = 0xc8,
733  _lev_ctrl_CC73_EXT = 0xc9,
734  _lev_ctrl_CC74_EXT = 0xca,
735  _lev_ctrl_CC75_EXT = 0xcb,
736  _lev_ctrl_CC76_EXT = 0xcc,
737  _lev_ctrl_CC77_EXT = 0xcd,
738  _lev_ctrl_CC78_EXT = 0xce,
739  _lev_ctrl_CC79_EXT = 0xcf,
740 
741  _lev_ctrl_CC84_EXT = 0xd4,
742  _lev_ctrl_CC85_EXT = 0xd5,
743  _lev_ctrl_CC86_EXT = 0xd6,
744  _lev_ctrl_CC87_EXT = 0xd7,
745 
746  _lev_ctrl_CC89_EXT = 0xd9,
747  _lev_ctrl_CC90_EXT = 0xda,
748 
749  _lev_ctrl_CC96_EXT = 0xe0,
750  _lev_ctrl_CC97_EXT = 0xe1,
751 
752  _lev_ctrl_CC102_EXT = 0xe6,
753  _lev_ctrl_CC103_EXT = 0xe7,
754  _lev_ctrl_CC104_EXT = 0xe8,
755  _lev_ctrl_CC105_EXT = 0xe9,
756  _lev_ctrl_CC106_EXT = 0xea,
757  _lev_ctrl_CC107_EXT = 0xeb,
758  _lev_ctrl_CC108_EXT = 0xec,
759  _lev_ctrl_CC109_EXT = 0xed,
760  _lev_ctrl_CC110_EXT = 0xee,
761  _lev_ctrl_CC111_EXT = 0xef,
762  _lev_ctrl_CC112_EXT = 0xf0,
763  _lev_ctrl_CC113_EXT = 0xf1,
764  _lev_ctrl_CC114_EXT = 0xf2,
765  _lev_ctrl_CC115_EXT = 0xf3,
766  _lev_ctrl_CC116_EXT = 0xf4,
767  _lev_ctrl_CC117_EXT = 0xf5,
768  _lev_ctrl_CC118_EXT = 0xf6,
769  _lev_ctrl_CC119_EXT = 0xf7
770  } _lev_ctrl_t;
771  typedef std::map<uint32_t, double*> VelocityTableMap;
772 
773  static size_t Instances;
774  static VelocityTableMap* pVelocityTables;
775  double* pVelocityAttenuationTable;
776  double* pVelocityReleaseTable;
777  double* pVelocityCutoffTable;
778  Region* pRegion;
779 
780  leverage_ctrl_t DecodeLeverageController(_lev_ctrl_t EncodedController);
781  _lev_ctrl_t EncodeLeverageController(leverage_ctrl_t DecodedController);
782  double* GetReleaseVelocityTable(curve_type_t releaseVelocityResponseCurve, uint8_t releaseVelocityResponseDepth);
783  double* GetCutoffVelocityTable(curve_type_t vcfVelocityCurve, uint8_t vcfVelocityDynamicRange, uint8_t vcfVelocityScale, vcf_cutoff_ctrl_t vcfCutoffController);
784  double* GetVelocityTable(curve_type_t curveType, uint8_t depth, uint8_t scaling);
785  double* CreateVelocityTable(curve_type_t curveType, uint8_t depth, uint8_t scaling);
786  bool UsesAnyGigFormatExtension() const;
787  };
788 
814  class Sample : public DLS::Sample {
815  public:
816  uint32_t Manufacturer;
817  uint32_t Product;
818  uint32_t SamplePeriod;
819  uint32_t MIDIUnityNote;
820  uint32_t FineTune;
821  smpte_format_t SMPTEFormat;
822  uint32_t SMPTEOffset;
823  uint32_t Loops;
824  uint32_t LoopID;
825  loop_type_t LoopType;
826  uint32_t LoopStart;
827  uint32_t LoopEnd;
828  uint32_t LoopSize;
829  uint32_t LoopFraction;
830  uint32_t LoopPlayCount;
831  bool Compressed;
832  uint32_t TruncatedBits;
833  bool Dithered;
834 
835  // own methods
836  buffer_t LoadSampleData();
837  buffer_t LoadSampleData(file_offset_t SampleCount);
838  buffer_t LoadSampleDataWithNullSamplesExtension(uint NullSamplesCount);
839  buffer_t LoadSampleDataWithNullSamplesExtension(file_offset_t SampleCount, uint NullSamplesCount);
840  buffer_t GetCache();
841  // own static methods
842  static buffer_t CreateDecompressionBuffer(file_offset_t MaxReadSize);
843  static void DestroyDecompressionBuffer(buffer_t& DecompressionBuffer);
844  // overridden methods
845  void ReleaseSampleData();
846  void Resize(file_offset_t NewSize);
847  file_offset_t SetPos(file_offset_t SampleCount, RIFF::stream_whence_t Whence = RIFF::stream_start);
848  file_offset_t GetPos() const;
849  file_offset_t Read(void* pBuffer, file_offset_t SampleCount, buffer_t* pExternalDecompressionBuffer = NULL);
850  file_offset_t ReadAndLoop(void* pBuffer, file_offset_t SampleCount, playback_state_t* pPlaybackState, DimensionRegion* pDimRgn, buffer_t* pExternalDecompressionBuffer = NULL);
851  file_offset_t Write(void* pBuffer, file_offset_t SampleCount);
852  Group* GetGroup() const;
853  virtual void UpdateChunks(progress_t* pProgress) OVERRIDE;
854  void CopyAssignMeta(const Sample* orig);
855  void CopyAssignWave(const Sample* orig);
856  uint32_t GetWaveDataCRC32Checksum();
857  bool VerifyWaveData(uint32_t* pActually = NULL);
858  protected:
859  static size_t Instances;
860  static buffer_t InternalDecompressionBuffer;
861  Group* pGroup;
862  file_offset_t FrameOffset;
863  file_offset_t* FrameTable;
864  file_offset_t SamplePos;
865  file_offset_t SamplesInLastFrame;
866  file_offset_t WorstCaseFrameSize;
867  file_offset_t SamplesPerFrame;
868  buffer_t RAMCache;
869  unsigned long FileNo;
870  RIFF::Chunk* pCk3gix;
871  RIFF::Chunk* pCkSmpl;
872  uint32_t crc;
873 
874  Sample(File* pFile, RIFF::List* waveList, file_offset_t WavePoolOffset, unsigned long fileNo = 0, int index = -1);
875  ~Sample();
876  uint32_t CalculateWaveDataChecksum();
877 
878  // Guess size (in bytes) of a compressed sample
879  inline file_offset_t GuessSize(file_offset_t samples) {
880  // 16 bit: assume all frames are compressed - 1 byte
881  // per sample and 5 bytes header per 2048 samples
882 
883  // 24 bit: assume next best compression rate - 1.5
884  // bytes per sample and 13 bytes header per 256
885  // samples
886  const file_offset_t size =
887  BitDepth == 24 ? samples + (samples >> 1) + (samples >> 8) * 13
888  : samples + (samples >> 10) * 5;
889  // Double for stereo and add one worst case sample
890  // frame
891  return (Channels == 2 ? size << 1 : size) + WorstCaseFrameSize;
892  }
893 
894  // Worst case amount of sample points that can be read with the
895  // given decompression buffer.
896  inline file_offset_t WorstCaseMaxSamples(buffer_t* pDecompressionBuffer) {
897  return (file_offset_t) ((float)pDecompressionBuffer->Size / (float)WorstCaseFrameSize * (float)SamplesPerFrame);
898  }
899  private:
900  void ScanCompressedSample();
901  friend class File;
902  friend class Region;
903  friend class Group; // allow to modify protected member pGroup
904  };
905 
906  // TODO: <3dnl> list not used yet - not important though (just contains optional descriptions for the dimensions)
927  class Region : public DLS::Region {
928  public:
929  unsigned int Dimensions;
930  dimension_def_t pDimensionDefinitions[8];
931  uint32_t DimensionRegions;
932  DimensionRegion* pDimensionRegions[256];
933  unsigned int Layers;
934 
935  // own methods
936  DimensionRegion* GetDimensionRegionByValue(const uint DimValues[8]);
937  DimensionRegion* GetDimensionRegionByBit(const uint8_t DimBits[8]);
938  int GetDimensionRegionIndexByValue(const uint DimValues[8]);
939  Sample* GetSample();
940  void AddDimension(dimension_def_t* pDimDef);
941  void DeleteDimension(dimension_def_t* pDimDef);
942  dimension_def_t* GetDimensionDefinition(dimension_t type);
943  void DeleteDimensionZone(dimension_t type, int zone);
944  void SplitDimensionZone(dimension_t type, int zone);
945  void SetDimensionType(dimension_t oldType, dimension_t newType);
946  // overridden methods
947  virtual void SetKeyRange(uint16_t Low, uint16_t High) OVERRIDE;
948  virtual void UpdateChunks(progress_t* pProgress) OVERRIDE;
949  virtual void CopyAssign(const Region* orig);
950  protected:
951  Region(Instrument* pInstrument, RIFF::List* rgnList);
952  void LoadDimensionRegions(RIFF::List* rgn);
953  void UpdateVelocityTable();
954  Sample* GetSampleFromWavePool(unsigned int WavePoolTableIndex, progress_t* pProgress = NULL);
955  void CopyAssign(const Region* orig, const std::map<Sample*,Sample*>* mSamples);
956  DimensionRegion* GetDimensionRegionByBit(const std::map<dimension_t,int>& DimCase);
957  ~Region();
958  friend class Instrument;
959  private:
960  bool UsesAnyGigFormatExtension() const;
961  };
962 
1005  class MidiRule {
1006  public:
1007  virtual ~MidiRule() { }
1008  protected:
1009  virtual void UpdateChunks(uint8_t* pData) const = 0;
1010  friend class Instrument;
1011  };
1012 
1026  class MidiRuleCtrlTrigger : public MidiRule {
1027  public:
1028  uint8_t ControllerNumber;
1029  uint8_t Triggers;
1030  struct trigger_t {
1031  uint8_t TriggerPoint;
1032  bool Descending;
1033  uint8_t VelSensitivity;
1034  uint8_t Key;
1035  bool NoteOff;
1036  uint8_t Velocity;
1037  bool OverridePedal;
1038  } pTriggers[32];
1039 
1040  protected:
1041  MidiRuleCtrlTrigger(RIFF::Chunk* _3ewg);
1042  MidiRuleCtrlTrigger();
1043  void UpdateChunks(uint8_t* pData) const OVERRIDE;
1044  friend class Instrument;
1045  };
1046 
1067  class MidiRuleLegato : public MidiRule {
1068  public:
1069  uint8_t LegatoSamples;
1070  bool BypassUseController;
1071  uint8_t BypassKey;
1072  uint8_t BypassController;
1073  uint16_t ThresholdTime;
1074  uint16_t ReleaseTime;
1075  range_t KeyRange;
1076  uint8_t ReleaseTriggerKey;
1077  uint8_t AltSustain1Key;
1078  uint8_t AltSustain2Key;
1079 
1080  protected:
1081  MidiRuleLegato(RIFF::Chunk* _3ewg);
1082  MidiRuleLegato();
1083  void UpdateChunks(uint8_t* pData) const OVERRIDE;
1084  friend class Instrument;
1085  };
1086 
1099  class MidiRuleAlternator : public MidiRule {
1100  public:
1101  uint8_t Articulations;
1102  String pArticulations[32];
1103 
1104  range_t PlayRange;
1105 
1106  uint8_t Patterns;
1107  struct pattern_t {
1108  String Name;
1109  int Size;
1110  const uint8_t& operator[](int i) const {
1111  return data[i];
1112  }
1113  uint8_t& operator[](int i) {
1114  return data[i];
1115  }
1116  private:
1117  uint8_t data[32];
1118  } pPatterns[32];
1119 
1120  typedef enum {
1121  selector_none,
1122  selector_key_switch,
1123  selector_controller
1124  } selector_t;
1125  selector_t Selector;
1126  range_t KeySwitchRange;
1127  uint8_t Controller;
1128 
1129  bool Polyphonic;
1130  bool Chained;
1131 
1132  protected:
1133  MidiRuleAlternator(RIFF::Chunk* _3ewg);
1134  MidiRuleAlternator();
1135  void UpdateChunks(uint8_t* pData) const OVERRIDE;
1136  friend class Instrument;
1137  };
1138 
1152  class MidiRuleUnknown : public MidiRule {
1153  protected:
1154  MidiRuleUnknown() { }
1155  void UpdateChunks(uint8_t* pData) const OVERRIDE { }
1156  friend class Instrument;
1157  };
1158 
1179  class Script : protected DLS::Storage {
1180  public:
1181  enum Encoding_t {
1182  ENCODING_ASCII = 0
1183  };
1184  enum Compression_t {
1185  COMPRESSION_NONE = 0
1186  };
1187  enum Language_t {
1188  LANGUAGE_NKSP = 0
1189  };
1190 
1191  String Name;
1192  Compression_t Compression;
1193  Encoding_t Encoding;
1194  Language_t Language;
1195  bool Bypass;
1196  uint8_t Uuid[16];
1197 
1198  String GetScriptAsText();
1199  void SetScriptAsText(const String& text);
1200  void SetGroup(ScriptGroup* pGroup);
1201  ScriptGroup* GetGroup() const;
1202  void CopyAssign(const Script* orig);
1203  protected:
1204  Script(ScriptGroup* group, RIFF::Chunk* ckScri);
1205  virtual ~Script();
1206  void UpdateChunks(progress_t* pProgress) OVERRIDE;
1207  void DeleteChunks() OVERRIDE;
1208  void RemoveAllScriptReferences();
1209  void GenerateUuid();
1210  friend class ScriptGroup;
1211  friend class Instrument;
1212  private:
1213  ScriptGroup* pGroup;
1214  RIFF::Chunk* pChunk;
1215  std::vector<uint8_t> data;
1216  uint32_t crc;
1217  };
1218 
1230  class ScriptGroup : protected DLS::Storage {
1231  public:
1232  String Name;
1233 
1234  Script* GetScript(uint index);
1235  Script* AddScript();
1236  void DeleteScript(Script* pScript);
1237  protected:
1238  ScriptGroup(File* file, RIFF::List* lstRTIS);
1239  virtual ~ScriptGroup();
1240  void LoadScripts();
1241  virtual void UpdateChunks(progress_t* pProgress) OVERRIDE;
1242  virtual void DeleteChunks() OVERRIDE;
1243  friend class Script;
1244  friend class File;
1245  private:
1246  File* pFile;
1247  RIFF::List* pList;
1248  std::list<Script*>* pScripts;
1249  };
1250 
1266  class Instrument : protected DLS::Instrument {
1267  public:
1268  // derived attributes from DLS::Resource
1269  using DLS::Resource::pInfo;
1270  using DLS::Resource::pDLSID;
1271  // derived attributes from DLS::Instrument
1272  using DLS::Instrument::IsDrum;
1273  using DLS::Instrument::MIDIBank;
1274  using DLS::Instrument::MIDIBankCoarse;
1275  using DLS::Instrument::MIDIBankFine;
1276  using DLS::Instrument::MIDIProgram;
1277  using DLS::Instrument::Regions;
1278  // own attributes
1279  int32_t Attenuation;
1280  uint16_t EffectSend;
1281  int16_t FineTune;
1282  uint16_t PitchbendRange;
1283  bool PianoReleaseMode;
1284  range_t DimensionKeyRange;
1285 
1286 
1287  // derived methods from DLS::Resource
1288  using DLS::Resource::GetParent;
1289  // overridden methods
1290  Region* GetFirstRegion();
1291  Region* GetNextRegion();
1292  Region* AddRegion();
1293  void DeleteRegion(Region* pRegion);
1294  void MoveTo(Instrument* dst);
1295  virtual void UpdateChunks(progress_t* pProgress) OVERRIDE;
1296  virtual void CopyAssign(const Instrument* orig);
1297  // own methods
1298  Region* GetRegion(unsigned int Key);
1299  MidiRule* GetMidiRule(int i);
1300  MidiRuleCtrlTrigger* AddMidiRuleCtrlTrigger();
1301  MidiRuleLegato* AddMidiRuleLegato();
1302  MidiRuleAlternator* AddMidiRuleAlternator();
1303  void DeleteMidiRule(int i);
1304  // real-time instrument script methods
1305  Script* GetScriptOfSlot(uint index);
1306  void AddScriptSlot(Script* pScript, bool bypass = false);
1307  void SwapScriptSlots(uint index1, uint index2);
1308  void RemoveScriptSlot(uint index);
1309  void RemoveScript(Script* pScript);
1310  uint ScriptSlotCount() const;
1311  bool IsScriptSlotBypassed(uint index);
1312  void SetScriptSlotBypassed(uint index, bool bBypass);
1313  bool IsScriptPatchVariableSet(int slot, String variable);
1314  std::map<String,String> GetScriptPatchVariables(int slot);
1315  String GetScriptPatchVariable(int slot, String variable);
1316  void SetScriptPatchVariable(int slot, String variable, String value);
1317  void UnsetScriptPatchVariable(int slot = -1, String variable = "");
1318  protected:
1319  Region* RegionKeyTable[128];
1320 
1321  Instrument(File* pFile, RIFF::List* insList, progress_t* pProgress = NULL);
1322  ~Instrument();
1323  void CopyAssign(const Instrument* orig, const std::map<Sample*,Sample*>* mSamples);
1324  void UpdateRegionKeyTable();
1325  void LoadScripts();
1326  void UpdateScriptFileOffsets();
1327  friend class File;
1328  friend class Region; // so Region can call UpdateRegionKeyTable()
1329  private:
1330  struct _ScriptPooolEntry {
1331  uint32_t fileOffset;
1332  bool bypass;
1333  };
1334  struct _ScriptPooolRef {
1335  Script* script;
1336  bool bypass;
1337  };
1338  typedef std::array<uint8_t,16> _UUID;
1339  typedef std::map<String,String> _PatchVars;
1340  typedef std::map<int,_PatchVars> _VarsBySlot;
1341  typedef std::map<_UUID,_VarsBySlot> _VarsByScript;
1342  MidiRule** pMidiRules;
1343  std::vector<_ScriptPooolEntry> scriptPoolFileOffsets;
1344  std::vector<_ScriptPooolRef>* pScriptRefs;
1345  _VarsByScript scriptVars;
1346 
1347  _VarsByScript stripScriptVars();
1348  bool ReferencesScriptWithUuid(const _UUID& uuid);
1349  bool UsesAnyGigFormatExtension() const;
1350  };
1351 
1363  class Group : public DLS::Storage {
1364  public:
1365  String Name;
1366 
1367  Sample* GetFirstSample();
1368  Sample* GetNextSample();
1369  void AddSample(Sample* pSample);
1370  protected:
1371  Group(File* file, RIFF::Chunk* ck3gnm);
1372  virtual ~Group();
1373  virtual void UpdateChunks(progress_t* pProgress) OVERRIDE;
1374  virtual void DeleteChunks() OVERRIDE;
1375  void MoveAll();
1376  friend class File;
1377  private:
1378  File* pFile;
1379  RIFF::Chunk* pNameChunk;
1380  };
1381 
1418  class File : protected DLS::File {
1419  public:
1420  static const DLS::version_t VERSION_2;
1421  static const DLS::version_t VERSION_3;
1422  static const DLS::version_t VERSION_4;
1423 
1424  // derived attributes from DLS::Resource
1425  using DLS::Resource::pInfo;
1426  using DLS::Resource::pDLSID;
1427  // derived attributes from DLS::File
1428  using DLS::File::pVersion;
1429  using DLS::File::Instruments;
1430 
1431  // derived methods from DLS::Resource
1432  using DLS::Resource::GetParent;
1433  // derived methods from DLS::File
1434  using DLS::File::Save;
1435  using DLS::File::GetFileName;
1436  using DLS::File::SetFileName;
1437  using DLS::File::GetRiffFile;
1438  // overridden methods
1439  File();
1440  File(RIFF::File* pRIFF);
1441  Sample* GetFirstSample(progress_t* pProgress = NULL);
1442  Sample* GetNextSample();
1443  Sample* GetSample(uint index);
1444  Sample* AddSample();
1445  size_t CountSamples();
1446  void DeleteSample(Sample* pSample);
1447  Instrument* GetFirstInstrument();
1448  Instrument* GetNextInstrument();
1449  Instrument* GetInstrument(uint index, progress_t* pProgress = NULL);
1450  Instrument* AddInstrument();
1451  Instrument* AddDuplicateInstrument(const Instrument* orig);
1452  size_t CountInstruments();
1453  void DeleteInstrument(Instrument* pInstrument);
1454  Group* GetFirstGroup();
1455  Group* GetNextGroup();
1456  Group* GetGroup(uint index);
1457  Group* GetGroup(String name);
1458  Group* AddGroup();
1459  void DeleteGroup(Group* pGroup);
1460  void DeleteGroupOnly(Group* pGroup);
1461  void SetAutoLoad(bool b);
1462  bool GetAutoLoad();
1463  void AddContentOf(File* pFile);
1464  ScriptGroup* GetScriptGroup(uint index);
1465  ScriptGroup* GetScriptGroup(const String& name);
1466  ScriptGroup* AddScriptGroup();
1467  void DeleteScriptGroup(ScriptGroup* pGroup);
1468  virtual ~File();
1469  virtual void UpdateChunks(progress_t* pProgress) OVERRIDE;
1470  protected:
1471  // overridden protected methods from DLS::File
1472  virtual void LoadSamples() OVERRIDE;
1473  virtual void LoadInstruments() OVERRIDE;
1474  virtual void LoadGroups();
1475  virtual void UpdateFileOffsets() OVERRIDE;
1476  // own protected methods
1477  virtual void LoadSamples(progress_t* pProgress);
1478  virtual void LoadInstruments(progress_t* pProgress);
1479  virtual void LoadScriptGroups();
1480  void SetSampleChecksum(Sample* pSample, uint32_t crc);
1481  uint32_t GetSampleChecksum(Sample* pSample);
1482  uint32_t GetSampleChecksumByIndex(int index);
1483  bool VerifySampleChecksumTable();
1484  bool RebuildSampleChecksumTable();
1485  int GetWaveTableIndexOf(gig::Sample* pSample);
1486  friend class Region;
1487  friend class Sample;
1488  friend class Instrument;
1489  friend class Group; // so Group can access protected member pRIFF
1490  friend class ScriptGroup; // so ScriptGroup can access protected member pRIFF
1491  private:
1492  std::list<Group*>* pGroups;
1493  std::list<Group*>::iterator GroupsIterator;
1494  bool bAutoLoad;
1495  std::list<ScriptGroup*>* pScriptGroups;
1496 
1497  bool UsesAnyGigFormatExtension() const;
1498  };
1499 
1508  class Exception : public DLS::Exception {
1509  public:
1510  Exception(String format, ...);
1511  Exception(String format, va_list arg);
1512  void PrintMessage();
1513  protected:
1514  Exception();
1515  };
1516 
1517 #if HAVE_RTTI
1518  size_t enumCount(const std::type_info& type);
1519  const char* enumKey(const std::type_info& type, size_t value);
1520  bool enumKey(const std::type_info& type, String key);
1521  const char** enumKeys(const std::type_info& type);
1522 #endif // HAVE_RTTI
1523  size_t enumCount(String typeName);
1524  const char* enumKey(String typeName, size_t value);
1525  bool enumKey(String typeName, String key);
1526  const char** enumKeys(String typeName);
1527  size_t enumValue(String key);
1528 
1529  String libraryName();
1530  String libraryVersion();
1531 
1532 } // namespace gig
1533 
1534 #endif // __GIG_H__
gig::Sample::~Sample
~Sample()
Destructor.
Definition: gig.cpp:1477
gig::DimensionRegion::InvertAttenuationController
bool InvertAttenuationController
Inverts the values coming from the defined Attenuation Controller.
Definition: gig.h:621
gig::Region::SetDimensionType
void SetDimensionType(dimension_t oldType, dimension_t newType)
Change type of an existing dimension.
Definition: gig.cpp:4102
gig::Sample::Write
file_offset_t Write(void *pBuffer, file_offset_t SampleCount)
Write sample wave data.
Definition: gig.cpp:1329
gig::DimensionRegion::EG2Decay1
double EG2Decay1
Decay time of the filter cutoff EG (0.000 - 60.000s).
Definition: gig.h:564
gig::Instrument
Provides access to a Gigasampler/GigaStudio instrument.
Definition: gig.h:1266
gig::dimension_genpurpose6
@ dimension_genpurpose6
General Purpose Controller 6 (Button, MIDI Controller 81)
Definition: gig.h:343
gig::crossfade_t::in_start
uint8_t in_start
Start position of fade in.
Definition: gig.h:412
gig::Script::Encoding_t
Encoding_t
Definition: gig.h:1181
gig::MidiRuleAlternator::Articulations
uint8_t Articulations
Number of articulations in the instrument.
Definition: gig.h:1101
gig::Sample::SamplesInLastFrame
file_offset_t SamplesInLastFrame
For compressed samples only: length of the last sample frame.
Definition: gig.h:865
gig::Sample::CopyAssignWave
void CopyAssignWave(const Sample *orig)
Should be called after CopyAssignMeta() and File::Save() sequence.
Definition: gig.cpp:546
gig::smpte_format_t
smpte_format_t
Society of Motion Pictures and Television E time format.
Definition: gig.h:145
gig::smpte_format_24_frames
@ smpte_format_24_frames
24 frames per second
Definition: gig.h:145
gig::Sample::GetWaveDataCRC32Checksum
uint32_t GetWaveDataCRC32Checksum()
Returns the CRC-32 checksum of the sample's raw wave form data at the time when this sample's wave fo...
Definition: gig.cpp:1423
gig::lfo2_ctrl_internal
@ lfo2_ctrl_internal
Only internally controlled.
Definition: gig.h:207
gig::Script::Encoding
Encoding_t Encoding
Format the script's source code text is encoded with.
Definition: gig.h:1193
gig::DimensionRegion::LFO2ControlDepth
uint16_t LFO2ControlDepth
Controller depth influencing filter cutoff LFO pitch (0 - 1200).
Definition: gig.h:578
gig::DimensionRegion::EG3Depth
int16_t EG3Depth
Depth of the sample pitch EG (-1200 - +1200).
Definition: gig.h:584
gig::MidiRuleCtrlTrigger::Triggers
uint8_t Triggers
Number of triggers.
Definition: gig.h:1029
gig::range_t
Lower and upper limit of a range.
Definition: gig.h:108
gig::Script::GetGroup
ScriptGroup * GetGroup() const
Returns the script group this script currently belongs to.
Definition: gig.cpp:4746
gig::loop_type_t
loop_type_t
Standard types of sample loops.
Definition: gig.h:133
DLS::Sampler::DeleteSampleLoop
void DeleteSampleLoop(sample_loop_t *pLoopDef)
Deletes an existing sample loop.
Definition: DLS.cpp:728
gig::DimensionRegion::EG2ControllerReleaseInfluence
uint8_t EG2ControllerReleaseInfluence
Amount EG2 Controller has influence on the EG2 Release time (0 - 3, where 0 means off).
Definition: gig.h:573
DLS::Instrument::IsDrum
bool IsDrum
Indicates if the Instrument is a drum type, as they differ in the synthesis model of DLS from melodic...
Definition: DLS.h:525
gig::vcf_type_lowpass_2p
@ vcf_type_lowpass_2p
[gig extension]: 2-pole lowpass filter type (LinuxSampler).
Definition: gig.h:396
gig::Sample::Loops
uint32_t Loops
Caution: Use the respective field in the DimensionRegion instead of this one! (Intended purpose: Numb...
Definition: gig.h:823
gig::Region::pDimensionDefinitions
dimension_def_t pDimensionDefinitions[8]
Defines the five (gig2) or eight (gig3) possible dimensions (the dimension's controller and number of...
Definition: gig.h:930
gig::Sample::LoopEnd
uint32_t LoopEnd
Caution: Use the respective field in the DimensionRegion instead of this one! (Intended purpose: The ...
Definition: gig.h:827
gig::dimension_releasetrigger
@ dimension_releasetrigger
Special dimension for triggering samples on releasing a key.
Definition: gig.h:343
gig::Script::DeleteChunks
void DeleteChunks()
Remove all RIFF chunks associated with this Script object.
Definition: gig.cpp:4656
gig::Region::DeleteDimensionZone
void DeleteDimensionZone(dimension_t type, int zone)
Delete one split zone of a dimension (decrement zone amount).
Definition: gig.cpp:3809
gig::DimensionRegion::SetVelocityResponseCurveScaling
void SetVelocityResponseCurveScaling(uint8_t scaling)
Updates the respective member variable and the lookup table / cache that depends on this value.
Definition: gig.cpp:3169
DLS::version_t
Quadtuple version number ("major.minor.release.build").
Definition: DLS.h:115
gig::DimensionRegion::SelfMask
bool SelfMask
If true: high velocity notes will stop low velocity notes at the same note, with that you can save vo...
Definition: gig.h:619
gig::smpte_format_no_offset
@ smpte_format_no_offset
no SMPTE offset
Definition: gig.h:145
DLS::Sample::Channels
uint16_t Channels
Number of channels represented in the waveform data, e.g. 1 for mono, 2 for stereo (defaults to 1=mon...
Definition: DLS.h:459
gig::DimensionRegion::EG2ControllerAttackInfluence
uint8_t EG2ControllerAttackInfluence
Amount EG2 Controller has influence on the EG2 Attack time (0 - 3, where 0 means off).
Definition: gig.h:571
gig::vcf_cutoff_ctrl_genpurpose8
@ vcf_cutoff_ctrl_genpurpose8
General Purpose Controller 8 (Button, MIDI Controller 83)
Definition: gig.h:238
gig::Region::GetSample
Sample * GetSample()
Returns pointer address to the Sample referenced with this region.
Definition: gig.cpp:4301
DLS::Sampler::Gain
int32_t Gain
Definition: DLS.h:428
gig::lfo_wave_triangle
@ lfo_wave_triangle
Triangle wave form.
Definition: gig.h:173
gig
Gigasampler/GigaStudio specific classes and definitions.
Definition: gig.h:101
gig::ScriptGroup
Group of instrument scripts (gig format extension).
Definition: gig.h:1230
DLS::Sample
Encapsulates sample waves used for playback.
Definition: DLS.h:456
gig::Sample::MIDIUnityNote
uint32_t MIDIUnityNote
Specifies the musical note at which the sample will be played at it's original sample rate.
Definition: gig.h:819
gig::Sample::FineTune
uint32_t FineTune
Specifies the fraction of a semitone up from the specified MIDI unity note field. A value of 0x800000...
Definition: gig.h:820
gig::playback_state_t
Reflects the current playback state for a sample.
Definition: gig.h:422
gig::vcf_type_lowpass
@ vcf_type_lowpass
Standard lowpass filter type (GigaStudio).
Definition: gig.h:396
gig::leverage_ctrl_t::type_velocity
@ type_velocity
Key Velocity.
Definition: gig.h:270
gig::DimensionRegion::LFO3Phase
double LFO3Phase
[gig extension]: Phase displacement of the pitch LFO's wave form (0.0° - 360.0°).
Definition: gig.h:587
gig::DimensionRegion::AttenuationControllerThreshold
uint8_t AttenuationControllerThreshold
0-127
Definition: gig.h:622
gig::loop_type_normal
@ loop_type_normal
Loop forward (normal)
Definition: gig.h:133
gig::DimensionRegion::EG1InfiniteSustain
bool EG1InfiniteSustain
If true, instead of going into Decay2 phase, Decay1 level will be hold until note will be released.
Definition: gig.h:544
gig::buffer_t::Size
file_offset_t Size
Size of the actual data in the buffer in bytes.
Definition: gig.h:116
gig::vcf_cutoff_ctrl_modwheel
@ vcf_cutoff_ctrl_modwheel
Modulation Wheel (MIDI Controller 1)
Definition: gig.h:238
gig::DimensionRegion::LFO3InternalDepth
int16_t LFO3InternalDepth
Firm depth of the sample pitch LFO (-1200 - +1200 cents).
Definition: gig.h:588
gig::Script::Bypass
bool Bypass
Global bypass: if enabled, this script shall not be executed by the sampler for any instrument.
Definition: gig.h:1195
gig::MidiRuleAlternator::PlayRange
range_t PlayRange
Key range of the playable keys in the instrument.
Definition: gig.h:1104
gig::dimension_genpurpose3
@ dimension_genpurpose3
General Purpose Controller 3 (Slider, MIDI Controller 18)
Definition: gig.h:343
gig::DimensionRegion::EG2Controller
eg2_ctrl_t EG2Controller
MIDI Controller which has influence on filter cutoff EG parameters (attack, decay,...
Definition: gig.h:569
gig::curve_type_t
curve_type_t
Defines the shape of a function graph.
Definition: gig.h:156
gig::DimensionRegion::LFO3Frequency
double LFO3Frequency
Frequency of the sample pitch LFO (0.10 - 10.00 Hz).
Definition: gig.h:586
gig::DimensionRegion::LFO3Sync
bool LFO3Sync
If set to true only one LFO should be used for all voices.
Definition: gig.h:592
gig::DimensionRegion::PitchTrack
bool PitchTrack
If true: sample will be pitched according to the key position (this will be disabled for drums for ex...
Definition: gig.h:616
gig::DimensionRegion::LFO1InternalDepth
uint16_t LFO1InternalDepth
Firm pitch of the sample amplitude LFO (0 - 1200 cents).
Definition: gig.h:556
gig::DimensionRegion::EG2Release
double EG2Release
Release time of the filter cutoff EG (0.000 - 60.000s).
Definition: gig.h:568
gig::lfo3_ctrl_internal
@ lfo3_ctrl_internal
Only internally controlled.
Definition: gig.h:195
gig::Instrument::PitchbendRange
uint16_t PitchbendRange
Number of semitones pitchbend controller can pitch (default is 2).
Definition: gig.h:1282
RIFF::List
RIFF List Chunk.
Definition: RIFF.h:308
gig::DimensionRegion::VCFKeyboardTrackingBreakpoint
uint8_t VCFKeyboardTrackingBreakpoint
See VCFKeyboardTracking (0 - 127).
Definition: gig.h:606
gig::lfo3_ctrl_modwheel
@ lfo3_ctrl_modwheel
Only controlled by external modulation wheel.
Definition: gig.h:195
gig::split_type_bit
@ split_type_bit
dimension values are already the sought bit number
Definition: gig.h:354
gig::DimensionRegion::EG1Sustain
uint16_t EG1Sustain
Sustain value of the sample amplitude EG (0 - 1000 permille).
Definition: gig.h:545
gig::File
Provides convenient access to Gigasampler/GigaStudio .gig files.
Definition: gig.h:1418
gig::Sample::FrameTable
file_offset_t * FrameTable
For positioning within compressed samples only: stores the offset values for each frame.
Definition: gig.h:863
gig::DimensionRegion::LFO2WaveForm
lfo_wave_t LFO2WaveForm
[gig extension]: The fundamental wave form to be used by the filter cutoff LFO, e....
Definition: gig.h:574
gig::Script::Language_t
Language_t
Definition: gig.h:1187
DLS::Sampler
Abstract base class which provides mandatory informations about sample players in general.
Definition: DLS.h:424
gig::DimensionRegion::EG2PreAttack
uint16_t EG2PreAttack
Preattack value of the filter cutoff EG (0 - 1000 permille).
Definition: gig.h:562
DLS::Instrument::MIDIBank
uint16_t MIDIBank
Reflects combination of MIDIBankCoarse and MIDIBankFine (bank 1 - bank 16384). Do not change this val...
Definition: DLS.h:526
gig::dimension_def_t::bits
uint8_t bits
Number of "bits" (1 bit = 2 splits/zones, 2 bit = 4 splits/zones, 3 bit = 8 splits/zones,...
Definition: gig.h:359
gig::DimensionRegion::EG2InfiniteSustain
bool EG2InfiniteSustain
If true, instead of going into Decay2 phase, Decay1 level will be hold until note will be released.
Definition: gig.h:566
gig::lfo3_ctrl_t
lfo3_ctrl_t
Defines how LFO3 is controlled by.
Definition: gig.h:195
gig::dimension_breath
@ dimension_breath
Breath Controller (Coarse, MIDI Controller 2)
Definition: gig.h:343
gig::vcf_cutoff_ctrl_effect2
@ vcf_cutoff_ctrl_effect2
Effect Controller 2 (Coarse, MIDI Controller 13)
Definition: gig.h:238
gig::Exception
Will be thrown whenever a gig specific error occurs while trying to access a Gigasampler File.
Definition: gig.h:1508
gig::Script::GetScriptAsText
String GetScriptAsText()
Returns the current script (i.e.
Definition: gig.cpp:4629
gig::Sample::SetPos
file_offset_t SetPos(file_offset_t SampleCount, RIFF::stream_whence_t Whence=RIFF::stream_start)
Sets the position within the sample (in sample points, not in bytes).
Definition: gig.cpp:892
RIFF::progress_t
Used for indicating the progress of a certain task.
Definition: RIFF.h:216
gig::vcf_res_ctrl_none
@ vcf_res_ctrl_none
No MIDI controller assigned for filter resonance.
Definition: gig.h:250
gig::DimensionRegion::EG1ControllerInvert
bool EG1ControllerInvert
Invert values coming from defined EG1 controller.
Definition: gig.h:549
gig::DimensionRegion::LFO2Phase
double LFO2Phase
[gig extension]: Phase displacement of the filter cutoff LFO's wave form (0.0° - 360....
Definition: gig.h:576
gig::lfo_wave_t
lfo_wave_t
Defines the wave form type used by an LFO (gig format extension).
Definition: gig.h:173
gig::dimension_roundrobinkeyboard
@ dimension_roundrobinkeyboard
Different samples triggered each time a note is played, any key advances the counter.
Definition: gig.h:343
gig::MidiRuleLegato::AltSustain2Key
uint8_t AltSustain2Key
Key triggering a second set of alternate sustain samples.
Definition: gig.h:1078
gig::DimensionRegion::EG2Attack
double EG2Attack
Attack time of the filter cutoff EG (0.000 - 60.000s).
Definition: gig.h:563
gig::DimensionRegion::LFO1Frequency
double LFO1Frequency
Frequency of the sample amplitude LFO (0.10 - 10.00 Hz).
Definition: gig.h:554
gig::dimension_def_t
General dimension definition.
Definition: gig.h:357
gig::dimension_def_t::split_type
split_type_t split_type
Intended for internal usage: will be used to convert a dimension value into the corresponding dimensi...
Definition: gig.h:361
gig::leverage_ctrl_t::type
type_t type
Controller type.
Definition: gig.h:272
gig::DimensionRegion::SustainReleaseTrigger
sust_rel_trg_t SustainReleaseTrigger
[gig extension]: Whether a sustain pedal up event shall play release trigger sample.
Definition: gig.h:631
gig::dimension_effect1depth
@ dimension_effect1depth
Effect 1 Depth (MIDI Controller 91)
Definition: gig.h:343
gig::DimensionRegion::UpdateChunks
virtual void UpdateChunks(progress_t *pProgress)
Apply dimension region settings to the respective RIFF chunks.
Definition: gig.cpp:2014
gig::lfo1_ctrl_t
lfo1_ctrl_t
Defines how LFO1 is controlled by.
Definition: gig.h:219
gig::lfo_wave_square
@ lfo_wave_square
Square wave form.
Definition: gig.h:173
gig::DimensionRegion::SustainDefeat
bool SustainDefeat
If true: Sustain pedal will not hold a note.
Definition: gig.h:624
gig::playback_state_t::loop_cycles_left
file_offset_t loop_cycles_left
How many times the loop has still to be passed, this value will be decremented with each loop cycle.
Definition: gig.h:425
gig::Sample::LoopType
loop_type_t LoopType
Caution: Use the respective field in the DimensionRegion instead of this one! (Intended purpose: The ...
Definition: gig.h:825
gig::Script::GenerateUuid
void GenerateUuid()
Generate a new Universally Unique Identifier (UUID) for this script.
Definition: gig.cpp:4706
gig::MidiRuleLegato::KeyRange
range_t KeyRange
Key range for legato notes.
Definition: gig.h:1075
gig::Script::Compression_t
Compression_t
Definition: gig.h:1184
gig::Region::SetKeyRange
virtual void SetKeyRange(uint16_t Low, uint16_t High)
Modifies the key range of this Region and makes sure the respective chunks are in correct order.
Definition: gig.cpp:3513
gig::DimensionRegion::EG2ControllerDecayInfluence
uint8_t EG2ControllerDecayInfluence
Amount EG2 Controller has influence on the EG2 Decay time (0 - 3, where 0 means off).
Definition: gig.h:572
gig::Sample
Encapsulates sample waves of Gigasampler/GigaStudio files used for playback.
Definition: gig.h:814
gig::dimension_effect2depth
@ dimension_effect2depth
Effect 2 Depth (MIDI Controller 92)
Definition: gig.h:343
gig::vcf_cutoff_ctrl_effect1
@ vcf_cutoff_ctrl_effect1
Effect Controller 1 (Coarse, MIDI Controller 12)
Definition: gig.h:238
gig::Sample::LoopPlayCount
uint32_t LoopPlayCount
Number of times the loop should be played (a value of 0 = infinite).
Definition: gig.h:830
gig::DimensionRegion::LFO2Sync
bool LFO2Sync
If set to true only one LFO should be used for all voices.
Definition: gig.h:581
gig::DimensionRegion::VCFCutoff
uint8_t VCFCutoff
Max. cutoff frequency.
Definition: gig.h:598
gig::MidiRuleLegato::BypassController
uint8_t BypassController
Controller to be used to bypass the sustain note.
Definition: gig.h:1072
gig::DimensionRegion::SetVelocityResponseDepth
void SetVelocityResponseDepth(uint8_t depth)
Updates the respective member variable and the lookup table / cache that depends on this value.
Definition: gig.cpp:3157
gig::Sample::WorstCaseFrameSize
file_offset_t WorstCaseFrameSize
For compressed samples only: size (in bytes) of the largest possible sample frame.
Definition: gig.h:866
gig::lfo1_ctrl_modwheel
@ lfo1_ctrl_modwheel
Only controlled by external modulation wheel.
Definition: gig.h:219
gig::curve_type_nonlinear
@ curve_type_nonlinear
Non-linear curve type.
Definition: gig.h:156
gig::DimensionRegion::LFO1Phase
double LFO1Phase
[gig extension]: Phase displacement of the amplitude LFO's wave form (0.0° - 360.0°).
Definition: gig.h:555
gig::Region::Layers
unsigned int Layers
Amount of defined layers (1 - 32). A value of 1 actually means no layering, a value > 1 means there i...
Definition: gig.h:933
gig::Sample::Resize
void Resize(file_offset_t NewSize)
Resize sample.
Definition: gig.cpp:866
gig::enumCount
size_t enumCount(String typeName)
Amount of elements in given enum type.
Definition: typeinfo.cpp:190
gig::DimensionRegion::Pan
int8_t Pan
Panorama / Balance (-64..0..63 <-> left..middle..right)
Definition: gig.h:618
gig::File::VERSION_2
static const DLS::version_t VERSION_2
Reflects Gigasampler file format version 2.0 (1998-06-28).
Definition: gig.h:1420
gig::Group::Name
String Name
Stores the name of this Group.
Definition: gig.h:1365
gig::crossfade_t::out_end
uint8_t out_end
End postition of fade out.
Definition: gig.h:415
gig::MidiRuleCtrlTrigger
MIDI rule for triggering notes by control change events.
Definition: gig.h:1026
DLS::File::GetRiffFile
RIFF::File * GetRiffFile()
Returns the underlying RIFF::File used for persistency of this DLS::File object.
Definition: DLS.cpp:1808
gig::DimensionRegion::SetGain
virtual void SetGain(int32_t gain)
Updates the respective member variable and updates SampleAttenuation which depends on this value.
Definition: gig.cpp:2000
gig::lfo3_ctrl_aftertouch
@ lfo3_ctrl_aftertouch
Only controlled by aftertouch controller.
Definition: gig.h:195
gig::Sample::ReadAndLoop
file_offset_t ReadAndLoop(void *pBuffer, file_offset_t SampleCount, playback_state_t *pPlaybackState, DimensionRegion *pDimRgn, buffer_t *pExternalDecompressionBuffer=NULL)
Reads SampleCount number of sample points from the position stored in pPlaybackState into the buffer ...
Definition: gig.cpp:965
gig::Script::SetScriptAsText
void SetScriptAsText(const String &text)
Replaces the current script with the new script source code text given by text.
Definition: gig.cpp:4642
gig::DimensionRegion::VCFVelocityCurve
curve_type_t VCFVelocityCurve
Defines a transformation curve for the incoming velocity values, affecting the VCF.
Definition: gig.h:599
gig::DimensionRegion::LFO3WaveForm
lfo_wave_t LFO3WaveForm
[gig extension]: The fundamental wave form to be used by the pitch LFO, e.g. sine,...
Definition: gig.h:585
gig::vcf_cutoff_ctrl_aftertouch
@ vcf_cutoff_ctrl_aftertouch
Key Pressure.
Definition: gig.h:238
DLS::Sample::BitDepth
uint16_t BitDepth
Size of each sample per channel (only if known sample data format is used, 0 otherwise).
Definition: DLS.h:463
gig::DimensionRegion::LFO3FlipPhase
bool LFO3FlipPhase
[gig extension]: Inverts the polarity of the pitch LFO wave, so it flips the wave form vertically (NO...
Definition: gig.h:591
gig::DimensionRegion::VelocityTable
uint8_t * VelocityTable
For velocity dimensions with custom defined zone ranges only: used for fast converting from velocity ...
Definition: gig.h:663
gig::Region::SplitDimensionZone
void SplitDimensionZone(dimension_t type, int zone)
Divide split zone of a dimension in two (increment zone amount).
Definition: gig.cpp:3948
gig::dimension_velocity
@ dimension_velocity
Key Velocity (this is the only dimension in gig2 where the ranges can exactly be defined).
Definition: gig.h:343
gig::MidiRuleAlternator::Controller
uint8_t Controller
CC number for controller selector.
Definition: gig.h:1127
gig::DimensionRegion::EG1ControllerReleaseInfluence
uint8_t EG1ControllerReleaseInfluence
Amount EG1 Controller has influence on the EG1 Release time (0 - 3, where 0 means off).
Definition: gig.h:552
gig::DimensionRegion::VCFCutoffControllerInvert
bool VCFCutoffControllerInvert
Inverts values coming from the defined cutoff controller.
Definition: gig.h:597
gig::eg_opt_t::ReleaseCancel
bool ReleaseCancel
Whether the "release" stage is cancelled when receiving a note-on (default: true).
Definition: gig.h:456
gig::DimensionRegion::EG2Sustain
uint16_t EG2Sustain
Sustain value of the filter cutoff EG (0 - 1000 permille).
Definition: gig.h:567
gig::ScriptGroup::Name
String Name
Name of this script group. For example to be displayed in an instrument editor.
Definition: gig.h:1232
gig::vcf_type_bandpass_2p
@ vcf_type_bandpass_2p
[gig extension]: 2-pole bandpass filter type (LinuxSampler).
Definition: gig.h:396
gig::Script::SetGroup
void SetGroup(ScriptGroup *pGroup)
Move this script from its current ScriptGroup to another ScriptGroup given by pGroup.
Definition: gig.cpp:4733
gig::vcf_type_lowpass_6p
@ vcf_type_lowpass_6p
[gig extension]: 6-pole lowpass filter type (LinuxSampler).
Definition: gig.h:396
gig::Region::CopyAssign
virtual void CopyAssign(const Region *orig)
Make a (semi) deep copy of the Region object given by orig and assign it to this object.
Definition: gig.cpp:4346
gig::dim_bypass_ctrl_95
@ dim_bypass_ctrl_95
Effect 5 Depth (MIDI Controller 95)
Definition: gig.h:183
gig::MidiRuleLegato::AltSustain1Key
uint8_t AltSustain1Key
Key triggering alternate sustain samples.
Definition: gig.h:1077
gig::DimensionRegion::SetVCFVelocityDynamicRange
void SetVCFVelocityDynamicRange(uint8_t range)
Updates the respective member variable and the lookup table / cache that depends on this value.
Definition: gig.cpp:3217
gig::DimensionRegion::ReleaseVelocityResponseCurve
curve_type_t ReleaseVelocityResponseCurve
Defines a transformation curve to the incoming release veloctiy values affecting envelope times.
Definition: gig.h:611
gig::DimensionRegion::CopyAssign
virtual void CopyAssign(const DimensionRegion *orig)
Make a (semi) deep copy of the DimensionRegion object given by orig and assign it to this object.
Definition: gig.cpp:1842
gig::DimensionRegion::VelocityResponseDepth
uint8_t VelocityResponseDepth
Dynamic range of velocity affecting amplitude (0 - 4) (usually you don't have to interpret this param...
Definition: gig.h:609
DLS::File::Save
virtual void Save(const String &Path, progress_t *pProgress=NULL)
Save changes to another file.
Definition: DLS.cpp:2103
gig::Region::AddDimension
void AddDimension(dimension_def_t *pDimDef)
Einstein would have dreamed of it - create a new dimension.
Definition: gig.cpp:3607
gig::split_type_t
split_type_t
Intended for internal usage: will be used to convert a dimension value into the corresponding dimensi...
Definition: gig.h:354
gig::Sample::VerifyWaveData
bool VerifyWaveData(uint32_t *pActually=NULL)
Checks the integrity of this sample's raw audio wave data.
Definition: gig.cpp:1452
gig::smpte_format_25_frames
@ smpte_format_25_frames
25 frames per second
Definition: gig.h:145
gig::DimensionRegion::VCFResonanceController
vcf_res_ctrl_t VCFResonanceController
Specifies which external controller has influence on the filter resonance Q.
Definition: gig.h:604
gig::dimension_portamento
@ dimension_portamento
Portamento (MIDI Controller 65)
Definition: gig.h:343
gig::Script::COMPRESSION_NONE
@ COMPRESSION_NONE
Is not compressed at all (default).
Definition: gig.h:1185
gig::DimensionRegion::EG1Controller
eg1_ctrl_t EG1Controller
MIDI Controller which has influence on sample amplitude EG parameters (attack, decay,...
Definition: gig.h:548
gig::Sample::FileNo
unsigned long FileNo
File number (> 0 when sample is stored in an extension file, 0 when it's in the gig)
Definition: gig.h:869
gig::DimensionRegion::NoNoteOffReleaseTrigger
bool NoNoteOffReleaseTrigger
[gig extension]: If true then don't play a release trigger sample on MIDI note-off events.
Definition: gig.h:632
gig::DimensionRegion::SetReleaseVelocityResponseCurve
void SetReleaseVelocityResponseCurve(curve_type_t curve)
Updates the respective member variable and the lookup table / cache that depends on this value.
Definition: gig.cpp:3181
gig::range_t::low
uint8_t low
Low value of range.
Definition: gig.h:109
gig::MidiRuleLegato::LegatoSamples
uint8_t LegatoSamples
Number of legato samples per key in each direction (always 12)
Definition: gig.h:1069
gig::DimensionRegion::SetReleaseVelocityResponseDepth
void SetReleaseVelocityResponseDepth(uint8_t depth)
Updates the respective member variable and the lookup table / cache that depends on this value.
Definition: gig.cpp:3190
gig::Instrument::FineTune
int16_t FineTune
in cents
Definition: gig.h:1281
gig::vcf_res_ctrl_genpurpose5
@ vcf_res_ctrl_genpurpose5
General Purpose Controller 5 (Button, MIDI Controller 80)
Definition: gig.h:250
gig::Sample::SamplePeriod
uint32_t SamplePeriod
Specifies the duration of time that passes during the playback of one sample in nanoseconds (normally...
Definition: gig.h:818
gig::Sample::GetGroup
Group * GetGroup() const
Returns pointer to the Group this Sample belongs to.
Definition: gig.cpp:1407
gig::MidiRuleLegato::BypassUseController
bool BypassUseController
If a controller should be used to bypass the sustain note.
Definition: gig.h:1070
gig::Script::CopyAssign
void CopyAssign(const Script *orig)
Make a (semi) deep copy of the Script object given by orig and assign it to this object.
Definition: gig.cpp:4757
gig::DimensionRegion::VCFEnabled
bool VCFEnabled
If filter should be used.
Definition: gig.h:594
gig::DimensionRegion::EG2Decay2
double EG2Decay2
Only if EG2InfiniteSustain == false: 2nd stage decay time of the filter cutoff EG (0....
Definition: gig.h:565
gig::eg_opt_t::Decay2Cancel
bool Decay2Cancel
Whether the "decay 2" stage is cancelled when receiving a note-off (default: true).
Definition: gig.h:455
DLS::Instrument::MIDIBankCoarse
uint8_t MIDIBankCoarse
Reflects the MIDI Bank number for MIDI Control Change 0 (bank 1 - 128).
Definition: DLS.h:527
gig::DimensionRegion::SetVelocityResponseCurve
void SetVelocityResponseCurve(curve_type_t curve)
Updates the respective member variable and the lookup table / cache that depends on this value.
Definition: gig.cpp:3145
gig::sust_rel_trg_maxvelocity
@ sust_rel_trg_maxvelocity
Play release trigger sample(s) on sustain pedal up, and simply use 127 as MIDI velocity for playback.
Definition: gig.h:482
gig::enumKeys
const char ** enumKeys(String typeName)
All element names of enum type.
Definition: typeinfo.cpp:323
gig::MidiRuleCtrlTrigger::ControllerNumber
uint8_t ControllerNumber
MIDI controller number.
Definition: gig.h:1028
gig::Sample::SMPTEFormat
smpte_format_t SMPTEFormat
Specifies the Society of Motion Pictures and Television E time format used in the following SMPTEOffs...
Definition: gig.h:821
RIFF::Chunk
Ordinary RIFF Chunk.
Definition: RIFF.h:232
gig::DimensionRegion::EG1Release
double EG1Release
Release time of the sample amplitude EG (0.000 - 60.000s).
Definition: gig.h:546
gig::MidiRuleUnknown
A MIDI rule not yet implemented by libgig.
Definition: gig.h:1152
gig::leverage_ctrl_t::type_channelaftertouch
@ type_channelaftertouch
Channel Key Pressure.
Definition: gig.h:270
gig::DimensionRegion::VelocityResponseCurve
curve_type_t VelocityResponseCurve
Defines a transformation curve to the incoming velocity values affecting amplitude (usually you don't...
Definition: gig.h:608
gig::DimensionRegion::LFO2Frequency
double LFO2Frequency
Frequency of the filter cutoff LFO (0.10 - 10.00 Hz).
Definition: gig.h:575
Serialization::Archive
Destination container for serialization, and source container for deserialization.
Definition: Serialization.h:895
gig::vcf_cutoff_ctrl_breath
@ vcf_cutoff_ctrl_breath
Breath Controller (Coarse, MIDI Controller 2)
Definition: gig.h:238
gig::Region::GetDimensionDefinition
dimension_def_t * GetDimensionDefinition(dimension_t type)
Searches in the current Region for a dimension of the given dimension type and returns the precise co...
Definition: gig.cpp:4142
gig::dimension_softpedal
@ dimension_softpedal
Soft Pedal (MIDI Controller 67)
Definition: gig.h:343
gig::lfo1_ctrl_internal_breath
@ lfo1_ctrl_internal_breath
Controlled internally and by external breath controller.
Definition: gig.h:219
gig::Script::UpdateChunks
void UpdateChunks(progress_t *pProgress)
Apply this script to the respective RIFF chunks.
Definition: gig.cpp:4668
gig::DimensionRegion::VCFType
vcf_type_t VCFType
Defines the general filter characteristic (lowpass, highpass, bandpass, etc.).
Definition: gig.h:595
gig::DimensionRegion::VCFVelocityScale
uint8_t VCFVelocityScale
(0-127) Amount velocity controls VCF cutoff frequency (only if no other VCF cutoff controller is defi...
Definition: gig.h:600
gig::DimensionRegion::DimensionUpperLimits
uint8_t DimensionUpperLimits[8]
gig3: defines the upper limit of the dimension values for this dimension region. In case you wondered...
Definition: gig.h:628
gig::dimension_effect1
@ dimension_effect1
Effect Controller 1 (Coarse, MIDI Controller 12)
Definition: gig.h:343
gig::DimensionRegion::EG1Options
eg_opt_t EG1Options
[gig extension]: Behavior options which should be used for envelope generator 1 (volume amplitude EG)...
Definition: gig.h:629
DLS::Resource::pInfo
Info * pInfo
Points (in any case) to an Info object, providing additional, optional infos and comments.
Definition: DLS.h:405
gig::vcf_type_lowpass_4p
@ vcf_type_lowpass_4p
[gig extension]: 4-pole lowpass filter type (LinuxSampler).
Definition: gig.h:396
gig::Sample::LoadSampleDataWithNullSamplesExtension
buffer_t LoadSampleDataWithNullSamplesExtension(uint NullSamplesCount)
Loads (and uncompresses if needed) the whole sample wave into RAM.
Definition: gig.cpp:755
gig::dimension_effect4depth
@ dimension_effect4depth
Effect 4 Depth (MIDI Controller 94)
Definition: gig.h:343
gig::File::VERSION_4
static const DLS::version_t VERSION_4
Reflects Gigasampler file format version 4.0 (2007-10-12).
Definition: gig.h:1422
gig::smpte_format_30_frames
@ smpte_format_30_frames
30 frames per second
Definition: gig.h:145
gig::Script
Real-time instrument script (gig format extension).
Definition: gig.h:1179
gig::vcf_type_lowpassturbo
@ vcf_type_lowpassturbo
More poles than normal lowpass (GigaStudio).
Definition: gig.h:396
gig::DimensionRegion::EG1ControllerDecayInfluence
uint8_t EG1ControllerDecayInfluence
Amount EG1 Controller has influence on the EG1 Decay time (0 - 3, where 0 means off).
Definition: gig.h:551
gig::Region::GetDimensionRegionByBit
DimensionRegion * GetDimensionRegionByBit(const uint8_t DimBits[8])
Returns the appropriate DimensionRegion for the given dimension bit numbers (zone index).
Definition: gig.cpp:4282
RIFF::stream_whence_t
stream_whence_t
File stream position dependent to these relations.
Definition: RIFF.h:177
gig::dimension_modwheel
@ dimension_modwheel
Modulation Wheel (MIDI Controller 1)
Definition: gig.h:343
gig::dimension_genpurpose8
@ dimension_genpurpose8
General Purpose Controller 8 (Button, MIDI Controller 83)
Definition: gig.h:343
gig::Sample::CreateDecompressionBuffer
static buffer_t CreateDecompressionBuffer(file_offset_t MaxReadSize)
Allocates a decompression buffer for streaming (compressed) samples with Sample::Read().
Definition: gig.cpp:1373
gig::Sample::LoopID
uint32_t LoopID
Specifies the unique ID that corresponds to one of the defined cue points in the cue point list (only...
Definition: gig.h:824
gig::DimensionRegion::GetVelocityAttenuation
double GetVelocityAttenuation(uint8_t MIDIKeyVelocity)
Returns the correct amplitude factor for the given MIDIKeyVelocity.
Definition: gig.cpp:3129
gig::vcf_type_t
vcf_type_t
Audio filter types.
Definition: gig.h:396
gig::Script::LANGUAGE_NKSP
@ LANGUAGE_NKSP
NKSP stands for "Is Not KSP" (default). Refer to the NKSP Reference Manual for details about this scr...
Definition: gig.h:1188
gig::lfo1_ctrl_breath
@ lfo1_ctrl_breath
Only controlled by external breath controller.
Definition: gig.h:219
gig::crossfade_t::in_end
uint8_t in_end
End position of fade in.
Definition: gig.h:413
gig::dimension_genpurpose5
@ dimension_genpurpose5
General Purpose Controller 5 (Button, MIDI Controller 80)
Definition: gig.h:343
gig::vcf_res_ctrl_genpurpose6
@ vcf_res_ctrl_genpurpose6
General Purpose Controller 6 (Button, MIDI Controller 81)
Definition: gig.h:250
gig::crossfade_t::out_start
uint8_t out_start
Start position of fade out.
Definition: gig.h:414
gig::vcf_cutoff_ctrl_genpurpose7
@ vcf_cutoff_ctrl_genpurpose7
General Purpose Controller 7 (Button, MIDI Controller 82)
Definition: gig.h:238
gig::DimensionRegion::EG1PreAttack
uint16_t EG1PreAttack
Preattack value of the sample amplitude EG (0 - 1000 permille).
Definition: gig.h:540
gig::MidiRuleLegato::ThresholdTime
uint16_t ThresholdTime
Maximum time (ms) between two notes that should be played legato.
Definition: gig.h:1073
gig::buffer_t::pStart
void * pStart
Points to the beginning of the buffer.
Definition: gig.h:115
gig::Region::pDimensionRegions
DimensionRegion * pDimensionRegions[256]
Pointer array to the 32 (gig2) or 256 (gig3) possible dimension regions (reflects NULL for dimension ...
Definition: gig.h:932
gig::vcf_cutoff_ctrl_foot
@ vcf_cutoff_ctrl_foot
Foot Pedal (Coarse, MIDI Controller 4)
Definition: gig.h:238
gig::dimension_smartmidi
@ dimension_smartmidi
For MIDI tools like legato and repetition mode.
Definition: gig.h:343
gig::vcf_type_highpass_1p
@ vcf_type_highpass_1p
[gig extension]: 1-pole highpass filter type (LinuxSampler).
Definition: gig.h:396
gig::DimensionRegion::VCFKeyboardTracking
bool VCFKeyboardTracking
If true: VCF cutoff frequence will be dependend to the note key position relative to the defined brea...
Definition: gig.h:605
gig::lfo_wave_saw
@ lfo_wave_saw
Saw (up) wave form (saw down wave form can be achieved by flipping the phase).
Definition: gig.h:173
gig::vcf_type_bandreject_2p
@ vcf_type_bandreject_2p
[gig extension]: 2-pole bandreject filter type (LinuxSampler).
Definition: gig.h:396
gig::MidiRuleAlternator::pPatterns
struct gig::MidiRuleAlternator::pattern_t pPatterns[32]
A pattern is a sequence of articulation numbers.
gig::playback_state_t::position
file_offset_t position
Current position within the sample.
Definition: gig.h:423
gig::leverage_ctrl_t::type_none
@ type_none
No controller defined.
Definition: gig.h:270
gig::DimensionRegion::LFO1Controller
lfo1_ctrl_t LFO1Controller
MIDI Controller which controls sample amplitude LFO.
Definition: gig.h:558
gig::DimensionRegion::LFO1WaveForm
lfo_wave_t LFO1WaveForm
[gig extension]: The fundamental wave form to be used by the amplitude LFO, e.g. sine,...
Definition: gig.h:553
DLS::File::SetFileName
void SetFileName(const String &name)
You may call this method store a future file name, so you don't have to to pass it to the Save() call...
Definition: DLS.cpp:1849
gig::Sample::SamplesPerFrame
file_offset_t SamplesPerFrame
For compressed samples only: number of samples in a full sample frame.
Definition: gig.h:867
gig::dimension_def_t::zones
uint8_t zones
Number of zones the dimension has.
Definition: gig.h:360
gig::vcf_type_highpass_2p
@ vcf_type_highpass_2p
[gig extension]: 2-pole highpass filter type (LinuxSampler).
Definition: gig.h:396
gig::lfo2_ctrl_modwheel
@ lfo2_ctrl_modwheel
Only controlled by external modulation wheel.
Definition: gig.h:207
gig::Sample::TruncatedBits
uint32_t TruncatedBits
For 24-bit compressed samples only: number of bits truncated during compression (0,...
Definition: gig.h:832
gig::vcf_cutoff_ctrl_none2
@ vcf_cutoff_ctrl_none2
The difference between none and none2 is unknown.
Definition: gig.h:238
gig::Sample::GetCache
buffer_t GetCache()
Returns current cached sample points.
Definition: gig.cpp:814
gig::sust_rel_trg_none
@ sust_rel_trg_none
No release triggered sample(s) are played on sustain pedal up (default).
Definition: gig.h:482
gig::Instrument::Attenuation
int32_t Attenuation
in dB
Definition: gig.h:1279
gig::vcf_type_bandpass
@ vcf_type_bandpass
Bandpass filter type (GigaStudio).
Definition: gig.h:396
gig::DimensionRegion::EG1Attack
double EG1Attack
Attack time of the sample amplitude EG (0.000 - 60.000s).
Definition: gig.h:541
gig::Sample::crc
uint32_t crc
Reflects CRC-32 checksum of the raw sample data at the last time when the sample's raw wave form data...
Definition: gig.h:872
gig::Script::Compression
Compression_t Compression
Whether the script was/should be compressed, and if so, which compression algorithm shall be used.
Definition: gig.h:1192
gig::DimensionRegion::VelocityResponseCurveScaling
uint8_t VelocityResponseCurveScaling
0 - 127 (usually you don't have to interpret this parameter, use GetVelocityAttenuation() instead).
Definition: gig.h:610
gig::DimensionRegion::VCFVelocityDynamicRange
uint8_t VCFVelocityDynamicRange
0x04 = lowest, 0x00 = highest .
Definition: gig.h:601
gig::lfo2_ctrl_foot
@ lfo2_ctrl_foot
Only controlled by external foot controller.
Definition: gig.h:207
gig::eg1_ctrl_t
leverage_ctrl_t eg1_ctrl_t
Defines controller influencing envelope generator 1.
Definition: gig.h:290
gig::dimension_genpurpose4
@ dimension_genpurpose4
General Purpose Controller 4 (Slider, MIDI Controller 19)
Definition: gig.h:343
RIFF::File
RIFF File.
Definition: RIFF.h:358
gig::buffer_t
Pointer address and size of a buffer.
Definition: gig.h:114
gig::DimensionRegion::VCFResonance
uint8_t VCFResonance
Firm internal filter resonance weight.
Definition: gig.h:602
gig::DimensionRegion::LFO2FlipPhase
bool LFO2FlipPhase
Inverts the polarity of the filter cutoff LFO wave, so it flips the wave form vertically.
Definition: gig.h:580
gig::loop_type_bidirectional
@ loop_type_bidirectional
Alternating loop (forward/backward, also known as Ping Pong)
Definition: gig.h:133
gig::Sample::Product
uint32_t Product
Specifies the MIDI model ID defined by the manufacturer corresponding to the Manufacturer field....
Definition: gig.h:817
gig::Sample::RAMCache
buffer_t RAMCache
Buffers samples (already uncompressed) in RAM.
Definition: gig.h:868
gig::DimensionRegion::DimensionBypass
dim_bypass_ctrl_t DimensionBypass
If defined, the MIDI controller can switch on/off the dimension in realtime.
Definition: gig.h:617
gig::Sample::InternalDecompressionBuffer
static buffer_t InternalDecompressionBuffer
Buffer used for decompression as well as for truncation of 24 Bit -> 16 Bit samples.
Definition: gig.h:860
gig::DimensionRegion::EG1Decay1
double EG1Decay1
Decay time of the sample amplitude EG (0.000 - 60.000s).
Definition: gig.h:542
gig::dimension_random
@ dimension_random
Different samples triggered each time a note is played, random order.
Definition: gig.h:343
gig::smpte_format_30_frames_dropping
@ smpte_format_30_frames_dropping
30 frames per second with frame dropping (30 drop)
Definition: gig.h:145
gig::range_t::high
uint8_t high
High value of range.
Definition: gig.h:110
gig::Sample::DestroyDecompressionBuffer
static void DestroyDecompressionBuffer(buffer_t &DecompressionBuffer)
Free decompression buffer, previously created with CreateDecompressionBuffer().
Definition: gig.cpp:1390
DLS
DLS specific classes and definitions.
Definition: DLS.h:108
gig::Region::~Region
~Region()
Destructor.
Definition: gig.cpp:4149
gig::dimension_foot
@ dimension_foot
Foot Pedal (Coarse, MIDI Controller 4)
Definition: gig.h:343
gig::curve_type_linear
@ curve_type_linear
Linear curve type.
Definition: gig.h:156
gig::enumValue
size_t enumValue(String key)
Numeric value of enum constant.
Definition: typeinfo.cpp:219
gig::DimensionRegion::SampleStartOffset
uint16_t SampleStartOffset
Number of samples the sample start should be moved (0 - 2000).
Definition: gig.h:626
gig::DimensionRegion::SetVCFVelocityScale
void SetVCFVelocityScale(uint8_t scaling)
Updates the respective member variable and the lookup table / cache that depends on this value.
Definition: gig.cpp:3226
gig::DimensionRegion::ReleaseVelocityResponseDepth
uint8_t ReleaseVelocityResponseDepth
Dynamic range of release velocity affecting envelope time (0 - 4).
Definition: gig.h:612
Serialization
Serialization / deserialization framework.
Definition: gig.h:98
gig::MidiRuleLegato::ReleaseTime
uint16_t ReleaseTime
Release time.
Definition: gig.h:1074
DLS::Resource::pDLSID
dlsid_t * pDLSID
Points to a dlsid_t structure if the file provided a DLS ID else is NULL.
Definition: DLS.h:406
gig::MidiRuleAlternator::Chained
bool Chained
If all patterns should be chained together.
Definition: gig.h:1130
gig::DimensionRegion::VelocityUpperLimit
uint8_t VelocityUpperLimit
Defines the upper velocity value limit of a velocity split (only if an user defined limit was set,...
Definition: gig.h:537
gig::vcf_cutoff_ctrl_t
vcf_cutoff_ctrl_t
Defines how the filter cutoff frequency is controlled by.
Definition: gig.h:238
gig::DimensionRegion::ReleaseTriggerDecay
uint8_t ReleaseTriggerDecay
0 - 8
Definition: gig.h:613
gig::Sample::Compressed
bool Compressed
If the sample wave is compressed (probably just interesting for instrument and sample editors,...
Definition: gig.h:831
gig::dimension_roundrobin
@ dimension_roundrobin
Different samples triggered each time a note is played, dimension regions selected in sequence.
Definition: gig.h:343
gig::vcf_res_ctrl_genpurpose3
@ vcf_res_ctrl_genpurpose3
General Purpose Controller 3 (Slider, MIDI Controller 18)
Definition: gig.h:250
gig::dimension_genpurpose7
@ dimension_genpurpose7
General Purpose Controller 7 (Button, MIDI Controller 82)
Definition: gig.h:343
DLS::Instrument::MIDIProgram
uint32_t MIDIProgram
Specifies the MIDI Program Change Number this Instrument should be assigned to.
Definition: DLS.h:529
DLS::Sampler::SampleLoops
uint32_t SampleLoops
Reflects the number of sample loops.
Definition: DLS.h:431
gig::DimensionRegion::LFO1ControlDepth
uint16_t LFO1ControlDepth
Controller depth influencing sample amplitude LFO pitch (0 - 1200 cents).
Definition: gig.h:557
gig::loop_type_backward
@ loop_type_backward
Loop backward (reverse)
Definition: gig.h:133
gig::vcf_cutoff_ctrl_softpedal
@ vcf_cutoff_ctrl_softpedal
Soft Pedal (MIDI Controller 67)
Definition: gig.h:238
gig::vcf_type_lowpass_1p
@ vcf_type_lowpass_1p
[gig extension]: 1-pole lowpass filter type (LinuxSampler).
Definition: gig.h:396
gig::eg_opt_t::AttackCancel
bool AttackCancel
Whether the "attack" stage is cancelled when receiving a note-off (default: true).
Definition: gig.h:452
gig::MidiRuleLegato
MIDI rule for instruments with legato samples.
Definition: gig.h:1067
gig::Region
Defines Region information of a Gigasampler/GigaStudio instrument.
Definition: gig.h:927
gig::DimensionRegion::EG1Hold
bool EG1Hold
If true, Decay1 stage should be postponed until the sample reached the sample loop start.
Definition: gig.h:547
gig::dimension_keyboard
@ dimension_keyboard
Dimension for keyswitching.
Definition: gig.h:343
gig::Region::GetDimensionRegionByValue
DimensionRegion * GetDimensionRegionByValue(const uint DimValues[8])
Use this method in your audio engine to get the appropriate dimension region with it's articulation d...
Definition: gig.cpp:4173
gig::DimensionRegion::VCFResonanceDynamic
bool VCFResonanceDynamic
If true: Increases the resonance Q according to changes of controllers that actually control the VCF ...
Definition: gig.h:603
gig::lfo1_ctrl_internal
@ lfo1_ctrl_internal
Only internally controlled.
Definition: gig.h:219
gig::buffer_t::NullExtensionSize
file_offset_t NullExtensionSize
The buffer might be bigger than the actual data, if that's the case that unused space at the end of t...
Definition: gig.h:117
gig::DimensionRegion::SampleAttenuation
double SampleAttenuation
Sample volume (calculated from DLS::Sampler::Gain)
Definition: gig.h:627
gig::dimension_def_t::zone_size
float zone_size
Intended for internal usage: reflects the size of each zone (128/zones) for normal split types only,...
Definition: gig.h:362
gig::File::VERSION_3
static const DLS::version_t VERSION_3
Reflects Gigasampler file format version 3.0 (2003-03-31).
Definition: gig.h:1421
gig::lfo_wave_sine
@ lfo_wave_sine
Sine (sinus) wave form (this is the default wave form).
Definition: gig.h:173
gig::sust_rel_trg_t
sust_rel_trg_t
Defines behaviour of release triggered sample(s) on sustain pedal up event.
Definition: gig.h:482
gig::dimension_channelaftertouch
@ dimension_channelaftertouch
Channel Key Pressure.
Definition: gig.h:343
gig::leverage_ctrl_t::controller_number
uint controller_number
MIDI controller number if this controller is a control change controller, 0 otherwise.
Definition: gig.h:273
gig::Sample::SMPTEOffset
uint32_t SMPTEOffset
The SMPTE Offset value specifies the time offset to be used for the synchronization / calibration to ...
Definition: gig.h:822
gig::split_type_normal
@ split_type_normal
dimension value between 0-127
Definition: gig.h:354
gig::curve_type_special
@ curve_type_special
Special curve type.
Definition: gig.h:156
gig::vcf_cutoff_ctrl_sustainpedal
@ vcf_cutoff_ctrl_sustainpedal
Sustain Pedal (MIDI Controller 64)
Definition: gig.h:238
gig::Sample::pGroup
Group * pGroup
pointer to the Group this sample belongs to (always not-NULL)
Definition: gig.h:861
gig::DimensionRegion::LFO2Controller
lfo2_ctrl_t LFO2Controller
MIDI Controlle which controls the filter cutoff LFO.
Definition: gig.h:579
gig::vcf_type_highpass_4p
@ vcf_type_highpass_4p
[gig extension]: 4-pole highpass filter type (LinuxSampler).
Definition: gig.h:396
gig::Region::DimensionRegions
uint32_t DimensionRegions
Total number of DimensionRegions this Region contains, do not alter!
Definition: gig.h:931
gig::Sample::Instances
static size_t Instances
Number of instances of class Sample.
Definition: gig.h:859
gig::playback_state_t::reverse
bool reverse
If playback direction is currently backwards (in case there is a pingpong or reverse loop defined).
Definition: gig.h:424
DLS::Region
Defines Region information of an Instrument.
Definition: DLS.h:492
gig::vcf_type_highpass_6p
@ vcf_type_highpass_6p
[gig extension]: 6-pole highpass filter type (LinuxSampler).
Definition: gig.h:396
gig::Script::Language
Language_t Language
Programming language and dialect the script is written in.
Definition: gig.h:1194
DLS::Sampler::pSampleLoops
sample_loop_t * pSampleLoops
Points to the beginning of a sample loop array, or is NULL if there are no loops defined.
Definition: DLS.h:432
gig::DimensionRegion::LFO3Controller
lfo3_ctrl_t LFO3Controller
MIDI Controller which controls the sample pitch LFO.
Definition: gig.h:590
gig::vcf_res_ctrl_genpurpose4
@ vcf_res_ctrl_genpurpose4
General Purpose Controller 4 (Slider, MIDI Controller 19)
Definition: gig.h:250
gig::DimensionRegion::SetVCFCutoffController
void SetVCFCutoffController(vcf_cutoff_ctrl_t controller)
Updates the respective member variable and the lookup table / cache that depends on this value.
Definition: gig.cpp:3199
gig::dimension_none
@ dimension_none
Dimension not in use.
Definition: gig.h:343
gig::dimension_sustainpedal
@ dimension_sustainpedal
Sustain Pedal (MIDI Controller 64)
Definition: gig.h:343
gig::lfo3_ctrl_internal_aftertouch
@ lfo3_ctrl_internal_aftertouch
Controlled internally and by aftertouch controller.
Definition: gig.h:195
gig::MidiRuleAlternator
MIDI rule to automatically cycle through specified sequences of different articulations.
Definition: gig.h:1099
gig::lfo3_ctrl_internal_modwheel
@ lfo3_ctrl_internal_modwheel
Controlled internally and by external modulation wheel.
Definition: gig.h:195
gig::DimensionRegion::ChannelOffset
uint8_t ChannelOffset
Audio output where the audio signal of the dimension region should be routed to (0 - 9).
Definition: gig.h:623
gig::leverage_ctrl_t
Defines a controller that has a certain contrained influence on a particular synthesis parameter (use...
Definition: gig.h:260
DLS::File::Instruments
uint32_t Instruments
Reflects the number of available Instrument objects.
Definition: DLS.h:564
gig::DimensionRegion::SetVCFVelocityCurve
void SetVCFVelocityCurve(curve_type_t curve)
Updates the respective member variable and the lookup table / cache that depends on this value.
Definition: gig.cpp:3208
gig::leverage_ctrl_t::type_controlchange
@ type_controlchange
Ordinary MIDI control change controller, see field 'controller_number'.
Definition: gig.h:270
DLS::File::pVersion
version_t * pVersion
Points to a version_t structure if the file provided a version number else is set to NULL.
Definition: DLS.h:563
gig::DimensionRegion::EG1ControllerAttackInfluence
uint8_t EG1ControllerAttackInfluence
Amount EG1 Controller has influence on the EG1 Attack time (0 - 3, where 0 means off).
Definition: gig.h:550
gig::eg2_ctrl_t
leverage_ctrl_t eg2_ctrl_t
Defines controller influencing envelope generator 2.
Definition: gig.h:297
gig::dimension_genpurpose1
@ dimension_genpurpose1
General Purpose Controller 1 (Slider, MIDI Controller 16)
Definition: gig.h:343
gig::dimension_samplechannel
@ dimension_samplechannel
If used sample has more than one channel (thus is not mono).
Definition: gig.h:343
gig::dimension_layer
@ dimension_layer
For layering of up to 8 instruments (and eventually crossfading of 2 or 4 layers).
Definition: gig.h:343
gig::eg_opt_t::AttackHoldCancel
bool AttackHoldCancel
Whether the "attack hold" stage is cancelled when receiving a note-off (default: true).
Definition: gig.h:453
gig::DimensionRegion::MSDecode
bool MSDecode
Gigastudio flag: defines if Mid Side Recordings should be decoded.
Definition: gig.h:625
gig::dim_bypass_ctrl_t
dim_bypass_ctrl_t
Dimensions allow to bypass one of the following controllers.
Definition: gig.h:183
gig::Sample::Read
file_offset_t Read(void *pBuffer, file_offset_t SampleCount, buffer_t *pExternalDecompressionBuffer=NULL)
Reads SampleCount number of sample points from the current position into the buffer pointed by pBuffe...
Definition: gig.cpp:1140
gig::dim_bypass_ctrl_none
@ dim_bypass_ctrl_none
No controller bypass.
Definition: gig.h:183
gig::MidiRuleLegato::ReleaseTriggerKey
uint8_t ReleaseTriggerKey
Key triggering release samples.
Definition: gig.h:1076
gig::Group
Group of Gigasampler samples.
Definition: gig.h:1363
gig::MidiRuleAlternator::KeySwitchRange
range_t KeySwitchRange
Key range for key switch selector.
Definition: gig.h:1126
gig::libraryName
String libraryName()
Returns the name of this C++ library.
Definition: gig.cpp:7405
gig::Sample::FrameOffset
file_offset_t FrameOffset
Current offset (sample points) in current sample frame (for decompression only).
Definition: gig.h:862
gig::dimension_sostenutopedal
@ dimension_sostenutopedal
Sostenuto Pedal (MIDI Controller 66)
Definition: gig.h:343
gig::dimension_effect5depth
@ dimension_effect5depth
Effect 5 Depth (MIDI Controller 95)
Definition: gig.h:343
gig::Sample::SamplePos
file_offset_t SamplePos
For compressed samples only: stores the current position (in sample points).
Definition: gig.h:864
gig::DimensionRegion::VCFCutoffController
vcf_cutoff_ctrl_t VCFCutoffController
Specifies which external controller has influence on the filter cutoff frequency.
Definition: gig.h:596
DLS::Instrument::MIDIBankFine
uint8_t MIDIBankFine
Reflects the MIDI Bank number for MIDI Control Change 32 (bank 1 - 128).
Definition: DLS.h:528
gig::attenuation_ctrl_t
leverage_ctrl_t attenuation_ctrl_t
Defines controller influencing attenuation.
Definition: gig.h:283
gig::dimension_t
dimension_t
Defines the type of dimension, that is how the dimension zones (and thus how the dimension regions ar...
Definition: gig.h:343
gig::MidiRule
Abstract base class for all MIDI rules.
Definition: gig.h:1005
gig::DimensionRegion::AttenuationController
attenuation_ctrl_t AttenuationController
MIDI Controller which has influence on the volume level of the sample (or entire sample group).
Definition: gig.h:620
gig::vcf_res_ctrl_t
vcf_res_ctrl_t
Defines how the filter resonance is controlled by.
Definition: gig.h:250
gig::DimensionRegion
Encapsulates articulation informations of a dimension region.
Definition: gig.h:535
gig::Sample::LoopFraction
uint32_t LoopFraction
The fractional value specifies a fraction of a sample at which to loop. This allows a loop to be fine...
Definition: gig.h:829
gig::Region::DeleteDimension
void DeleteDimension(dimension_def_t *pDimDef)
Delete an existing dimension.
Definition: gig.cpp:3719
gig::leverage_ctrl_t::type_t
type_t
Defines possible controllers.
Definition: gig.h:270
DLS::File::GetFileName
String GetFileName()
File name of this DLS file.
Definition: DLS.cpp:1841
gig::Instrument::DimensionKeyRange
range_t DimensionKeyRange
0-127 (where 0 means C1 and 127 means G9)
Definition: gig.h:1284
gig::curve_type_unknown
@ curve_type_unknown
Unknown curve type.
Definition: gig.h:156
gig::MidiRuleAlternator::Selector
selector_t Selector
Method by which pattern is chosen.
Definition: gig.h:1125
gig::eg_opt_t
Defines behavior options for envelope generators (gig format extension).
Definition: gig.h:451
gig::Region::Dimensions
unsigned int Dimensions
Number of defined dimensions, do not alter!
Definition: gig.h:929
gig::DimensionRegion::EG2ControllerInvert
bool EG2ControllerInvert
Invert values coming from defined EG2 controller.
Definition: gig.h:570
gig::lfo2_ctrl_internal_modwheel
@ lfo2_ctrl_internal_modwheel
Controlled internally and by external modulation wheel.
Definition: gig.h:207
gig::Region::UpdateChunks
virtual void UpdateChunks(progress_t *pProgress)
Apply Region settings and all its DimensionRegions to the respective RIFF chunks.
Definition: gig.cpp:3399
gig::DimensionRegion::LFO3ControlDepth
int16_t LFO3ControlDepth
Controller depth of the sample pitch LFO (-1200 - +1200 cents).
Definition: gig.h:589
gig::MidiRuleLegato::BypassKey
uint8_t BypassKey
Key to be used to bypass the sustain note.
Definition: gig.h:1071
gig::DimensionRegion::EG2Options
eg_opt_t EG2Options
[gig extension]: Behavior options which should be used for envelope generator 2 (filter cutoff EG).
Definition: gig.h:630
gig::MidiRuleAlternator::Polyphonic
bool Polyphonic
If alternator should step forward only when all notes are off.
Definition: gig.h:1129
gig::MidiRuleAlternator::Patterns
uint8_t Patterns
Number of alternator patterns.
Definition: gig.h:1106
gig::DimensionRegion::EG3Attack
double EG3Attack
Attack time of the sample pitch EG (0.000 - 10.000s).
Definition: gig.h:583
gig::vcf_type_highpass
@ vcf_type_highpass
Highpass filter type (GigaStudio).
Definition: gig.h:396
RIFF::file_offset_t
uint64_t file_offset_t
Type used by libgig for handling file positioning during file I/O tasks.
Definition: RIFF.h:160
gig::Sample::Sample
Sample(File *pFile, RIFF::List *waveList, file_offset_t WavePoolOffset, unsigned long fileNo=0, int index=-1)
Constructor.
Definition: gig.cpp:390
gig::Sample::LoopSize
uint32_t LoopSize
Caution: Use the respective fields in the DimensionRegion instead of this one! (Intended purpose: Len...
Definition: gig.h:828
gig::Script::Uuid
uint8_t Uuid[16]
Persistent Universally Unique Identifier of this script, which remains identical after any changes to...
Definition: gig.h:1196
gig::dimension_def_t::dimension
dimension_t dimension
Specifies which source (usually a MIDI controller) is associated with the dimension.
Definition: gig.h:358
gig::dimension_portamentotime
@ dimension_portamentotime
Portamento Time (Coarse, MIDI Controller 5)
Definition: gig.h:343
gig::DimensionRegion::LFO1FlipPhase
bool LFO1FlipPhase
Inverts the polarity of the sample amplitude LFO wave, so it flips the wave form vertically.
Definition: gig.h:559
gig::lfo1_ctrl_internal_modwheel
@ lfo1_ctrl_internal_modwheel
Controlled internally and by external modulation wheel.
Definition: gig.h:219
DLS::Storage
Abstract base class for all classes using RIFF::Chunks for persistency.
Definition: DLS.h:283
gig::Script::ENCODING_ASCII
@ ENCODING_ASCII
Standard 8 bit US ASCII character encoding (default).
Definition: gig.h:1182
gig::vcf_cutoff_ctrl_none
@ vcf_cutoff_ctrl_none
No MIDI controller assigned for filter cutoff frequency.
Definition: gig.h:238
RIFF
RIFF specific classes and definitions.
Definition: RIFF.h:150
gig::Sample::GetPos
file_offset_t GetPos() const
Returns the current position in the sample (in sample points).
Definition: gig.cpp:926
gig::libraryVersion
String libraryVersion()
Returns version of this C++ library.
Definition: gig.cpp:7413
gig::Sample::UpdateChunks
virtual void UpdateChunks(progress_t *pProgress)
Apply sample and its settings to the respective RIFF chunks.
Definition: gig.cpp:574
gig::Sample::LoopStart
uint32_t LoopStart
Caution: Use the respective field in the DimensionRegion instead of this one! (Intended purpose: The ...
Definition: gig.h:826
gig::enumKey
const char * enumKey(String typeName, size_t value)
Enum constant name of numeric value.
Definition: typeinfo.cpp:280
gig::dimension_effect2
@ dimension_effect2
Effect Controller 2 (Coarse, MIDI Controller 13)
Definition: gig.h:343
gig::dim_bypass_ctrl_94
@ dim_bypass_ctrl_94
Effect 4 Depth (MIDI Controller 94)
Definition: gig.h:183
gig::eg_opt_t::Decay1Cancel
bool Decay1Cancel
Whether the "decay 1" stage is cancelled when receiving a note-off (default: true).
Definition: gig.h:454
gig::DimensionRegion::LFO2InternalDepth
uint16_t LFO2InternalDepth
Firm pitch of the filter cutoff LFO (0 - 1200 cents).
Definition: gig.h:577
gig::DimensionRegion::EG1Decay2
double EG1Decay2
Only if EG1InfiniteSustain == false: 2nd decay stage time of the sample amplitude EG (0....
Definition: gig.h:543
gig::Sample::Dithered
bool Dithered
For 24-bit compressed samples only: if dithering was used during compression with bit reduction.
Definition: gig.h:833
gig::Script::Name
String Name
Arbitrary name of the script, which may be displayed i.e. in an instrument editor.
Definition: gig.h:1191
gig::crossfade_t
Defines the envelope of a crossfade.
Definition: gig.h:405
DLS::Instrument::Regions
uint32_t Regions
Reflects the number of Region defintions this Instrument has.
Definition: DLS.h:530
gig::lfo2_ctrl_internal_foot
@ lfo2_ctrl_internal_foot
Controlled internally and by external foot controller.
Definition: gig.h:207
gig::MidiRuleAlternator::pArticulations
String pArticulations[32]
Names of the articulations.
Definition: gig.h:1102
gig::Sample::LoadSampleData
buffer_t LoadSampleData()
Loads (and uncompresses if needed) the whole sample wave into RAM.
Definition: gig.cpp:706
gig::Sample::Manufacturer
uint32_t Manufacturer
Specifies the MIDI Manufacturer's Association (MMA) Manufacturer code for the sampler intended to rec...
Definition: gig.h:816
gig::DimensionRegion::LFO1Sync
bool LFO1Sync
If set to true only one LFO should be used for all voices.
Definition: gig.h:560
gig::Sample::CopyAssignMeta
void CopyAssignMeta(const Sample *orig)
Make a (semi) deep copy of the Sample object given by orig (without the actual waveform data) and ass...
Definition: gig.cpp:510
gig::sust_rel_trg_keyvelocity
@ sust_rel_trg_keyvelocity
Play release trigger sample(s) on sustain pedal up, and use the key`s last MIDI note-on velocity for ...
Definition: gig.h:482
DLS::Sampler::AddSampleLoop
void AddSampleLoop(sample_loop_t *pLoopDef)
Adds a new sample loop with the provided loop definition.
Definition: DLS.cpp:706
gig::dimension_effect3depth
@ dimension_effect3depth
Effect 3 Depth (MIDI Controller 93)
Definition: gig.h:343
gig::Sample::ReleaseSampleData
void ReleaseSampleData()
Frees the cached sample from RAM if loaded with LoadSampleData() previously.
Definition: gig.cpp:829
gig::vcf_type_bandreject
@ vcf_type_bandreject
Band reject filter type (GigaStudio).
Definition: gig.h:396
gig::dimension_genpurpose2
@ dimension_genpurpose2
General Purpose Controller 2 (Slider, MIDI Controller 17)
Definition: gig.h:343
gig::DimensionRegion::pSample
Sample * pSample
Points to the Sample which is assigned to the dimension region.
Definition: gig.h:538
gig::lfo2_ctrl_t
lfo2_ctrl_t
Defines how LFO2 is controlled by.
Definition: gig.h:207