/[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 1416 by schoenebeck, Sun Oct 14 12:06:32 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
# 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);
# Line 630  namespace gig { Line 629  namespace gig {
629              // overridden methods              // overridden methods
630              virtual void     SetKeyRange(uint16_t Low, uint16_t High);              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 639  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 662  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;
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 679  namespace gig { Line 786  namespace gig {
786              void UpdateRegionKeyTable();              void UpdateRegionKeyTable();
787              friend class File;              friend class File;
788              friend class Region; // so Region can call UpdateRegionKeyTable()              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 721  namespace gig { Line 830  namespace gig {
830              static const DLS::version_t VERSION_3;              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 742  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 749  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 766  namespace gig { Line 879  namespace gig {
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.1416  
changed lines
  Added in v.2450
  ViewVC Help
Powered by ViewVC