/[svn]/libgig/trunk/src/gig.h
ViewVC logotype

Diff of /libgig/trunk/src/gig.h

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1154 by schoenebeck, Wed Apr 11 16:33:56 2007 UTC revision 2450 by persson, Wed May 8 17:53:07 2013 UTC
# Line 2  Line 2 
2   *                                                                         *   *                                                                         *
3   *   libgig - C++ cross-platform Gigasampler format file access library    *   *   libgig - C++ cross-platform Gigasampler format file access library    *
4   *                                                                         *   *                                                                         *
5   *   Copyright (C) 2003-2007 by Christian Schoenebeck                      *   *   Copyright (C) 2003-2013 by Christian Schoenebeck                      *
6   *                              <cuse@users.sourceforge.net>               *   *                              <cuse@users.sourceforge.net>               *
7   *                                                                         *   *                                                                         *
8   *   This library is free software; you can redistribute it and/or modify  *   *   This library is free software; you can redistribute it and/or modify  *
# Line 31  Line 31 
31  # define LIST_TYPE_3EWL 0x3365776C  # define LIST_TYPE_3EWL 0x3365776C
32  # define LIST_TYPE_3GRI 0x33677269  # define LIST_TYPE_3GRI 0x33677269
33  # define LIST_TYPE_3GNL 0x33676E6C  # define LIST_TYPE_3GNL 0x33676E6C
 # define CHUNK_ID_SMPL  0x736D706C  
34  # define CHUNK_ID_3GIX  0x33676978  # define CHUNK_ID_3GIX  0x33676978
35  # define CHUNK_ID_3EWA  0x33657761  # define CHUNK_ID_3EWA  0x33657761
36  # define CHUNK_ID_3LNK  0x336C6E6B  # define CHUNK_ID_3LNK  0x336C6E6B
37  # define CHUNK_ID_3EWG  0x33657767  # define CHUNK_ID_3EWG  0x33657767
38  # define CHUNK_ID_EWAV  0x65776176  # define CHUNK_ID_EWAV  0x65776176
39  # define CHUNK_ID_3GNM  0x33676E6D  # define CHUNK_ID_3GNM  0x33676E6D
40    # define CHUNK_ID_EINF  0x65696E66
41    # define CHUNK_ID_3CRC  0x33637263
42  #else  // little endian  #else  // little endian
43  # define LIST_TYPE_3PRG 0x67727033  # define LIST_TYPE_3PRG 0x67727033
44  # define LIST_TYPE_3EWL 0x6C776533  # define LIST_TYPE_3EWL 0x6C776533
45  # define LIST_TYPE_3GRI 0x69726733  # define LIST_TYPE_3GRI 0x69726733
46  # define LIST_TYPE_3GNL 0x6C6E6733  # define LIST_TYPE_3GNL 0x6C6E6733
 # define CHUNK_ID_SMPL  0x6C706D73  
47  # define CHUNK_ID_3GIX  0x78696733  # define CHUNK_ID_3GIX  0x78696733
48  # define CHUNK_ID_3EWA  0x61776533  # define CHUNK_ID_3EWA  0x61776533
49  # define CHUNK_ID_3LNK  0x6B6E6C33  # define CHUNK_ID_3LNK  0x6B6E6C33
50  # define CHUNK_ID_3EWG  0x67776533  # define CHUNK_ID_3EWG  0x67776533
51  # define CHUNK_ID_EWAV  0x76617765  # define CHUNK_ID_EWAV  0x76617765
52  # define CHUNK_ID_3GNM  0x6D6E6733  # define CHUNK_ID_3GNM  0x6D6E6733
53    # define CHUNK_ID_EINF  0x666E6965
54    # define CHUNK_ID_3CRC  0x63726333
55  #endif // WORDS_BIGENDIAN  #endif // WORDS_BIGENDIAN
56    
57  /** Gigasampler specific classes and definitions */  /** Gigasampler specific classes and definitions */
# Line 392  namespace gig { Line 394  namespace gig {
394              // Filter              // Filter
395              bool               VCFEnabled;                    ///< If filter should be used.              bool               VCFEnabled;                    ///< If filter should be used.
396              vcf_type_t         VCFType;                       ///< Defines the general filter characteristic (lowpass, highpass, bandpass, etc.).              vcf_type_t         VCFType;                       ///< Defines the general filter characteristic (lowpass, highpass, bandpass, etc.).
397              vcf_cutoff_ctrl_t  VCFCutoffController;           ///< Specifies which external controller has influence on the filter cutoff frequency.              vcf_cutoff_ctrl_t  VCFCutoffController;           ///< Specifies which external controller has influence on the filter cutoff frequency. @deprecated Don't alter directly, use SetVCFCutoffController() instead!
398              bool               VCFCutoffControllerInvert;     ///< Inverts values coming from the defined cutoff controller              bool               VCFCutoffControllerInvert;     ///< Inverts values coming from the defined cutoff controller
399              uint8_t            VCFCutoff;                     ///< Max. cutoff frequency.              uint8_t            VCFCutoff;                     ///< Max. cutoff frequency.
400              curve_type_t       VCFVelocityCurve;              ///< Defines a transformation curve for the incoming velocity values, affecting the VCF.              curve_type_t       VCFVelocityCurve;              ///< Defines a transformation curve for the incoming velocity values, affecting the VCF. @deprecated Don't alter directly, use SetVCFVelocityCurve() instead!
401              uint8_t            VCFVelocityScale;              ///< (0-127) Amount velocity controls VCF cutoff frequency (only if no other VCF cutoff controller is defined, otherwise this is the minimum cutoff).              uint8_t            VCFVelocityScale;              ///< (0-127) Amount velocity controls VCF cutoff frequency (only if no other VCF cutoff controller is defined, otherwise this is the minimum cutoff). @deprecated Don't alter directly, use SetVCFVelocityScale() instead!
402              uint8_t            VCFVelocityDynamicRange;       ///< 0x04 = lowest, 0x00 = highest              uint8_t            VCFVelocityDynamicRange;       ///< 0x04 = lowest, 0x00 = highest . @deprecated Don't alter directly, use SetVCFVelocityDynamicRange() instead!
403              uint8_t            VCFResonance;                  ///< Firm internal filter resonance weight.              uint8_t            VCFResonance;                  ///< Firm internal filter resonance weight.
404              bool               VCFResonanceDynamic;           ///< If <i>true</i>: Increases the resonance Q according to changes of controllers that actually control the VCF cutoff frequency (EG2, ext. VCF MIDI controller).              bool               VCFResonanceDynamic;           ///< If <i>true</i>: Increases the resonance Q according to changes of controllers that actually control the VCF cutoff frequency (EG2, ext. VCF MIDI controller).
405              vcf_res_ctrl_t     VCFResonanceController;        ///< Specifies which external controller has influence on the filter resonance Q.              vcf_res_ctrl_t     VCFResonanceController;        ///< Specifies which external controller has influence on the filter resonance Q.
406              bool               VCFKeyboardTracking;           ///< If <i>true</i>: VCF cutoff frequence will be dependend to the note key position relative to the defined breakpoint value.              bool               VCFKeyboardTracking;           ///< If <i>true</i>: VCF cutoff frequence will be dependend to the note key position relative to the defined breakpoint value.
407              uint8_t            VCFKeyboardTrackingBreakpoint; ///< See VCFKeyboardTracking (0 - 127).              uint8_t            VCFKeyboardTrackingBreakpoint; ///< See VCFKeyboardTracking (0 - 127).
408              // Key Velocity Transformations              // Key Velocity Transformations
409              curve_type_t       VelocityResponseCurve;         ///< Defines a transformation curve to the incoming velocity values affecting amplitude (usually you don't have to interpret this parameter, use GetVelocityAttenuation() instead).              curve_type_t       VelocityResponseCurve;         ///< Defines a transformation curve to the incoming velocity values affecting amplitude (usually you don't have to interpret this parameter, use GetVelocityAttenuation() instead). @deprecated Don't alter directly, use SetVelocityResponseCurve() instead!
410              uint8_t            VelocityResponseDepth;         ///< Dynamic range of velocity affecting amplitude (0 - 4) (usually you don't have to interpret this parameter, use GetVelocityAttenuation() instead).              uint8_t            VelocityResponseDepth;         ///< Dynamic range of velocity affecting amplitude (0 - 4) (usually you don't have to interpret this parameter, use GetVelocityAttenuation() instead). @deprecated Don't alter directly, use SetVelocityResponseDepth() instead!
411              uint8_t            VelocityResponseCurveScaling;  ///< 0 - 127 (usually you don't have to interpret this parameter, use GetVelocityAttenuation() instead)              uint8_t            VelocityResponseCurveScaling;  ///< 0 - 127 (usually you don't have to interpret this parameter, use GetVelocityAttenuation() instead). @deprecated Don't alter directly, use SetVelocityResponseCurveScaling() instead!
412              curve_type_t       ReleaseVelocityResponseCurve;  ///< Defines a transformation curve to the incoming release veloctiy values affecting envelope times.              curve_type_t       ReleaseVelocityResponseCurve;  ///< Defines a transformation curve to the incoming release veloctiy values affecting envelope times. @deprecated Don't alter directly, use SetReleaseVelocityResponseCurve() instead!
413              uint8_t            ReleaseVelocityResponseDepth;  ///< Dynamic range of release velocity affecting envelope time (0 - 4).              uint8_t            ReleaseVelocityResponseDepth;  ///< Dynamic range of release velocity affecting envelope time (0 - 4). @deprecated Don't alter directly, use SetReleaseVelocityResponseDepth() instead!
414              uint8_t            ReleaseTriggerDecay;           ///< 0 - 8              uint8_t            ReleaseTriggerDecay;           ///< 0 - 8
415              // Mix / Layer              // Mix / Layer
416              crossfade_t        Crossfade;              crossfade_t        Crossfade;
# Line 427  namespace gig { Line 429  namespace gig {
429              uint8_t            DimensionUpperLimits[8];       ///< gig3: defines the upper limit of the dimension values for this dimension region              uint8_t            DimensionUpperLimits[8];       ///< gig3: defines the upper limit of the dimension values for this dimension region
430    
431              // derived attributes from DLS::Sampler              // derived attributes from DLS::Sampler
432              DLS::Sampler::UnityNote;              using DLS::Sampler::UnityNote;
433              DLS::Sampler::FineTune;              using DLS::Sampler::FineTune;
434              DLS::Sampler::Gain;              using DLS::Sampler::Gain;
435              DLS::Sampler::SampleLoops;              using DLS::Sampler::SampleLoops;
436              DLS::Sampler::pSampleLoops;              using DLS::Sampler::pSampleLoops;
437    
438              // own methods              // own methods
439              double GetVelocityAttenuation(uint8_t MIDIKeyVelocity);              double GetVelocityAttenuation(uint8_t MIDIKeyVelocity);
440              double GetVelocityRelease(uint8_t MIDIKeyVelocity);              double GetVelocityRelease(uint8_t MIDIKeyVelocity);
441              double GetVelocityCutoff(uint8_t MIDIKeyVelocity);              double GetVelocityCutoff(uint8_t MIDIKeyVelocity);
442                void SetVelocityResponseCurve(curve_type_t curve);
443                void SetVelocityResponseDepth(uint8_t depth);
444                void SetVelocityResponseCurveScaling(uint8_t scaling);
445                void SetReleaseVelocityResponseCurve(curve_type_t curve);
446                void SetReleaseVelocityResponseDepth(uint8_t depth);
447                void SetVCFCutoffController(vcf_cutoff_ctrl_t controller);
448                void SetVCFVelocityCurve(curve_type_t curve);
449                void SetVCFVelocityDynamicRange(uint8_t range);
450                void SetVCFVelocityScale(uint8_t scaling);
451                Region* GetParent() const;
452                // derived methods
453                using DLS::Sampler::AddSampleLoop;
454                using DLS::Sampler::DeleteSampleLoop;
455              // overridden methods              // overridden methods
456                virtual void SetGain(int32_t gain);
457              virtual void UpdateChunks();              virtual void UpdateChunks();
458                virtual void CopyAssign(const DimensionRegion* orig);
459          protected:          protected:
460              uint8_t* VelocityTable; ///< For velocity dimensions with custom defined zone ranges only: used for fast converting from velocity MIDI value to dimension bit number.              uint8_t* VelocityTable; ///< For velocity dimensions with custom defined zone ranges only: used for fast converting from velocity MIDI value to dimension bit number.
461              DimensionRegion(RIFF::List* _3ewl);              DimensionRegion(Region* pParent, RIFF::List* _3ewl);
462                DimensionRegion(RIFF::List* _3ewl, const DimensionRegion& src);
463             ~DimensionRegion();             ~DimensionRegion();
464              friend class Region;              friend class Region;
465          private:          private:
# Line 480  namespace gig { Line 498  namespace gig {
498              double*                  pVelocityAttenuationTable;  ///< Points to the velocity table corresponding to the velocity parameters of this DimensionRegion.              double*                  pVelocityAttenuationTable;  ///< Points to the velocity table corresponding to the velocity parameters of this DimensionRegion.
499              double*                  pVelocityReleaseTable;      ///< Points to the velocity table corresponding to the release velocity parameters of this DimensionRegion              double*                  pVelocityReleaseTable;      ///< Points to the velocity table corresponding to the release velocity parameters of this DimensionRegion
500              double*                  pVelocityCutoffTable;       ///< Points to the velocity table corresponding to the filter velocity parameters of this DimensionRegion              double*                  pVelocityCutoffTable;       ///< Points to the velocity table corresponding to the filter velocity parameters of this DimensionRegion
501                Region*                  pRegion;
502    
503              leverage_ctrl_t DecodeLeverageController(_lev_ctrl_t EncodedController);              leverage_ctrl_t DecodeLeverageController(_lev_ctrl_t EncodedController);
504              _lev_ctrl_t     EncodeLeverageController(leverage_ctrl_t DecodedController);              _lev_ctrl_t     EncodeLeverageController(leverage_ctrl_t DecodedController);
505                double* GetReleaseVelocityTable(curve_type_t releaseVelocityResponseCurve, uint8_t releaseVelocityResponseDepth);
506                double* GetCutoffVelocityTable(curve_type_t vcfVelocityCurve, uint8_t vcfVelocityDynamicRange, uint8_t vcfVelocityScale, vcf_cutoff_ctrl_t vcfCutoffController);
507              double* GetVelocityTable(curve_type_t curveType, uint8_t depth, uint8_t scaling);              double* GetVelocityTable(curve_type_t curveType, uint8_t depth, uint8_t scaling);
508              double* CreateVelocityTable(curve_type_t curveType, uint8_t depth, uint8_t scaling);              double* CreateVelocityTable(curve_type_t curveType, uint8_t depth, uint8_t scaling);
509      };      };
# Line 556  namespace gig { Line 577  namespace gig {
577              unsigned long        FileNo;                  ///< File number (> 0 when sample is stored in an extension file, 0 when it's in the gig)              unsigned long        FileNo;                  ///< File number (> 0 when sample is stored in an extension file, 0 when it's in the gig)
578              RIFF::Chunk*         pCk3gix;              RIFF::Chunk*         pCk3gix;
579              RIFF::Chunk*         pCkSmpl;              RIFF::Chunk*         pCkSmpl;
580                uint32_t             crc;                     ///< CRC-32 checksum of the raw sample data
581    
582              Sample(File* pFile, RIFF::List* waveList, unsigned long WavePoolOffset, unsigned long fileNo = 0);              Sample(File* pFile, RIFF::List* waveList, unsigned long WavePoolOffset, unsigned long fileNo = 0);
583             ~Sample();             ~Sample();
# Line 598  namespace gig { Line 620  namespace gig {
620              DimensionRegion*        pDimensionRegions[256];   ///< Pointer array to the 32 (gig2) or 256 (gig3) possible dimension regions (reflects NULL for dimension regions not in use). Avoid to access the array directly and better use GetDimensionRegionByValue() instead, but of course in some cases it makes sense to use the array (e.g. iterating through all DimensionRegions). Use AddDimension() and DeleteDimension() to create a new dimension or delete an existing one (which will create or delete the respective dimension region(s) automatically).              DimensionRegion*        pDimensionRegions[256];   ///< Pointer array to the 32 (gig2) or 256 (gig3) possible dimension regions (reflects NULL for dimension regions not in use). Avoid to access the array directly and better use GetDimensionRegionByValue() instead, but of course in some cases it makes sense to use the array (e.g. iterating through all DimensionRegions). Use AddDimension() and DeleteDimension() to create a new dimension or delete an existing one (which will create or delete the respective dimension region(s) automatically).
621              unsigned int            Layers;                   ///< Amount of defined layers (1 - 32). A value of 1 actually means no layering, a value > 1 means there is Layer dimension. The same information can of course also be obtained by accessing pDimensionDefinitions. Do not alter this value!              unsigned int            Layers;                   ///< Amount of defined layers (1 - 32). A value of 1 actually means no layering, a value > 1 means there is Layer dimension. The same information can of course also be obtained by accessing pDimensionDefinitions. Do not alter this value!
622    
623                // own methods
624              DimensionRegion* GetDimensionRegionByValue(const uint DimValues[8]);              DimensionRegion* GetDimensionRegionByValue(const uint DimValues[8]);
625              DimensionRegion* GetDimensionRegionByBit(const uint8_t DimBits[8]);              DimensionRegion* GetDimensionRegionByBit(const uint8_t DimBits[8]);
626              Sample*          GetSample();              Sample*          GetSample();
627              void             AddDimension(dimension_def_t* pDimDef);              void             AddDimension(dimension_def_t* pDimDef);
628              void             DeleteDimension(dimension_def_t* pDimDef);              void             DeleteDimension(dimension_def_t* pDimDef);
629                // overridden methods
630                virtual void     SetKeyRange(uint16_t Low, uint16_t High);
631              virtual void     UpdateChunks();              virtual void     UpdateChunks();
632                virtual void     CopyAssign(const Region* orig);
633          protected:          protected:
634              Region(Instrument* pInstrument, RIFF::List* rgnList);              Region(Instrument* pInstrument, RIFF::List* rgnList);
635              void LoadDimensionRegions(RIFF::List* rgn);              void LoadDimensionRegions(RIFF::List* rgn);
# Line 613  namespace gig { Line 639  namespace gig {
639              friend class Instrument;              friend class Instrument;
640      };      };
641    
642        /** Abstract base class for all MIDI rules. */
643        class MidiRule {
644            public:
645                virtual ~MidiRule() { }
646            protected:
647                virtual void UpdateChunks(uint8_t* pData) const = 0;
648                friend class Instrument;
649        };
650    
651        /** MIDI rule for triggering notes by control change events. */
652        class MidiRuleCtrlTrigger : public MidiRule {
653            public:
654                uint8_t ControllerNumber;   ///< MIDI controller number.
655                uint8_t Triggers;           ///< Number of triggers.
656                struct trigger_t {
657                    uint8_t TriggerPoint;   ///< The CC value to pass for the note to be triggered.
658                    bool    Descending;     ///< If the change in CC value should be downwards.
659                    uint8_t VelSensitivity; ///< How sensitive the velocity should be to the speed of the controller change.
660                    uint8_t Key;            ///< Key to trigger.
661                    bool    NoteOff;        ///< If a note off should be triggered instead of a note on.
662                    uint8_t Velocity;       ///< Velocity of the note to trigger. 255 means that velocity should depend on the speed of the controller change.
663                    bool    OverridePedal;  ///< If a note off should be triggered even if the sustain pedal is down.
664                } pTriggers[32];
665    
666            protected:
667                MidiRuleCtrlTrigger(RIFF::Chunk* _3ewg);
668                MidiRuleCtrlTrigger();
669                void UpdateChunks(uint8_t* pData) const;
670                friend class Instrument;
671        };
672    
673        /** MIDI rule for instruments with legato samples. */
674        class MidiRuleLegato : public MidiRule {
675            public:
676                uint8_t LegatoSamples;     ///< Number of legato samples per key in each direction (always 12)
677                bool BypassUseController;  ///< If a controller should be used to bypass the sustain note
678                uint8_t BypassKey;         ///< Key to be used to bypass the sustain note
679                uint8_t BypassController;  ///< Controller to be used to bypass the sustain note
680                uint16_t ThresholdTime;    ///< Maximum time (ms) between two notes that should be played legato
681                uint16_t ReleaseTime;      ///< Release time
682                range_t KeyRange;          ///< Key range for legato notes
683                uint8_t ReleaseTriggerKey; ///< Key triggering release samples
684                uint8_t AltSustain1Key;    ///< Key triggering alternate sustain samples
685                uint8_t AltSustain2Key;    ///< Key triggering a second set of alternate sustain samples
686    
687            protected:
688                MidiRuleLegato(RIFF::Chunk* _3ewg);
689                MidiRuleLegato();
690                void UpdateChunks(uint8_t* pData) const;
691                friend class Instrument;
692        };
693    
694        /** MIDI rule to automatically cycle through specified sequences of different articulations. The instrument must be using the smartmidi dimension. */
695        class MidiRuleAlternator : public MidiRule {
696            public:
697                uint8_t Articulations;     ///< Number of articulations in the instrument
698                String pArticulations[32]; ///< Names of the articulations
699    
700                range_t PlayRange;         ///< Key range of the playable keys in the instrument
701    
702                uint8_t Patterns;          ///< Number of alternator patterns
703                struct pattern_t {
704                    String Name;           ///< Name of the pattern
705                    int Size;              ///< Number of steps in the pattern
706                    const uint8_t& operator[](int i) const { /// Articulation to play
707                        return data[i];
708                    }
709                    uint8_t& operator[](int i) {
710                        return data[i];
711                    }
712                private:
713                    uint8_t data[32];
714                } pPatterns[32];           ///< A pattern is a sequence of articulation numbers
715    
716                typedef enum {
717                    selector_none,
718                    selector_key_switch,
719                    selector_controller
720                } selector_t;
721                selector_t Selector;       ///< Method by which pattern is chosen
722                range_t KeySwitchRange;    ///< Key range for key switch selector
723                uint8_t Controller;        ///< CC number for controller selector
724    
725                bool Polyphonic;           ///< If alternator should step forward only when all notes are off
726                bool Chained;              ///< If all patterns should be chained together
727    
728            protected:
729                MidiRuleAlternator(RIFF::Chunk* _3ewg);
730                MidiRuleAlternator();
731                void UpdateChunks(uint8_t* pData) const;
732                friend class Instrument;
733        };
734    
735        /** A MIDI rule not yet implemented by libgig. */
736        class MidiRuleUnknown : public MidiRule {
737            protected:
738                MidiRuleUnknown() { }
739                void UpdateChunks(uint8_t* pData) const { }
740                friend class Instrument;
741        };
742    
743      /** Provides all neccessary information for the synthesis of an <i>Instrument</i>. */      /** Provides all neccessary information for the synthesis of an <i>Instrument</i>. */
744      class Instrument : protected DLS::Instrument {      class Instrument : protected DLS::Instrument {
745          public:          public:
746              // derived attributes from DLS::Resource              // derived attributes from DLS::Resource
747              DLS::Resource::pInfo;              using DLS::Resource::pInfo;
748              DLS::Resource::pDLSID;              using DLS::Resource::pDLSID;
749              // derived attributes from DLS::Instrument              // derived attributes from DLS::Instrument
750              DLS::Instrument::IsDrum;              using DLS::Instrument::IsDrum;
751              DLS::Instrument::MIDIBank;              using DLS::Instrument::MIDIBank;
752              DLS::Instrument::MIDIBankCoarse;              using DLS::Instrument::MIDIBankCoarse;
753              DLS::Instrument::MIDIBankFine;              using DLS::Instrument::MIDIBankFine;
754              DLS::Instrument::MIDIProgram;              using DLS::Instrument::MIDIProgram;
755              DLS::Instrument::Regions;              using DLS::Instrument::Regions;
756              // own attributes              // own attributes
757              int32_t   Attenuation;       ///< in dB              int32_t   Attenuation;       ///< in dB
758              uint16_t  EffectSend;              uint16_t  EffectSend;
# Line 636  namespace gig { Line 763  namespace gig {
763    
764    
765              // derived methods from DLS::Resource              // derived methods from DLS::Resource
766              DLS::Resource::GetParent;              using DLS::Resource::GetParent;
             // derived methods from DLS::Instrument  
             DLS::Instrument::MoveRegion;  
767              // overridden methods              // overridden methods
768              Region*   GetFirstRegion();              Region*   GetFirstRegion();
769              Region*   GetNextRegion();              Region*   GetNextRegion();
770              Region*   AddRegion();              Region*   AddRegion();
771              void      DeleteRegion(Region* pRegion);              void      DeleteRegion(Region* pRegion);
772              virtual void UpdateChunks();              virtual void UpdateChunks();
773                virtual void CopyAssign(const Instrument* orig);
774              // own methods              // own methods
775              Region*   GetRegion(unsigned int Key);              Region*   GetRegion(unsigned int Key);
776                MidiRule* GetMidiRule(int i);
777                MidiRuleCtrlTrigger* AddMidiRuleCtrlTrigger();
778                MidiRuleLegato*      AddMidiRuleLegato();
779                MidiRuleAlternator*  AddMidiRuleAlternator();
780                void      DeleteMidiRule(int i);
781          protected:          protected:
782              Region*   RegionKeyTable[128]; ///< fast lookup for the corresponding Region of a MIDI key              Region*   RegionKeyTable[128]; ///< fast lookup for the corresponding Region of a MIDI key
783    
# Line 654  namespace gig { Line 785  namespace gig {
785             ~Instrument();             ~Instrument();
786              void UpdateRegionKeyTable();              void UpdateRegionKeyTable();
787              friend class File;              friend class File;
788                friend class Region; // so Region can call UpdateRegionKeyTable()
789            private:
790                MidiRule** pMidiRules;
791      };      };
792    
793      /** @brief Group of Gigasampler objects      /** @brief Group of Gigasampler objects
# Line 692  namespace gig { Line 826  namespace gig {
826      /** Parses Gigasampler files and provides abstract access to the data. */      /** Parses Gigasampler files and provides abstract access to the data. */
827      class File : protected DLS::File {      class File : protected DLS::File {
828          public:          public:
829                static const DLS::version_t VERSION_2;
830                static const DLS::version_t VERSION_3;
831    
832              // derived attributes from DLS::Resource              // derived attributes from DLS::Resource
833              DLS::Resource::pInfo;              using DLS::Resource::pInfo;
834              DLS::Resource::pDLSID;              using DLS::Resource::pDLSID;
835              // derived attributes from DLS::File              // derived attributes from DLS::File
836              DLS::File::pVersion;              using DLS::File::pVersion;
837              DLS::File::Instruments;              using DLS::File::Instruments;
838    
839              // derived methods from DLS::Resource              // derived methods from DLS::Resource
840              DLS::Resource::GetParent;              using DLS::Resource::GetParent;
841              // derived methods from DLS::File              // derived methods from DLS::File
842              DLS::File::Save;              using DLS::File::Save;
843                using DLS::File::GetFileName;
844              // overridden  methods              // overridden  methods
845              File();              File();
846              File(RIFF::File* pRIFF);              File(RIFF::File* pRIFF);
# Line 714  namespace gig { Line 852  namespace gig {
852              Instrument* GetNextInstrument();  ///< Returns a pointer to the next <i>Instrument</i> object of the file, <i>NULL</i> otherwise.              Instrument* GetNextInstrument();  ///< Returns a pointer to the next <i>Instrument</i> object of the file, <i>NULL</i> otherwise.
853              Instrument* GetInstrument(uint index, progress_t* pProgress = NULL);              Instrument* GetInstrument(uint index, progress_t* pProgress = NULL);
854              Instrument* AddInstrument();              Instrument* AddInstrument();
855                Instrument* AddDuplicateInstrument(const Instrument* orig);
856              void        DeleteInstrument(Instrument* pInstrument);              void        DeleteInstrument(Instrument* pInstrument);
857              Group*      GetFirstGroup(); ///< Returns a pointer to the first <i>Group</i> object of the file, <i>NULL</i> otherwise.              Group*      GetFirstGroup(); ///< Returns a pointer to the first <i>Group</i> object of the file, <i>NULL</i> otherwise.
858              Group*      GetNextGroup();  ///< Returns a pointer to the next <i>Group</i> object of the file, <i>NULL</i> otherwise.              Group*      GetNextGroup();  ///< Returns a pointer to the next <i>Group</i> object of the file, <i>NULL</i> otherwise.
# Line 721  namespace gig { Line 860  namespace gig {
860              Group*      AddGroup();              Group*      AddGroup();
861              void        DeleteGroup(Group* pGroup);              void        DeleteGroup(Group* pGroup);
862              void        DeleteGroupOnly(Group* pGroup);              void        DeleteGroupOnly(Group* pGroup);
863                void        SetAutoLoad(bool b);
864                bool        GetAutoLoad();
865              virtual    ~File();              virtual    ~File();
866              virtual void UpdateChunks();              virtual void UpdateChunks();
867          protected:          protected:
# Line 731  namespace gig { Line 872  namespace gig {
872              // own protected methods              // own protected methods
873              virtual void LoadSamples(progress_t* pProgress);              virtual void LoadSamples(progress_t* pProgress);
874              virtual void LoadInstruments(progress_t* pProgress);              virtual void LoadInstruments(progress_t* pProgress);
875                void SetSampleChecksum(Sample* pSample, uint32_t crc);
876              friend class Region;              friend class Region;
877              friend class Sample;              friend class Sample;
878              friend class Group; // so Group can access protected member pRIFF              friend class Group; // so Group can access protected member pRIFF
879          private:          private:
880              std::list<Group*>*          pGroups;              std::list<Group*>*          pGroups;
881              std::list<Group*>::iterator GroupsIterator;              std::list<Group*>::iterator GroupsIterator;
882                bool                        bAutoLoad;
883      };      };
884    
885      /**      /**
Legend:
Removed from v.1154  
changed lines
  Added in v.2450
  ViewVC Help
Powered by ViewVC