/[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 2394 by schoenebeck, Mon Jan 7 23:23:58 2013 UTC revision 2482 by schoenebeck, Mon Nov 25 02:22:38 2013 UTC
# Line 461  namespace gig { Line 461  namespace gig {
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
# Line 557  namespace gig { Line 558  namespace gig {
558              void          ReleaseSampleData();              void          ReleaseSampleData();
559              void          Resize(int iNewSize);              void          Resize(int iNewSize);
560              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);
561              unsigned long GetPos();              unsigned long GetPos() const;
562              unsigned long Read(void* pBuffer, unsigned long SampleCount, buffer_t* pExternalDecompressionBuffer = NULL);              unsigned long Read(void* pBuffer, unsigned long SampleCount, buffer_t* pExternalDecompressionBuffer = NULL);
563              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);
564              unsigned long Write(void* pBuffer, unsigned long SampleCount);              unsigned long Write(void* pBuffer, unsigned long SampleCount);
565              Group*        GetGroup() const;              Group*        GetGroup() const;
566              virtual void  UpdateChunks();              virtual void  UpdateChunks();
567                void CopyAssignMeta(const Sample* orig);
568                void CopyAssignWave(const Sample* orig);
569          protected:          protected:
570              static unsigned int  Instances;               ///< Number of instances of class Sample.              static unsigned int  Instances;               ///< Number of instances of class Sample.
571              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 635  namespace gig { Line 638  namespace gig {
638              void LoadDimensionRegions(RIFF::List* rgn);              void LoadDimensionRegions(RIFF::List* rgn);
639              void UpdateVelocityTable();              void UpdateVelocityTable();
640              Sample* GetSampleFromWavePool(unsigned int WavePoolTableIndex, progress_t* pProgress = NULL);              Sample* GetSampleFromWavePool(unsigned int WavePoolTableIndex, progress_t* pProgress = NULL);
641                void CopyAssign(const Region* orig, const std::map<Sample*,Sample*>* mSamples);
642             ~Region();             ~Region();
643              friend class Instrument;              friend class Instrument;
644      };      };
# Line 643  namespace gig { Line 647  namespace gig {
647      class MidiRule {      class MidiRule {
648          public:          public:
649              virtual ~MidiRule() { }              virtual ~MidiRule() { }
650            protected:
651                virtual void UpdateChunks(uint8_t* pData) const = 0;
652                friend class Instrument;
653      };      };
654    
655      /** MIDI rule for triggering notes by control change events. */      /** MIDI rule for triggering notes by control change events. */
# Line 662  namespace gig { Line 669  namespace gig {
669    
670          protected:          protected:
671              MidiRuleCtrlTrigger(RIFF::Chunk* _3ewg);              MidiRuleCtrlTrigger(RIFF::Chunk* _3ewg);
672                MidiRuleCtrlTrigger();
673                void UpdateChunks(uint8_t* pData) const;
674                friend class Instrument;
675        };
676    
677        /** MIDI rule for instruments with legato samples. */
678        class MidiRuleLegato : public MidiRule {
679            public:
680                uint8_t LegatoSamples;     ///< Number of legato samples per key in each direction (always 12)
681                bool BypassUseController;  ///< If a controller should be used to bypass the sustain note
682                uint8_t BypassKey;         ///< Key to be used to bypass the sustain note
683                uint8_t BypassController;  ///< Controller to be used to bypass the sustain note
684                uint16_t ThresholdTime;    ///< Maximum time (ms) between two notes that should be played legato
685                uint16_t ReleaseTime;      ///< Release time
686                range_t KeyRange;          ///< Key range for legato notes
687                uint8_t ReleaseTriggerKey; ///< Key triggering release samples
688                uint8_t AltSustain1Key;    ///< Key triggering alternate sustain samples
689                uint8_t AltSustain2Key;    ///< Key triggering a second set of alternate sustain samples
690    
691            protected:
692                MidiRuleLegato(RIFF::Chunk* _3ewg);
693                MidiRuleLegato();
694                void UpdateChunks(uint8_t* pData) const;
695                friend class Instrument;
696        };
697    
698        /** MIDI rule to automatically cycle through specified sequences of different articulations. The instrument must be using the smartmidi dimension. */
699        class MidiRuleAlternator : public MidiRule {
700            public:
701                uint8_t Articulations;     ///< Number of articulations in the instrument
702                String pArticulations[32]; ///< Names of the articulations
703    
704                range_t PlayRange;         ///< Key range of the playable keys in the instrument
705    
706                uint8_t Patterns;          ///< Number of alternator patterns
707                struct pattern_t {
708                    String Name;           ///< Name of the pattern
709                    int Size;              ///< Number of steps in the pattern
710                    const uint8_t& operator[](int i) const { /// Articulation to play
711                        return data[i];
712                    }
713                    uint8_t& operator[](int i) {
714                        return data[i];
715                    }
716                private:
717                    uint8_t data[32];
718                } pPatterns[32];           ///< A pattern is a sequence of articulation numbers
719    
720                typedef enum {
721                    selector_none,
722                    selector_key_switch,
723                    selector_controller
724                } selector_t;
725                selector_t Selector;       ///< Method by which pattern is chosen
726                range_t KeySwitchRange;    ///< Key range for key switch selector
727                uint8_t Controller;        ///< CC number for controller selector
728    
729                bool Polyphonic;           ///< If alternator should step forward only when all notes are off
730                bool Chained;              ///< If all patterns should be chained together
731    
732            protected:
733                MidiRuleAlternator(RIFF::Chunk* _3ewg);
734                MidiRuleAlternator();
735                void UpdateChunks(uint8_t* pData) const;
736                friend class Instrument;
737        };
738    
739        /** A MIDI rule not yet implemented by libgig. */
740        class MidiRuleUnknown : public MidiRule {
741            protected:
742                MidiRuleUnknown() { }
743                void UpdateChunks(uint8_t* pData) const { }
744              friend class Instrument;              friend class Instrument;
745      };      };
746    
# Line 699  namespace gig { Line 778  namespace gig {
778              // own methods              // own methods
779              Region*   GetRegion(unsigned int Key);              Region*   GetRegion(unsigned int Key);
780              MidiRule* GetMidiRule(int i);              MidiRule* GetMidiRule(int i);
781                MidiRuleCtrlTrigger* AddMidiRuleCtrlTrigger();
782                MidiRuleLegato*      AddMidiRuleLegato();
783                MidiRuleAlternator*  AddMidiRuleAlternator();
784                void      DeleteMidiRule(int i);
785          protected:          protected:
786              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
787    
788              Instrument(File* pFile, RIFF::List* insList, progress_t* pProgress = NULL);              Instrument(File* pFile, RIFF::List* insList, progress_t* pProgress = NULL);
789             ~Instrument();             ~Instrument();
790                void CopyAssign(const Instrument* orig, const std::map<Sample*,Sample*>* mSamples);
791              void UpdateRegionKeyTable();              void UpdateRegionKeyTable();
792              friend class File;              friend class File;
793              friend class Region; // so Region can call UpdateRegionKeyTable()              friend class Region; // so Region can call UpdateRegionKeyTable()
# Line 741  namespace gig { Line 825  namespace gig {
825              friend class File;              friend class File;
826          private:          private:
827              File*        pFile;              File*        pFile;
828              RIFF::Chunk* pNameChunk;              RIFF::Chunk* pNameChunk; ///< '3gnm' chunk
829      };      };
830    
831      /** Parses Gigasampler files and provides abstract access to the data. */      /** Parses Gigasampler files and provides abstract access to the data. */
# Line 762  namespace gig { Line 846  namespace gig {
846              // derived methods from DLS::File              // derived methods from DLS::File
847              using DLS::File::Save;              using DLS::File::Save;
848              using DLS::File::GetFileName;              using DLS::File::GetFileName;
849                using DLS::File::SetFileName;
850              // overridden  methods              // overridden  methods
851              File();              File();
852              File(RIFF::File* pRIFF);              File(RIFF::File* pRIFF);
853              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.
854              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.
855                Sample*     GetSample(uint index);
856              Sample*     AddSample();              Sample*     AddSample();
857              void        DeleteSample(Sample* pSample);              void        DeleteSample(Sample* pSample);
858              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.
# Line 783  namespace gig { Line 869  namespace gig {
869              void        DeleteGroupOnly(Group* pGroup);              void        DeleteGroupOnly(Group* pGroup);
870              void        SetAutoLoad(bool b);              void        SetAutoLoad(bool b);
871              bool        GetAutoLoad();              bool        GetAutoLoad();
872                void        AddContentOf(File* pFile);
873              virtual    ~File();              virtual    ~File();
874              virtual void UpdateChunks();              virtual void UpdateChunks();
875          protected:          protected:
Legend:
Removed from v.2394  
changed lines
  Added in v.2482
  ViewVC Help
Powered by ViewVC