trunk/src/SF.h

/***************************************************************************
 *                                                                         *
 *   libsf2 - C++ cross-platform SF2 format file access library            *
 *                                                                         *
 *   Copyright (C) 2009 by Grigor Iliev  <grigor@grigoriliev.com>          *
 *                                                                         *
 *   This library is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This library is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this library; if not, write to the Free Software           *
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
 *   MA  02111-1307  USA                                                   *
 ***************************************************************************/

#ifndef __SF2_SF_H__
#define __SF2_SF_H__

#include "RIFF.h"

#include <vector>


#if WORDS_BIGENDIAN
#define ENDIAN_SWAP(x) \
        ( (x>>24) | ((x<<8) & 0x00FF0000) | ((x>>8) & 0x0000FF00) | (x<<24) )
#else
#define ENDIAN_SWAP(x) (x)
#endif

#define RIFF_ID(x) ENDIAN_SWAP( (*((uint32_t*) x)) )


#define RIFF_TYPE_SF2   RIFF_ID("sfbk")

// Level 0
#define LIST_TYPE_INFO  RIFF_ID("INFO")
#define LIST_TYPE_SDTA  RIFF_ID("sdta")
#define LIST_TYPE_PDTA  RIFF_ID("pdta")

// Level 1
//<INFO-list>
#define CHUNK_ID_IFIL   RIFF_ID("ifil")
#define CHUNK_ID_ISNG   RIFF_ID("isng")
#define CHUNK_ID_INAM   RIFF_ID("INAM")
#define CHUNK_ID_IROM   RIFF_ID("irom")
#define CHUNK_ID_IVER   RIFF_ID("iver")
#define CHUNK_ID_ICRD   RIFF_ID("ICRD")
#define CHUNK_ID_IENG   RIFF_ID("IENG")
#define CHUNK_ID_IPRD   RIFF_ID("IPRD")
#define CHUNK_ID_ICOP   RIFF_ID("ICOP")
#define CHUNK_ID_ICMT   RIFF_ID("ICMT")
#define CHUNK_ID_ISFT   RIFF_ID("ISFT")

//<sdta-list>
#define CHUNK_ID_SMPL   RIFF_ID("smpl")
#define CHUNK_ID_SM24   RIFF_ID("sm24")

//<pdta-list>
#define CHUNK_ID_PHDR   RIFF_ID("phdr")
#define CHUNK_ID_PBAG   RIFF_ID("pbag")
#define CHUNK_ID_PMOD   RIFF_ID("pmod")
#define CHUNK_ID_PGEN   RIFF_ID("pgen")
#define CHUNK_ID_INST   RIFF_ID("inst")
#define CHUNK_ID_IBAG   RIFF_ID("ibag")
#define CHUNK_ID_IMOD   RIFF_ID("imod")
#define CHUNK_ID_IGEN   RIFF_ID("igen")
#define CHUNK_ID_SHDR   RIFF_ID("shdr")

#define NONE 0x1ffffff

namespace sf2 {
    typedef struct _PresetBag {
        uint16_t GenNdx;
        uint16_t ModNdx;
    } PresetBag;

    typedef uint16_t SFModulator;
    typedef uint16_t SFGenerator;
    typedef uint16_t SFTransform;

    typedef struct _ModList {
        SFModulator  ModSrcOper;
        SFGenerator  ModDestOper;
        uint16_t     ModAmount;
        SFModulator  ModAmtSrcOper;
        SFTransform  ModTransOper;
    } ModList;

    typedef struct _RangesType {
        uint8_t byLo;
        uint8_t byHi;
    } RangesType;

    typedef union _GenAmountType {
        RangesType  ranges;
        short       shAmount;
        uint16_t    wAmount;
    } GenAmountType;

    typedef struct _GenList {
        SFGenerator    GenOper;
        GenAmountType  GenAmount;
    } GenList;

    typedef struct _InstBag {
        uint16_t InstGenNdx;
        uint16_t InstModNdx;
    } InstBag;

    typedef enum {
        START_ADDRS_OFFSET = 0,
        END_ADDRS_OFFSET,
        STARTLOOP_ADDRS_OFFSET,
        ENDLOOP_ADDRS_OFFSET ,
        START_ADDRS_COARSE_OFFSET,
        MOD_LFO_TO_PITCH,
        VIB_LFO_TO_PITCH,
        MOD_ENV_TO_PITCH,
        INITIAL_FILTER_FC,
        INITIAL_FILTER_Q,
        MOD_LFO_TO_FILTER_FC, // 10
        MOD_ENV_TO_FILTER_FC,
        END_ADDRS_COARSE_OFFSET,
        MOD_LFO_TO_VOLUME,
        UNUSED1,
        CHORUS_EFFECTS_SEND,
        REVERB_EFFECTS_SEND,
        PAN,
        UNUSED2,
        UNUSED3,
        UNUSED4, //20
        DELAY_MOD_LFO,
        FREQ_MOD_LFO,
        DELAY_VIB_LFO,
        FREQ_VIB_LFO,
        DELAY_MOD_ENV,
        ATTACK_MOD_ENV,
        HOLD_MOD_ENV,
        DECAY_MOD_ENV,
        SUSTAIN_MOD_ENV,
        RELEASEMODENV, // 30
        KEYNUM_TO_MOD_ENV_HOLD,
        KEYNUM_TO_MOD_ENV_DECAY,
        DELAY_VOL_ENV,
        ATTACK_VOL_ENV,
        HOLD_VOL_ENV,
        DECAY_VOL_ENV,
        SUSTAIN_VOL_ENV,
        RELEASE_VOL_ENV,
        KEYNUM_TO_VOL_ENV_HOLD,
        KEYNUM_TO_VOL_ENV_DECAY, //40
        INSTRUMENT,
        RESERVED1,
        KEY_RANGE,
        VEL_RANGE,
        STARTLOOP_ADDRS_COARSE_OFFSET,
        KEYNUM,
        VELOCITY,
        INITIAL_ATTENUATION,
        RESERVED2,
        ENDLOOP_ADDRS_COARSE_OFFSET, // 50
        COARSE_TUNE,
        FINE_TUNE,
        SAMPLE_ID,
        SAMPLE_MODES,
        RESERVED3,
        SCALE_TUNING,
        EXCLUSIVE_CLASS,
        OVERRIDING_ROOT_KEY,
        UNUSED5,
        END_OPER
    } SFGeneratorType;

    class Modulator {
        public:

            /**
             * General Controller palette of controllers.
             * Controller sources.
             */
            enum {
                NO_CONTROLLER = 0,
                NOTE_ON_VELOCITY = 2,
                NOTE_ON_KEY_NUMBER = 3,
                POLY_PRESSURE = 10,
                CHANNEL_PRESSURE = 13,
                PITCH_WHEEL = 14,
                PITCH_WHEEL_SENSITIVITY = 16,
                LINK = 127
            };

            /**
             * Controller type
             */
            enum {
                LINEAR = 0,
                CONCAVE,
                CONVEX,
                SWITCH
            };

            int  Type;
            bool MidiPalete;
            bool Direction;
            bool Polarity;
            int  Index;

            Modulator(SFModulator mod);
    };

    class ModulatorItem {
        public:
            Modulator    ModSrcOper;
            SFGenerator  ModDestOper;
            uint16_t     ModAmount;
            Modulator    ModAmtSrcOper;
            SFTransform  ModTransOper;

            ModulatorItem(ModList& mod);
    };


    typedef std::string String;

    class Exception : public RIFF::Exception {
        public: Exception(String Message) : RIFF::Exception(Message) { }
    };

    class Version {
        public:
            int Major;
            int Minor;

            Version(RIFF::Chunk* ck);
    };

    class Info {
        public:
            Version*  pVer;          ///< <ifil-ck>   ; Refers to the version of the Sound Font RIFF file
            String    SoundEngine;   ///< <isng-ck>   ; Refers to the target Sound Engine
            String    BankName;      ///< <INAM-ck>   ; Refers to the Sound Font Bank Name
            String    RomName;       ///< [<irom-ck>] ; Refers to the Sound ROM Name
            Version*  pRomVer;       ///< [<iver-ck>] ; Refers to the Sound ROM Version
            String    CreationDate;  ///< [<ICRD-ck>] ; Refers to the Date of Creation of the Bank
            String    Engineers;     ///< [<IENG-ck>] ; Sound Designers and Engineers for the Bank
            String    Product;       ///< [<IPRD-ck>] ; Product for which the Bank was intended
            String    Copyright;     ///< [<ICOP-ck>] ; Contains any Copyright message
            String    Comments;      ///< [<ICMT-ck>] ; Contains any Comments on the Bank
            String    Software;      ///< [<ISFT-ck>] ; The SoundFont tools used to create and alter the bank

            Info(RIFF::List* list);
            ~Info();
        private:
            static void LoadString(uint32_t ChunkID, RIFF::List* lstINFO, String& s);
    };

    class Sample {
        public:

            typedef enum {
                MONO_SAMPLE       = 1,
                RIGHT_SAMPLE      = 2,
                LEFT_SAMPLE       = 4,
                LINKED_SAMPLE     = 8,
                ROM_MONO_SAMPLE   = 0x8001,
                ROM_RIGHT_SAMPLE  = 0x8002,
                ROM_LEFT_SAMPLE   = 0x8004,
                ROM_LINKED_SAMPLE = 0x8008
            } Link;

            /** Reflects the current playback state for a sample. */
            class PlaybackState {
                public:
                    unsigned long position;          ///< Current position within the sample.
                    bool          reverse;           ///< If playback direction is currently backwards (in case there is a pingpong or reverse loop defined).
                    unsigned long loop_cycles_left;  ///< How many times the loop has still to be passed, this value will be decremented with each loop cycle.
            };

            /** Pointer address and size of a buffer. */
            struct buffer_t {
                void*         pStart;            ///< Points to the beginning of the buffer.
                unsigned long Size;              ///< Size of the actual data in the buffer in bytes.
                unsigned long NullExtensionSize; ///< The buffer might be bigger than the actual data, if that's the case that unused space at the end of the buffer is filled with NULLs and NullExtensionSize reflects that unused buffer space in bytes. Those NULL extensions are mandatory for differential algorithms that have to take the following data words into account, thus have to access past the buffer's boundary. If you don't know what I'm talking about, just forget this variable. :)
                buffer_t() {
                    pStart            = NULL;
                    Size              = 0;
                    NullExtensionSize = 0;
                }
            };

            String Name;

            Sample(RIFF::Chunk* ck, RIFF::Chunk* pCkSmpl, RIFF::Chunk* pCkSm24);

            String  GetName() { return Name; }
            int     GetChannelCount();
            long    GetTotalFrameCount();
            int     GetFrameSize();

            buffer_t  LoadSampleData();
            buffer_t  LoadSampleData(unsigned long SampleCount);
            buffer_t  LoadSampleDataWithNullSamplesExtension(uint NullSamplesCount);
            buffer_t  LoadSampleDataWithNullSamplesExtension(unsigned long SampleCount, uint NullSamplesCount);
            buffer_t  GetCache();
            void      ReleaseSampleData();
            unsigned long SetPos(unsigned long SampleCount);
            unsigned long GetPos();
            unsigned long Read(void* pBuffer, unsigned long SampleCount);

            unsigned long ReadAndLoop (
                void*           pBuffer,
                unsigned long   FrameCount,
                PlaybackState*  pPlaybackState
            );

        //protected:
            buffer_t      RAMCache;   ///< Buffers samples (already uncompressed) in RAM.
            RIFF::Chunk*  pCkSmpl;
            RIFF::Chunk*  pCkSm24;

        //private:
            int ChannelCount; // 2 for left and right samples

            uint32_t Start;     // in sample data points (frames)
            uint32_t End;       // in sample data points (frames)
            uint32_t StartLoop; // in sample data points (frames)
            uint32_t EndLoop;   // in sample data points (frames)
            uint32_t SampleRate;
            uint8_t  OriginalPitch;
            uint8_t  PitchCorrection;
            uint16_t SampleLink; /* If sfSampleType indicates a left or right sample, the
                                  * sample header index of the associated right or left stereo
                                  * sample respectively; zero otherwise. */
            uint16_t SampleType;
    };

    class File;
    class Instrument;

    /**
     * Instrument zone
     */
    class Region {
        public:
            int loKey, hiKey;
            int minVel, maxVel;
            int pan; // -64 - +63
            int fineTune; // -99 - +99
            int startAddrsOffset, startAddrsCoarseOffset, endAddrsOffset;
            int startloopAddrsOffset, endloopAddrsOffset;

            double EG1PreAttack;
            double EG1Attack;
            double EG1Hold;
            double EG1Decay;
            double EG1Sustain;
            double EG1Release;

            Sample* pSample;
            Instrument* pInstrument; // used when the region belongs to preset

            Region();
            Sample* GetSample() { return pSample; }
            Region* GetParent() { return this; }

            std::vector<ModulatorItem> modulators;

            friend class Instrument;
            friend class Preset;

        private:
            void SetGenerator(sf2::File* pFile, GenList& Gen);
            void SetModulator(sf2::File* pFile, ModList& Mod);
    };

    class InstrumentBase {
        public:
            String   Name;
            Region*  pGlobalRegion;

            InstrumentBase(sf2::File* pFile);
            virtual ~InstrumentBase();

            sf2::File* GetFile() { return pFile; }
            String     GetName() { return Name; }
            
            int      GetRegionCount();
            Region*  GetRegion(int idx);

            std::vector<Region*> GetRegionsOnKey(int key, uint8_t vel);

        protected:
            std::vector<Region*> regions;
            sf2::File* pFile;
    };

    class Instrument : public InstrumentBase {
        public:
            Instrument(sf2::File* pFile, RIFF::Chunk* ck);
            ~Instrument();
        //private:
            uint16_t InstBagNdx;
            
            /**
             * Load all regions (zones, bags) in the range idx1 - idx2
             */
            void LoadRegions(int idx1, int idx2);
    };

    class Preset : public InstrumentBase {
        public:
            uint16_t  PresetNum;
            uint16_t  Bank;
            uint32_t  Library;
            uint32_t  Genre;
            uint32_t  Morphology;

            Preset(sf2::File* pFile, RIFF::Chunk* ck);
            ~Preset();

        //private:
            sf2::File*  pFile;
            uint16_t    PresetBagNdx;

            /**
             * Load all regions (zones, bags) in the range idx1 - idx2
             */
            void LoadRegions(int idx1, int idx2);
    };

    class File {
        public:
            Info* pInfo;

            File(RIFF::File* pRIFF);
            ~File();

            int          GetPresetCount();
            Preset*      GetPreset(int idx);
            int          GetInstrumentCount();
            Instrument*  GetInstrument(int idx);
            int          GetSampleCount();
            Sample*      GetSample(int idx);
            void         DeleteSample(Sample* pSample);
            bool         HasSamples();

            friend class Region;
            friend class Instrument;
            friend class Preset;

        protected:
            RIFF::File*             pRIFF;
            std::vector<PresetBag>  PresetBags;
            std::vector<ModList>    PresetModLists;
            std::vector<GenList>    PresetGenLists;
            std::vector<InstBag>    InstBags;
            std::vector<ModList>    InstModLists;
            std::vector<GenList>    InstGenLists;

        private:
            std::vector<Preset*> Presets;
            std::vector<Instrument*> Instruments;
            std::vector<Sample*> Samples;
    };

    String libraryName();
    String libraryVersion();

} // namespace sf2
#endif // __SF2_SF_H__
1	iliev	2008	/***************************************************************************
2			* *
3			* libsf2 - C++ cross-platform SF2 format file access library *
4			* *
5			* Copyright (C) 2009 by Grigor Iliev <grigor@grigoriliev.com> *
6			* *
7			* This library is free software; you can redistribute it and/or modify *
8			* it under the terms of the GNU General Public License as published by *
9			* the Free Software Foundation; either version 2 of the License, or *
10			* (at your option) any later version. *
11			* *
12			* This library is distributed in the hope that it will be useful, *
13			* but WITHOUT ANY WARRANTY; without even the implied warranty of *
14			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
15			* GNU General Public License for more details. *
16			* *
17			* You should have received a copy of the GNU General Public License *
18			* along with this library; if not, write to the Free Software *
19			* Foundation, Inc., 59 Temple Place, Suite 330, Boston, *
20			* MA 02111-1307 USA *
21			***************************************************************************/
22
23			#ifndef __SF2_SF_H__
24			#define __SF2_SF_H__
25
26			#include "RIFF.h"
27
28			#include <vector>
29
30
31			#if WORDS_BIGENDIAN
32			#define ENDIAN_SWAP(x) \
33			( (x>>24) \| ((x<<8) & 0x00FF0000) \| ((x>>8) & 0x0000FF00) \| (x<<24) )
34			#else
35			#define ENDIAN_SWAP(x) (x)
36			#endif
37
38			#define RIFF_ID(x) ENDIAN_SWAP( (((uint32_t) x)) )
39
40
41			#define RIFF_TYPE_SF2 RIFF_ID("sfbk")
42
43			// Level 0
44			#define LIST_TYPE_INFO RIFF_ID("INFO")
45			#define LIST_TYPE_SDTA RIFF_ID("sdta")
46			#define LIST_TYPE_PDTA RIFF_ID("pdta")
47
48			// Level 1
49			//<INFO-list>
50			#define CHUNK_ID_IFIL RIFF_ID("ifil")
51			#define CHUNK_ID_ISNG RIFF_ID("isng")
52			#define CHUNK_ID_INAM RIFF_ID("INAM")
53			#define CHUNK_ID_IROM RIFF_ID("irom")
54			#define CHUNK_ID_IVER RIFF_ID("iver")
55			#define CHUNK_ID_ICRD RIFF_ID("ICRD")
56			#define CHUNK_ID_IENG RIFF_ID("IENG")
57			#define CHUNK_ID_IPRD RIFF_ID("IPRD")
58			#define CHUNK_ID_ICOP RIFF_ID("ICOP")
59			#define CHUNK_ID_ICMT RIFF_ID("ICMT")
60			#define CHUNK_ID_ISFT RIFF_ID("ISFT")
61
62			//<sdta-list>
63			#define CHUNK_ID_SMPL RIFF_ID("smpl")
64			#define CHUNK_ID_SM24 RIFF_ID("sm24")
65
66			//<pdta-list>
67			#define CHUNK_ID_PHDR RIFF_ID("phdr")
68			#define CHUNK_ID_PBAG RIFF_ID("pbag")
69			#define CHUNK_ID_PMOD RIFF_ID("pmod")
70			#define CHUNK_ID_PGEN RIFF_ID("pgen")
71			#define CHUNK_ID_INST RIFF_ID("inst")
72			#define CHUNK_ID_IBAG RIFF_ID("ibag")
73			#define CHUNK_ID_IMOD RIFF_ID("imod")
74			#define CHUNK_ID_IGEN RIFF_ID("igen")
75			#define CHUNK_ID_SHDR RIFF_ID("shdr")
76
77			#define NONE 0x1ffffff
78
79			namespace sf2 {
80			typedef struct _PresetBag {
81			uint16_t GenNdx;
82			uint16_t ModNdx;
83			} PresetBag;
84
85			typedef uint16_t SFModulator;
86			typedef uint16_t SFGenerator;
87			typedef uint16_t SFTransform;
88
89			typedef struct _ModList {
90			SFModulator ModSrcOper;
91			SFGenerator ModDestOper;
92			uint16_t ModAmount;
93			SFModulator ModAmtSrcOper;
94			SFTransform ModTransOper;
95			} ModList;
96
97			typedef struct _RangesType {
98			uint8_t byLo;
99			uint8_t byHi;
100			} RangesType;
101
102			typedef union _GenAmountType {
103			RangesType ranges;
104			short shAmount;
105			uint16_t wAmount;
106			} GenAmountType;
107
108			typedef struct _GenList {
109			SFGenerator GenOper;
110			GenAmountType GenAmount;
111			} GenList;
112
113			typedef struct _InstBag {
114			uint16_t InstGenNdx;
115			uint16_t InstModNdx;
116			} InstBag;
117
118			typedef enum {
119			START_ADDRS_OFFSET = 0,
120			END_ADDRS_OFFSET,
121			STARTLOOP_ADDRS_OFFSET,
122			ENDLOOP_ADDRS_OFFSET ,
123			START_ADDRS_COARSE_OFFSET,
124			MOD_LFO_TO_PITCH,
125			VIB_LFO_TO_PITCH,
126			MOD_ENV_TO_PITCH,
127			INITIAL_FILTER_FC,
128			INITIAL_FILTER_Q,
129			MOD_LFO_TO_FILTER_FC, // 10
130			MOD_ENV_TO_FILTER_FC,
131			END_ADDRS_COARSE_OFFSET,
132			MOD_LFO_TO_VOLUME,
133			UNUSED1,
134			CHORUS_EFFECTS_SEND,
135			REVERB_EFFECTS_SEND,
136			PAN,
137			UNUSED2,
138			UNUSED3,
139			UNUSED4, //20
140			DELAY_MOD_LFO,
141			FREQ_MOD_LFO,
142			DELAY_VIB_LFO,
143			FREQ_VIB_LFO,
144			DELAY_MOD_ENV,
145			ATTACK_MOD_ENV,
146			HOLD_MOD_ENV,
147			DECAY_MOD_ENV,
148			SUSTAIN_MOD_ENV,
149			RELEASEMODENV, // 30
150			KEYNUM_TO_MOD_ENV_HOLD,
151			KEYNUM_TO_MOD_ENV_DECAY,
152			DELAY_VOL_ENV,
153			ATTACK_VOL_ENV,
154			HOLD_VOL_ENV,
155			DECAY_VOL_ENV,
156			SUSTAIN_VOL_ENV,
157			RELEASE_VOL_ENV,
158			KEYNUM_TO_VOL_ENV_HOLD,
159			KEYNUM_TO_VOL_ENV_DECAY, //40
160			INSTRUMENT,
161			RESERVED1,
162			KEY_RANGE,
163			VEL_RANGE,
164			STARTLOOP_ADDRS_COARSE_OFFSET,
165			KEYNUM,
166			VELOCITY,
167			INITIAL_ATTENUATION,
168			RESERVED2,
169			ENDLOOP_ADDRS_COARSE_OFFSET, // 50
170			COARSE_TUNE,
171			FINE_TUNE,
172			SAMPLE_ID,
173			SAMPLE_MODES,
174			RESERVED3,
175			SCALE_TUNING,
176			EXCLUSIVE_CLASS,
177			OVERRIDING_ROOT_KEY,
178			UNUSED5,
179			END_OPER
180			} SFGeneratorType;
181
182			class Modulator {
183			public:
184
185			/**
186			* General Controller palette of controllers.
187			* Controller sources.
188			*/
189			enum {
190			NO_CONTROLLER = 0,
191			NOTE_ON_VELOCITY = 2,
192			NOTE_ON_KEY_NUMBER = 3,
193			POLY_PRESSURE = 10,
194			CHANNEL_PRESSURE = 13,
195			PITCH_WHEEL = 14,
196			PITCH_WHEEL_SENSITIVITY = 16,
197			LINK = 127
198			};
199
200			/**
201			* Controller type
202			*/
203			enum {
204			LINEAR = 0,
205			CONCAVE,
206			CONVEX,
207			SWITCH
208			};
209
210			int Type;
211			bool MidiPalete;
212			bool Direction;
213			bool Polarity;
214			int Index;
215
216			Modulator(SFModulator mod);
217			};
218
219			class ModulatorItem {
220			public:
221			Modulator ModSrcOper;
222			SFGenerator ModDestOper;
223			uint16_t ModAmount;
224			Modulator ModAmtSrcOper;
225			SFTransform ModTransOper;
226
227			ModulatorItem(ModList& mod);
228			};
229
230
231			typedef std::string String;
232
233			class Exception : public RIFF::Exception {
234			public: Exception(String Message) : RIFF::Exception(Message) { }
235			};
236
237			class Version {
238			public:
239			int Major;
240			int Minor;
241
242			Version(RIFF::Chunk* ck);
243			};
244
245			class Info {
246			public:
247			Version* pVer; ///< <ifil-ck> ; Refers to the version of the Sound Font RIFF file
248			String SoundEngine; ///< <isng-ck> ; Refers to the target Sound Engine
249			String BankName; ///< <INAM-ck> ; Refers to the Sound Font Bank Name
250			String RomName; ///< [<irom-ck>] ; Refers to the Sound ROM Name
251			Version* pRomVer; ///< [<iver-ck>] ; Refers to the Sound ROM Version
252			String CreationDate; ///< [<ICRD-ck>] ; Refers to the Date of Creation of the Bank
253			String Engineers; ///< [<IENG-ck>] ; Sound Designers and Engineers for the Bank
254			String Product; ///< [<IPRD-ck>] ; Product for which the Bank was intended
255			String Copyright; ///< [<ICOP-ck>] ; Contains any Copyright message
256			String Comments; ///< [<ICMT-ck>] ; Contains any Comments on the Bank
257			String Software; ///< [<ISFT-ck>] ; The SoundFont tools used to create and alter the bank
258
259			Info(RIFF::List* list);
260			~Info();
261			private:
262			static void LoadString(uint32_t ChunkID, RIFF::List* lstINFO, String& s);
263			};
264
265			class Sample {
266			public:
267
268			typedef enum {
269			MONO_SAMPLE = 1,
270			RIGHT_SAMPLE = 2,
271			LEFT_SAMPLE = 4,
272			LINKED_SAMPLE = 8,
273			ROM_MONO_SAMPLE = 0x8001,
274			ROM_RIGHT_SAMPLE = 0x8002,
275			ROM_LEFT_SAMPLE = 0x8004,
276			ROM_LINKED_SAMPLE = 0x8008
277			} Link;
278
279			/** Reflects the current playback state for a sample. */
280			class PlaybackState {
281			public:
282			unsigned long position; ///< Current position within the sample.
283			bool reverse; ///< If playback direction is currently backwards (in case there is a pingpong or reverse loop defined).
284			unsigned long loop_cycles_left; ///< How many times the loop has still to be passed, this value will be decremented with each loop cycle.
285			};
286
287			/** Pointer address and size of a buffer. */
288			struct buffer_t {
289			void* pStart; ///< Points to the beginning of the buffer.
290			unsigned long Size; ///< Size of the actual data in the buffer in bytes.
291			unsigned long NullExtensionSize; ///< The buffer might be bigger than the actual data, if that's the case that unused space at the end of the buffer is filled with NULLs and NullExtensionSize reflects that unused buffer space in bytes. Those NULL extensions are mandatory for differential algorithms that have to take the following data words into account, thus have to access past the buffer's boundary. If you don't know what I'm talking about, just forget this variable. :)
292			buffer_t() {
293			pStart = NULL;
294			Size = 0;
295			NullExtensionSize = 0;
296			}
297			};
298
299			String Name;
300
301			Sample(RIFF::Chunk* ck, RIFF::Chunk* pCkSmpl, RIFF::Chunk* pCkSm24);
302
303			String GetName() { return Name; }
304			int GetChannelCount();
305			long GetTotalFrameCount();
306			int GetFrameSize();
307
308			buffer_t LoadSampleData();
309			buffer_t LoadSampleData(unsigned long SampleCount);
310			buffer_t LoadSampleDataWithNullSamplesExtension(uint NullSamplesCount);
311			buffer_t LoadSampleDataWithNullSamplesExtension(unsigned long SampleCount, uint NullSamplesCount);
312			buffer_t GetCache();
313			void ReleaseSampleData();
314			unsigned long SetPos(unsigned long SampleCount);
315			unsigned long GetPos();
316			unsigned long Read(void* pBuffer, unsigned long SampleCount);
317
318			unsigned long ReadAndLoop (
319			void* pBuffer,
320			unsigned long FrameCount,
321			PlaybackState* pPlaybackState
322			);
323
324			//protected:
325			buffer_t RAMCache; ///< Buffers samples (already uncompressed) in RAM.
326			RIFF::Chunk* pCkSmpl;
327			RIFF::Chunk* pCkSm24;
328
329			//private:
330			int ChannelCount; // 2 for left and right samples
331
332			uint32_t Start; // in sample data points (frames)
333			uint32_t End; // in sample data points (frames)
334			uint32_t StartLoop; // in sample data points (frames)
335			uint32_t EndLoop; // in sample data points (frames)
336			uint32_t SampleRate;
337			uint8_t OriginalPitch;
338			uint8_t PitchCorrection;
339			uint16_t SampleLink; /* If sfSampleType indicates a left or right sample, the
340			* sample header index of the associated right or left stereo
341			* sample respectively; zero otherwise. */
342			uint16_t SampleType;
343			};
344
345			class File;
346			class Instrument;
347
348			/**
349			* Instrument zone
350			*/
351			class Region {
352			public:
353			int loKey, hiKey;
354			int minVel, maxVel;
355			int pan; // -64 - +63
356			int fineTune; // -99 - +99
357			int startAddrsOffset, startAddrsCoarseOffset, endAddrsOffset;
358			int startloopAddrsOffset, endloopAddrsOffset;
359
360			double EG1PreAttack;
361			double EG1Attack;
362			double EG1Hold;
363			double EG1Decay;
364			double EG1Sustain;
365			double EG1Release;
366
367			Sample* pSample;
368			Instrument* pInstrument; // used when the region belongs to preset
369
370			Region();
371			Sample* GetSample() { return pSample; }
372			Region* GetParent() { return this; }
373
374			std::vector<ModulatorItem> modulators;
375
376			friend class Instrument;
377			friend class Preset;
378
379			private:
380			void SetGenerator(sf2::File* pFile, GenList& Gen);
381			void SetModulator(sf2::File* pFile, ModList& Mod);
382			};
383
384			class InstrumentBase {
385			public:
386			String Name;
387			Region* pGlobalRegion;
388
389			InstrumentBase(sf2::File* pFile);
390			virtual ~InstrumentBase();
391
392			sf2::File* GetFile() { return pFile; }
393			String GetName() { return Name; }
394
395			int GetRegionCount();
396			Region* GetRegion(int idx);
397
398			std::vector<Region*> GetRegionsOnKey(int key, uint8_t vel);
399
400			protected:
401			std::vector<Region*> regions;
402			sf2::File* pFile;
403			};
404
405			class Instrument : public InstrumentBase {
406			public:
407			Instrument(sf2::File* pFile, RIFF::Chunk* ck);
408			~Instrument();
409			//private:
410			uint16_t InstBagNdx;
411
412			/**
413			* Load all regions (zones, bags) in the range idx1 - idx2
414			*/
415			void LoadRegions(int idx1, int idx2);
416			};
417
418			class Preset : public InstrumentBase {
419			public:
420			uint16_t PresetNum;
421			uint16_t Bank;
422			uint32_t Library;
423			uint32_t Genre;
424			uint32_t Morphology;
425
426			Preset(sf2::File* pFile, RIFF::Chunk* ck);
427			~Preset();
428
429			//private:
430			sf2::File* pFile;
431			uint16_t PresetBagNdx;
432
433			/**
434			* Load all regions (zones, bags) in the range idx1 - idx2
435			*/
436			void LoadRegions(int idx1, int idx2);
437			};
438
439			class File {
440			public:
441			Info* pInfo;
442
443			File(RIFF::File* pRIFF);
444			~File();
445
446			int GetPresetCount();
447			Preset* GetPreset(int idx);
448			int GetInstrumentCount();
449			Instrument* GetInstrument(int idx);
450			int GetSampleCount();
451			Sample* GetSample(int idx);
452			void DeleteSample(Sample* pSample);
453			bool HasSamples();
454
455			friend class Region;
456			friend class Instrument;
457			friend class Preset;
458
459			protected:
460			RIFF::File* pRIFF;
461			std::vector<PresetBag> PresetBags;
462			std::vector<ModList> PresetModLists;
463			std::vector<GenList> PresetGenLists;
464			std::vector<InstBag> InstBags;
465			std::vector<ModList> InstModLists;
466			std::vector<GenList> InstGenLists;
467
468			private:
469			std::vector<Preset*> Presets;
470			std::vector<Instrument*> Instruments;
471			std::vector<Sample*> Samples;
472			};
473
474			String libraryName();
475			String libraryVersion();
476
477			} // namespace sf2
478			#endif // __SF2_SF_H__