/[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 1524 by schoenebeck, Sun Nov 25 17:29:37 2007 UTC revision 2540 by schoenebeck, Wed Apr 23 16:39:43 2014 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-2014 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
# Line 45  Line 44 
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
# Line 431  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);
# Line 452  namespace gig { Line 450  namespace gig {
450              void SetVCFVelocityScale(uint8_t scaling);              void SetVCFVelocityScale(uint8_t scaling);
451              Region* GetParent() const;              Region* GetParent() const;
452              // derived methods              // derived methods
453              DLS::Sampler::AddSampleLoop;              using DLS::Sampler::AddSampleLoop;
454              DLS::Sampler::DeleteSampleLoop;              using DLS::Sampler::DeleteSampleLoop;
455              // overridden methods              // overridden methods
456              virtual void SetGain(int32_t gain);              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(Region* pParent, RIFF::List* _3ewl);              DimensionRegion(Region* pParent, RIFF::List* _3ewl);
462              DimensionRegion(RIFF::List* _3ewl, const DimensionRegion& src);              DimensionRegion(RIFF::List* _3ewl, const DimensionRegion& src);
463             ~DimensionRegion();             ~DimensionRegion();
464                void CopyAssign(const DimensionRegion* orig, const std::map<Sample*,Sample*>* mSamples);
465              friend class Region;              friend class Region;
466          private:          private:
467              typedef enum { ///< Used to decode attenuation, EG1 and EG2 controller              typedef enum { ///< Used to decode attenuation, EG1 and EG2 controller
468                    // official leverage controllers as they were defined in the original Gigasampler/GigaStudio format:
469                  _lev_ctrl_none              = 0x00,                  _lev_ctrl_none              = 0x00,
470                  _lev_ctrl_modwheel          = 0x03, ///< Modulation Wheel (MIDI Controller 1)                  _lev_ctrl_modwheel          = 0x03, ///< Modulation Wheel (MIDI Controller 1)
471                  _lev_ctrl_breath            = 0x05, ///< Breath Controller (Coarse, MIDI Controller 2)                  _lev_ctrl_breath            = 0x05, ///< Breath Controller (Coarse, MIDI Controller 2)
# Line 490  namespace gig { Line 491  namespace gig {
491                  _lev_ctrl_effect4depth      = 0x2b, ///< Effect 4 Depth (MIDI Controller 94)                  _lev_ctrl_effect4depth      = 0x2b, ///< Effect 4 Depth (MIDI Controller 94)
492                  _lev_ctrl_effect5depth      = 0x2d, ///< Effect 5 Depth (MIDI Controller 95)                  _lev_ctrl_effect5depth      = 0x2d, ///< Effect 5 Depth (MIDI Controller 95)
493                  _lev_ctrl_channelaftertouch = 0x2f, ///< Channel Key Pressure                  _lev_ctrl_channelaftertouch = 0x2f, ///< Channel Key Pressure
494                  _lev_ctrl_velocity          = 0xff  ///< Key Velocity                  _lev_ctrl_velocity          = 0xff, ///< Key Velocity
495    
496                    // format extension (these controllers are so far only supported by LinuxSampler & gigedit) they will *NOT* work with Gigasampler/GigaStudio !
497                    // (the assigned values here are their official MIDI CC number plus the highest bit set):
498                    _lev_ctrl_CC3_EXT           = 0x83, ///< MIDI Controller 3 [gig format extension]
499    
500                    _lev_ctrl_CC6_EXT           = 0x86, ///< Data Entry MSB (MIDI Controller 6) [gig format extension]
501                    _lev_ctrl_CC7_EXT           = 0x87, ///< Channel Volume (MIDI Controller 7) [gig format extension]
502                    _lev_ctrl_CC8_EXT           = 0x88, ///< Balance (MIDI Controller 8) [gig format extension]
503                    _lev_ctrl_CC9_EXT           = 0x89, ///< MIDI Controller 9 [gig format extension]
504                    _lev_ctrl_CC10_EXT          = 0x8a, ///< Pan (MIDI Controller 10) [gig format extension]
505                    _lev_ctrl_CC11_EXT          = 0x8b, ///< Expression Controller (MIDI Controller 11) [gig format extension]
506    
507                    _lev_ctrl_CC14_EXT          = 0x8e, ///< MIDI Controller 14 [gig format extension]
508                    _lev_ctrl_CC15_EXT          = 0x8f, ///< MIDI Controller 15 [gig format extension]
509    
510                    _lev_ctrl_CC20_EXT          = 0x94, ///< MIDI Controller 20 [gig format extension]
511                    _lev_ctrl_CC21_EXT          = 0x95, ///< MIDI Controller 21 [gig format extension]
512                    _lev_ctrl_CC22_EXT          = 0x96, ///< MIDI Controller 22 [gig format extension]
513                    _lev_ctrl_CC23_EXT          = 0x97, ///< MIDI Controller 23 [gig format extension]
514                    _lev_ctrl_CC24_EXT          = 0x98, ///< MIDI Controller 24 [gig format extension]
515                    _lev_ctrl_CC25_EXT          = 0x99, ///< MIDI Controller 25 [gig format extension]
516                    _lev_ctrl_CC26_EXT          = 0x9a, ///< MIDI Controller 26 [gig format extension]
517                    _lev_ctrl_CC27_EXT          = 0x9b, ///< MIDI Controller 27 [gig format extension]
518                    _lev_ctrl_CC28_EXT          = 0x9c, ///< MIDI Controller 28 [gig format extension]
519                    _lev_ctrl_CC29_EXT          = 0x9d, ///< MIDI Controller 29 [gig format extension]
520                    _lev_ctrl_CC30_EXT          = 0x9e, ///< MIDI Controller 30 [gig format extension]
521                    _lev_ctrl_CC31_EXT          = 0x9f, ///< MIDI Controller 31 [gig format extension]
522    
523                    _lev_ctrl_CC68_EXT          = 0xc4, ///< Legato Footswitch (MIDI Controller 68) [gig format extension]
524                    _lev_ctrl_CC69_EXT          = 0xc5, ///< Hold 2 (MIDI Controller 69) [gig format extension]
525                    _lev_ctrl_CC70_EXT          = 0xc6, ///< Sound Ctrl. 1 - Sound Variation (MIDI Controller 70) [gig format extension]
526                    _lev_ctrl_CC71_EXT          = 0xc7, ///< Sound Ctrl. 2 - Timbre (MIDI Controller 71) [gig format extension]
527                    _lev_ctrl_CC72_EXT          = 0xc8, ///< Sound Ctrl. 3 - Release Time (MIDI Controller 72) [gig format extension]
528                    _lev_ctrl_CC73_EXT          = 0xc9, ///< Sound Ctrl. 4 - Attack Time (MIDI Controller 73) [gig format extension]
529                    _lev_ctrl_CC74_EXT          = 0xca, ///< Sound Ctrl. 5 - Brightness (MIDI Controller 74) [gig format extension]
530                    _lev_ctrl_CC75_EXT          = 0xcb, ///< Sound Ctrl. 6 - Decay Time (MIDI Controller 75) [gig format extension]
531                    _lev_ctrl_CC76_EXT          = 0xcc, ///< Sound Ctrl. 7 - Vibrato Rate (MIDI Controller 76) [gig format extension]
532                    _lev_ctrl_CC77_EXT          = 0xcd, ///< Sound Ctrl. 8 - Vibrato Depth (MIDI Controller 77) [gig format extension]
533                    _lev_ctrl_CC78_EXT          = 0xce, ///< Sound Ctrl. 9 - Vibrato Delay (MIDI Controller 78) [gig format extension]
534                    _lev_ctrl_CC79_EXT          = 0xcf, ///< Sound Ctrl. 10 (MIDI Controller 79) [gig format extension]
535    
536                    _lev_ctrl_CC84_EXT          = 0xd4, ///< Portamento Control (MIDI Controller 84) [gig format extension]
537                    _lev_ctrl_CC85_EXT          = 0xd5, ///< MIDI Controller 85 [gig format extension]
538                    _lev_ctrl_CC86_EXT          = 0xd6, ///< MIDI Controller 86 [gig format extension]
539                    _lev_ctrl_CC87_EXT          = 0xd7, ///< MIDI Controller 87 [gig format extension]
540    
541                    _lev_ctrl_CC89_EXT          = 0xd9, ///< MIDI Controller 89 [gig format extension]
542                    _lev_ctrl_CC90_EXT          = 0xda, ///< MIDI Controller 90 [gig format extension]
543    
544                    _lev_ctrl_CC96_EXT          = 0xe0, ///< Data Increment (MIDI Controller 96) [gig format extension]
545                    _lev_ctrl_CC97_EXT          = 0xe1, ///< Data Decrement (MIDI Controller 97) [gig format extension]
546    
547                    _lev_ctrl_CC102_EXT         = 0xe6, ///< MIDI Controller 102 [gig format extension]
548                    _lev_ctrl_CC103_EXT         = 0xe7, ///< MIDI Controller 103 [gig format extension]
549                    _lev_ctrl_CC104_EXT         = 0xe8, ///< MIDI Controller 104 [gig format extension]
550                    _lev_ctrl_CC105_EXT         = 0xe9, ///< MIDI Controller 105 [gig format extension]
551                    _lev_ctrl_CC106_EXT         = 0xea, ///< MIDI Controller 106 [gig format extension]
552                    _lev_ctrl_CC107_EXT         = 0xeb, ///< MIDI Controller 107 [gig format extension]
553                    _lev_ctrl_CC108_EXT         = 0xec, ///< MIDI Controller 108 [gig format extension]
554                    _lev_ctrl_CC109_EXT         = 0xed, ///< MIDI Controller 109 [gig format extension]
555                    _lev_ctrl_CC110_EXT         = 0xee, ///< MIDI Controller 110 [gig format extension]
556                    _lev_ctrl_CC111_EXT         = 0xef, ///< MIDI Controller 111 [gig format extension]
557                    _lev_ctrl_CC112_EXT         = 0xf0, ///< MIDI Controller 112 [gig format extension]
558                    _lev_ctrl_CC113_EXT         = 0xf1, ///< MIDI Controller 113 [gig format extension]
559                    _lev_ctrl_CC114_EXT         = 0xf2, ///< MIDI Controller 114 [gig format extension]
560                    _lev_ctrl_CC115_EXT         = 0xf3, ///< MIDI Controller 115 [gig format extension]
561                    _lev_ctrl_CC116_EXT         = 0xf4, ///< MIDI Controller 116 [gig format extension]
562                    _lev_ctrl_CC117_EXT         = 0xf5, ///< MIDI Controller 117 [gig format extension]
563                    _lev_ctrl_CC118_EXT         = 0xf6, ///< MIDI Controller 118 [gig format extension]
564                    _lev_ctrl_CC119_EXT         = 0xf7  ///< MIDI Controller 119 [gig format extension]
565              } _lev_ctrl_t;              } _lev_ctrl_t;
566              typedef std::map<uint32_t, double*> VelocityTableMap;              typedef std::map<uint32_t, double*> VelocityTableMap;
567    
# Line 558  namespace gig { Line 629  namespace gig {
629              void          ReleaseSampleData();              void          ReleaseSampleData();
630              void          Resize(int iNewSize);              void          Resize(int iNewSize);
631              unsigned long SetPos(unsigned long SampleCount, RIFF::stream_whence_t Whence = RIFF::stream_start);              unsigned long SetPos(unsigned long SampleCount, RIFF::stream_whence_t Whence = RIFF::stream_start);
632              unsigned long GetPos();              unsigned long GetPos() const;
633              unsigned long Read(void* pBuffer, unsigned long SampleCount, buffer_t* pExternalDecompressionBuffer = NULL);              unsigned long Read(void* pBuffer, unsigned long SampleCount, buffer_t* pExternalDecompressionBuffer = NULL);
634              unsigned long ReadAndLoop(void* pBuffer, unsigned long SampleCount, playback_state_t* pPlaybackState, DimensionRegion* pDimRgn, buffer_t* pExternalDecompressionBuffer = NULL);              unsigned long ReadAndLoop(void* pBuffer, unsigned long SampleCount, playback_state_t* pPlaybackState, DimensionRegion* pDimRgn, buffer_t* pExternalDecompressionBuffer = NULL);
635              unsigned long Write(void* pBuffer, unsigned long SampleCount);              unsigned long Write(void* pBuffer, unsigned long SampleCount);
636              Group*        GetGroup() const;              Group*        GetGroup() const;
637              virtual void  UpdateChunks();              virtual void  UpdateChunks();
638                void CopyAssignMeta(const Sample* orig);
639                void CopyAssignWave(const Sample* orig);
640          protected:          protected:
641              static unsigned int  Instances;               ///< Number of instances of class Sample.              static unsigned int  Instances;               ///< Number of instances of class Sample.
642              static buffer_t      InternalDecompressionBuffer; ///< Buffer used for decompression as well as for truncation of 24 Bit -> 16 Bit samples.              static buffer_t      InternalDecompressionBuffer; ///< Buffer used for decompression as well as for truncation of 24 Bit -> 16 Bit samples.
# Line 630  namespace gig { Line 703  namespace gig {
703              // overridden methods              // overridden methods
704              virtual void     SetKeyRange(uint16_t Low, uint16_t High);              virtual void     SetKeyRange(uint16_t Low, uint16_t High);
705              virtual void     UpdateChunks();              virtual void     UpdateChunks();
706                virtual void     CopyAssign(const Region* orig);
707          protected:          protected:
708              Region(Instrument* pInstrument, RIFF::List* rgnList);              Region(Instrument* pInstrument, RIFF::List* rgnList);
709              void LoadDimensionRegions(RIFF::List* rgn);              void LoadDimensionRegions(RIFF::List* rgn);
710              void UpdateVelocityTable();              void UpdateVelocityTable();
711              Sample* GetSampleFromWavePool(unsigned int WavePoolTableIndex, progress_t* pProgress = NULL);              Sample* GetSampleFromWavePool(unsigned int WavePoolTableIndex, progress_t* pProgress = NULL);
712                void CopyAssign(const Region* orig, const std::map<Sample*,Sample*>* mSamples);
713             ~Region();             ~Region();
714              friend class Instrument;              friend class Instrument;
715      };      };
716    
717        /** Abstract base class for all MIDI rules. */
718        class MidiRule {
719            public:
720                virtual ~MidiRule() { }
721            protected:
722                virtual void UpdateChunks(uint8_t* pData) const = 0;
723                friend class Instrument;
724        };
725    
726        /** MIDI rule for triggering notes by control change events. */
727        class MidiRuleCtrlTrigger : public MidiRule {
728            public:
729                uint8_t ControllerNumber;   ///< MIDI controller number.
730                uint8_t Triggers;           ///< Number of triggers.
731                struct trigger_t {
732                    uint8_t TriggerPoint;   ///< The CC value to pass for the note to be triggered.
733                    bool    Descending;     ///< If the change in CC value should be downwards.
734                    uint8_t VelSensitivity; ///< How sensitive the velocity should be to the speed of the controller change.
735                    uint8_t Key;            ///< Key to trigger.
736                    bool    NoteOff;        ///< If a note off should be triggered instead of a note on.
737                    uint8_t Velocity;       ///< Velocity of the note to trigger. 255 means that velocity should depend on the speed of the controller change.
738                    bool    OverridePedal;  ///< If a note off should be triggered even if the sustain pedal is down.
739                } pTriggers[32];
740    
741            protected:
742                MidiRuleCtrlTrigger(RIFF::Chunk* _3ewg);
743                MidiRuleCtrlTrigger();
744                void UpdateChunks(uint8_t* pData) const;
745                friend class Instrument;
746        };
747    
748        /** MIDI rule for instruments with legato samples. */
749        class MidiRuleLegato : public MidiRule {
750            public:
751                uint8_t LegatoSamples;     ///< Number of legato samples per key in each direction (always 12)
752                bool BypassUseController;  ///< If a controller should be used to bypass the sustain note
753                uint8_t BypassKey;         ///< Key to be used to bypass the sustain note
754                uint8_t BypassController;  ///< Controller to be used to bypass the sustain note
755                uint16_t ThresholdTime;    ///< Maximum time (ms) between two notes that should be played legato
756                uint16_t ReleaseTime;      ///< Release time
757                range_t KeyRange;          ///< Key range for legato notes
758                uint8_t ReleaseTriggerKey; ///< Key triggering release samples
759                uint8_t AltSustain1Key;    ///< Key triggering alternate sustain samples
760                uint8_t AltSustain2Key;    ///< Key triggering a second set of alternate sustain samples
761    
762            protected:
763                MidiRuleLegato(RIFF::Chunk* _3ewg);
764                MidiRuleLegato();
765                void UpdateChunks(uint8_t* pData) const;
766                friend class Instrument;
767        };
768    
769        /** MIDI rule to automatically cycle through specified sequences of different articulations. The instrument must be using the smartmidi dimension. */
770        class MidiRuleAlternator : public MidiRule {
771            public:
772                uint8_t Articulations;     ///< Number of articulations in the instrument
773                String pArticulations[32]; ///< Names of the articulations
774    
775                range_t PlayRange;         ///< Key range of the playable keys in the instrument
776    
777                uint8_t Patterns;          ///< Number of alternator patterns
778                struct pattern_t {
779                    String Name;           ///< Name of the pattern
780                    int Size;              ///< Number of steps in the pattern
781                    const uint8_t& operator[](int i) const { /// Articulation to play
782                        return data[i];
783                    }
784                    uint8_t& operator[](int i) {
785                        return data[i];
786                    }
787                private:
788                    uint8_t data[32];
789                } pPatterns[32];           ///< A pattern is a sequence of articulation numbers
790    
791                typedef enum {
792                    selector_none,
793                    selector_key_switch,
794                    selector_controller
795                } selector_t;
796                selector_t Selector;       ///< Method by which pattern is chosen
797                range_t KeySwitchRange;    ///< Key range for key switch selector
798                uint8_t Controller;        ///< CC number for controller selector
799    
800                bool Polyphonic;           ///< If alternator should step forward only when all notes are off
801                bool Chained;              ///< If all patterns should be chained together
802    
803            protected:
804                MidiRuleAlternator(RIFF::Chunk* _3ewg);
805                MidiRuleAlternator();
806                void UpdateChunks(uint8_t* pData) const;
807                friend class Instrument;
808        };
809    
810        /** A MIDI rule not yet implemented by libgig. */
811        class MidiRuleUnknown : public MidiRule {
812            protected:
813                MidiRuleUnknown() { }
814                void UpdateChunks(uint8_t* pData) const { }
815                friend class Instrument;
816        };
817    
818      /** Provides all neccessary information for the synthesis of an <i>Instrument</i>. */      /** Provides all neccessary information for the synthesis of an <i>Instrument</i>. */
819      class Instrument : protected DLS::Instrument {      class Instrument : protected DLS::Instrument {
820          public:          public:
821              // derived attributes from DLS::Resource              // derived attributes from DLS::Resource
822              DLS::Resource::pInfo;              using DLS::Resource::pInfo;
823              DLS::Resource::pDLSID;              using DLS::Resource::pDLSID;
824              // derived attributes from DLS::Instrument              // derived attributes from DLS::Instrument
825              DLS::Instrument::IsDrum;              using DLS::Instrument::IsDrum;
826              DLS::Instrument::MIDIBank;              using DLS::Instrument::MIDIBank;
827              DLS::Instrument::MIDIBankCoarse;              using DLS::Instrument::MIDIBankCoarse;
828              DLS::Instrument::MIDIBankFine;              using DLS::Instrument::MIDIBankFine;
829              DLS::Instrument::MIDIProgram;              using DLS::Instrument::MIDIProgram;
830              DLS::Instrument::Regions;              using DLS::Instrument::Regions;
831              // own attributes              // own attributes
832              int32_t   Attenuation;       ///< in dB              int32_t   Attenuation;       ///< in dB
833              uint16_t  EffectSend;              uint16_t  EffectSend;
# Line 662  namespace gig { Line 838  namespace gig {
838    
839    
840              // derived methods from DLS::Resource              // derived methods from DLS::Resource
841              DLS::Resource::GetParent;              using DLS::Resource::GetParent;
842              // overridden methods              // overridden methods
843              Region*   GetFirstRegion();              Region*   GetFirstRegion();
844              Region*   GetNextRegion();              Region*   GetNextRegion();
845              Region*   AddRegion();              Region*   AddRegion();
846              void      DeleteRegion(Region* pRegion);              void      DeleteRegion(Region* pRegion);
847              virtual void UpdateChunks();              virtual void UpdateChunks();
848                virtual void CopyAssign(const Instrument* orig);
849              // own methods              // own methods
850              Region*   GetRegion(unsigned int Key);              Region*   GetRegion(unsigned int Key);
851                MidiRule* GetMidiRule(int i);
852                MidiRuleCtrlTrigger* AddMidiRuleCtrlTrigger();
853                MidiRuleLegato*      AddMidiRuleLegato();
854                MidiRuleAlternator*  AddMidiRuleAlternator();
855                void      DeleteMidiRule(int i);
856          protected:          protected:
857              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
858    
859              Instrument(File* pFile, RIFF::List* insList, progress_t* pProgress = NULL);              Instrument(File* pFile, RIFF::List* insList, progress_t* pProgress = NULL);
860             ~Instrument();             ~Instrument();
861                void CopyAssign(const Instrument* orig, const std::map<Sample*,Sample*>* mSamples);
862              void UpdateRegionKeyTable();              void UpdateRegionKeyTable();
863              friend class File;              friend class File;
864              friend class Region; // so Region can call UpdateRegionKeyTable()              friend class Region; // so Region can call UpdateRegionKeyTable()
865            private:
866                MidiRule** pMidiRules;
867      };      };
868    
869      /** @brief Group of Gigasampler objects      /** @brief Group of Gigasampler objects
# Line 711  namespace gig { Line 896  namespace gig {
896              friend class File;              friend class File;
897          private:          private:
898              File*        pFile;              File*        pFile;
899              RIFF::Chunk* pNameChunk;              RIFF::Chunk* pNameChunk; ///< '3gnm' chunk
900      };      };
901    
902      /** Parses Gigasampler files and provides abstract access to the data. */      /** Parses Gigasampler files and provides abstract access to the data. */
# Line 721  namespace gig { Line 906  namespace gig {
906              static const DLS::version_t VERSION_3;              static const DLS::version_t VERSION_3;
907    
908              // derived attributes from DLS::Resource              // derived attributes from DLS::Resource
909              DLS::Resource::pInfo;              using DLS::Resource::pInfo;
910              DLS::Resource::pDLSID;              using DLS::Resource::pDLSID;
911              // derived attributes from DLS::File              // derived attributes from DLS::File
912              DLS::File::pVersion;              using DLS::File::pVersion;
913              DLS::File::Instruments;              using DLS::File::Instruments;
914    
915              // derived methods from DLS::Resource              // derived methods from DLS::Resource
916              DLS::Resource::GetParent;              using DLS::Resource::GetParent;
917              // derived methods from DLS::File              // derived methods from DLS::File
918              DLS::File::Save;              using DLS::File::Save;
919                using DLS::File::GetFileName;
920                using DLS::File::SetFileName;
921              // overridden  methods              // overridden  methods
922              File();              File();
923              File(RIFF::File* pRIFF);              File(RIFF::File* pRIFF);
924              Sample*     GetFirstSample(progress_t* pProgress = NULL); ///< Returns a pointer to the first <i>Sample</i> object of the file, <i>NULL</i> otherwise.              Sample*     GetFirstSample(progress_t* pProgress = NULL); ///< Returns a pointer to the first <i>Sample</i> object of the file, <i>NULL</i> otherwise.
925              Sample*     GetNextSample();      ///< Returns a pointer to the next <i>Sample</i> object of the file, <i>NULL</i> otherwise.              Sample*     GetNextSample();      ///< Returns a pointer to the next <i>Sample</i> object of the file, <i>NULL</i> otherwise.
926                Sample*     GetSample(uint index);
927              Sample*     AddSample();              Sample*     AddSample();
928              void        DeleteSample(Sample* pSample);              void        DeleteSample(Sample* pSample);
929              Instrument* GetFirstInstrument(); ///< Returns a pointer to the first <i>Instrument</i> object of the file, <i>NULL</i> otherwise.              Instrument* GetFirstInstrument(); ///< Returns a pointer to the first <i>Instrument</i> object of the file, <i>NULL</i> otherwise.
930              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.
931              Instrument* GetInstrument(uint index, progress_t* pProgress = NULL);              Instrument* GetInstrument(uint index, progress_t* pProgress = NULL);
932              Instrument* AddInstrument();              Instrument* AddInstrument();
933                Instrument* AddDuplicateInstrument(const Instrument* orig);
934              void        DeleteInstrument(Instrument* pInstrument);              void        DeleteInstrument(Instrument* pInstrument);
935              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.
936              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 751  namespace gig { Line 940  namespace gig {
940              void        DeleteGroupOnly(Group* pGroup);              void        DeleteGroupOnly(Group* pGroup);
941              void        SetAutoLoad(bool b);              void        SetAutoLoad(bool b);
942              bool        GetAutoLoad();              bool        GetAutoLoad();
943                void        AddContentOf(File* pFile);
944              virtual    ~File();              virtual    ~File();
945              virtual void UpdateChunks();              virtual void UpdateChunks();
946          protected:          protected:
Legend:
Removed from v.1524  
changed lines
  Added in v.2540
  ViewVC Help
Powered by ViewVC