/[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 437 by persson, Wed Mar 9 22:02:40 2005 UTC revision 929 by schoenebeck, Tue Oct 24 22:24:45 2006 UTC
# Line 2  Line 2 
2   *                                                                         *   *                                                                         *
3   *   libgig - C++ cross-platform Gigasampler format file loader library    *   *   libgig - C++ cross-platform Gigasampler format file loader library    *
4   *                                                                         *   *                                                                         *
5   *   Copyright (C) 2003-2005 by Christian Schoenebeck                      *   *   Copyright (C) 2003-2006 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 26  Line 26 
26    
27  #include "DLS.h"  #include "DLS.h"
28    
 #include <math.h>  
 #include <string.h>  
   
 /// Initial size of the sample buffer which is used for decompression of  
 /// compressed sample wave streams - this value should always be bigger than  
 /// the biggest sample piece expected to be read by the sampler engine,  
 /// otherwise the buffer size will be raised at runtime and thus the buffer  
 /// reallocated which is time consuming and unefficient.  
 #define INITIAL_SAMPLE_BUFFER_SIZE              512000 // 512 kB  
   
29  #if WORDS_BIGENDIAN  #if WORDS_BIGENDIAN
30  # define LIST_TYPE_3PRG 0x33707267  # define LIST_TYPE_3PRG 0x33707267
31  # define LIST_TYPE_3EWL 0x3365776C  # define LIST_TYPE_3EWL 0x3365776C
32    # define LIST_TYPE_3GRI 0x33677269
33    # define LIST_TYPE_3GNL 0x33676E6C
34  # define CHUNK_ID_SMPL  0x736D706C  # define CHUNK_ID_SMPL  0x736D706C
35  # define CHUNK_ID_3GIX  0x33676978  # define CHUNK_ID_3GIX  0x33676978
36  # define CHUNK_ID_3EWA  0x33657761  # define CHUNK_ID_3EWA  0x33657761
37  # define CHUNK_ID_3LNK  0x336C6E6B  # define CHUNK_ID_3LNK  0x336C6E6B
38  # define CHUNK_ID_3EWG  0x33657767  # define CHUNK_ID_3EWG  0x33657767
39  # define CHUNK_ID_EWAV  0x65776176  # define CHUNK_ID_EWAV  0x65776176
40    # define CHUNK_ID_3GNM  0x33676E6D
41  #else  // little endian  #else  // little endian
42  # define LIST_TYPE_3PRG 0x67727033  # define LIST_TYPE_3PRG 0x67727033
43  # define LIST_TYPE_3EWL 0x6C776533  # define LIST_TYPE_3EWL 0x6C776533
44    # define LIST_TYPE_3GRI 0x69726733
45    # define LIST_TYPE_3GNL 0x6C6E6733
46  # define CHUNK_ID_SMPL  0x6C706D73  # define CHUNK_ID_SMPL  0x6C706D73
47  # define CHUNK_ID_3GIX  0x78696733  # define CHUNK_ID_3GIX  0x78696733
48  # define CHUNK_ID_3EWA  0x61776533  # define CHUNK_ID_3EWA  0x61776533
49  # define CHUNK_ID_3LNK  0x6B6E6C33  # define CHUNK_ID_3LNK  0x6B6E6C33
50  # define CHUNK_ID_3EWG  0x67776533  # define CHUNK_ID_3EWG  0x67776533
51  # define CHUNK_ID_EWAV  0x76617765  # define CHUNK_ID_EWAV  0x76617765
52    # define CHUNK_ID_3GNM  0x6D6E6733
53  #endif // WORDS_BIGENDIAN  #endif // WORDS_BIGENDIAN
54    
 /** (so far) every exponential paramater in the gig format has a basis of 1.000000008813822 */  
 #define GIG_EXP_DECODE(x)                                       (pow(1.000000008813822, x))  
 #define GIG_PITCH_TRACK_EXTRACT(x)                              (!(x & 0x01))  
 #define GIG_VCF_RESONANCE_CTRL_EXTRACT(x)                       ((x >> 4) & 0x03)  
 #define GIG_EG_CTR_ATTACK_INFLUENCE_EXTRACT(x)                  ((x >> 1) & 0x03)  
 #define GIG_EG_CTR_DECAY_INFLUENCE_EXTRACT(x)                   ((x >> 3) & 0x03)  
 #define GIG_EG_CTR_RELEASE_INFLUENCE_EXTRACT(x)                 ((x >> 5) & 0x03)  
   
55  /** Gigasampler specific classes and definitions */  /** Gigasampler specific classes and definitions */
56  namespace gig {  namespace gig {
57    
# Line 148  namespace gig { Line 136  namespace gig {
136      /** Defines how the filter cutoff frequency is controlled by. */      /** Defines how the filter cutoff frequency is controlled by. */
137      typedef enum {      typedef enum {
138          vcf_cutoff_ctrl_none         = 0x00,          vcf_cutoff_ctrl_none         = 0x00,
139            vcf_cutoff_ctrl_none2        = 0x01,  ///< The difference between none and none2 is unknown
140          vcf_cutoff_ctrl_modwheel     = 0x81,  ///< Modulation Wheel (MIDI Controller 1)          vcf_cutoff_ctrl_modwheel     = 0x81,  ///< Modulation Wheel (MIDI Controller 1)
141          vcf_cutoff_ctrl_effect1      = 0x8c,  ///< Effect Controller 1 (Coarse, MIDI Controller 12)          vcf_cutoff_ctrl_effect1      = 0x8c,  ///< Effect Controller 1 (Coarse, MIDI Controller 12)
142          vcf_cutoff_ctrl_effect2      = 0x8d,  ///< Effect Controller 2 (Coarse, MIDI Controller 13)          vcf_cutoff_ctrl_effect2      = 0x8d,  ///< Effect Controller 2 (Coarse, MIDI Controller 13)
# Line 257  namespace gig { Line 246  namespace gig {
246       * into the corresponding dimension bit number.       * into the corresponding dimension bit number.
247       */       */
248      typedef enum {      typedef enum {
249          split_type_normal,         ///< dimension value between 0-127, no custom range of zones          split_type_normal,         ///< dimension value between 0-127
         split_type_customvelocity, ///< a velocity dimension split with custom range definition for each zone (if a velocity dimension split has no custom defined zone ranges then it's also just of type split_type_normal)  
250          split_type_bit             ///< dimension values are already the sought bit number          split_type_bit             ///< dimension values are already the sought bit number
251      } split_type_t;      } split_type_t;
252    
# Line 268  namespace gig { Line 256  namespace gig {
256          uint8_t      bits;       ///< Number of "bits" (1 bit = 2 splits/zones, 2 bit = 4 splits/zones, 3 bit = 8 splits/zones,...).          uint8_t      bits;       ///< Number of "bits" (1 bit = 2 splits/zones, 2 bit = 4 splits/zones, 3 bit = 8 splits/zones,...).
257          uint8_t      zones;      ///< Number of zones the dimension has.          uint8_t      zones;      ///< Number of zones the dimension has.
258          split_type_t split_type; ///< Intended for internal usage: will be used to convert a dimension value into the corresponding dimension bit number.          split_type_t split_type; ///< Intended for internal usage: will be used to convert a dimension value into the corresponding dimension bit number.
259          range_t*     ranges;     ///< Intended for internal usage: Points to the beginning of a range_t array which reflects the value ranges of each dimension zone (only if custom defined ranges are defined, is NULL otherwise).          float        zone_size;  ///< Intended for internal usage: reflects the size of each zone (128/zones) for normal split types only, 0 otherwise.
         unsigned int zone_size;  ///< Intended for internal usage: reflects the size of each zone (128/zones) for normal split types only, 0 otherwise.  
260      };      };
261    
262      /** Defines which frequencies are filtered by the VCF. */      /** Defines which frequencies are filtered by the VCF. */
# Line 309  namespace gig { Line 296  namespace gig {
296          unsigned long loop_cycles_left;  ///< How many times the loop has still to be passed, this value will be decremented with each loop cycle.          unsigned long loop_cycles_left;  ///< How many times the loop has still to be passed, this value will be decremented with each loop cycle.
297      };      };
298    
299        /**
300         * @brief Used for indicating the progress of a certain task.
301         *
302         * The function pointer argument has to be supplied with a valid
303         * function of the given signature which will then be called on
304         * progress changes. An equivalent progress_t structure will be passed
305         * back as argument to the callback function on each progress change.
306         * The factor field of the supplied progress_t structure will then
307         * reflect the current progress as value between 0.0 and 1.0. You might
308         * want to use the custom field for data needed in your callback
309         * function.
310         */
311        struct progress_t {
312            void (*callback)(progress_t*); ///< Callback function pointer which has to be assigned to a function for progress notification.
313            float factor;                  ///< Reflects current progress as value between 0.0 and 1.0.
314            void* custom;                  ///< This pointer can be used for arbitrary data.
315            float __range_min;             ///< Only for internal usage, do not modify!
316            float __range_max;             ///< Only for internal usage, do not modify!
317            progress_t();
318        };
319    
320      // just symbol prototyping      // just symbol prototyping
321      class File;      class File;
322      class Instrument;      class Instrument;
323      class Sample;      class Sample;
324      class Region;      class Region;
325        class Group;
326    
327      /** Encapsulates articulation information of a dimension region.      /** Encapsulates articulation information of a dimension region.
328       *       *
# Line 382  namespace gig { Line 391  namespace gig {
391              bool               VCFEnabled;                    ///< If filter should be used.              bool               VCFEnabled;                    ///< If filter should be used.
392              vcf_type_t         VCFType;                       ///< Defines the general filter characteristic (lowpass, highpass, bandpass, etc.).              vcf_type_t         VCFType;                       ///< Defines the general filter characteristic (lowpass, highpass, bandpass, etc.).
393              vcf_cutoff_ctrl_t  VCFCutoffController;           ///< Specifies which external controller has influence on the filter cutoff frequency.              vcf_cutoff_ctrl_t  VCFCutoffController;           ///< Specifies which external controller has influence on the filter cutoff frequency.
394                bool               VCFCutoffControllerInvert;     ///< Inverts values coming from the defined cutoff controller
395              uint8_t            VCFCutoff;                     ///< Max. cutoff frequency.              uint8_t            VCFCutoff;                     ///< Max. cutoff frequency.
396              curve_type_t       VCFVelocityCurve;              ///< Defines a transformation curve for the incoming velocity values, affecting the VCF.              curve_type_t       VCFVelocityCurve;              ///< Defines a transformation curve for the incoming velocity values, affecting the VCF.
397              uint8_t            VCFVelocityScale;              ///< (0-127) Amount velocity controls VCF cutoff frequency (only if no other VCF cutoff controller is defined).              uint8_t            VCFVelocityScale;              ///< (0-127) Amount velocity controls VCF cutoff frequency (only if no other VCF cutoff controller is defined, otherwise this is the minimum cutoff).
398              uint8_t            VCFVelocityDynamicRange;       ///< 0x04 = lowest, 0x00 = highest              uint8_t            VCFVelocityDynamicRange;       ///< 0x04 = lowest, 0x00 = highest
399              uint8_t            VCFResonance;                  ///< Firm internal filter resonance weight.              uint8_t            VCFResonance;                  ///< Firm internal filter resonance weight.
400              bool               VCFResonanceDynamic;           ///< If <i>true</i>: Increases the resonance Q according to changes of controllers that actually control the VCF cutoff frequency (EG2, ext. VCF MIDI controller).              bool               VCFResonanceDynamic;           ///< If <i>true</i>: Increases the resonance Q according to changes of controllers that actually control the VCF cutoff frequency (EG2, ext. VCF MIDI controller).
# Line 420  namespace gig { Line 430  namespace gig {
430              DLS::Sampler::SampleLoops;              DLS::Sampler::SampleLoops;
431              DLS::Sampler::pSampleLoops;              DLS::Sampler::pSampleLoops;
432    
433              // Methods              // own methods
434              double GetVelocityAttenuation(uint8_t MIDIKeyVelocity);              double GetVelocityAttenuation(uint8_t MIDIKeyVelocity);
435                double GetVelocityRelease(uint8_t MIDIKeyVelocity);
436                double GetVelocityCutoff(uint8_t MIDIKeyVelocity);
437                // overridden methods
438                virtual void UpdateChunks();
439          protected:          protected:
440                uint8_t* VelocityTable; ///< For velocity dimensions with custom defined zone ranges only: used for fast converting from velocity MIDI value to dimension bit number.
441              DimensionRegion(RIFF::List* _3ewl);              DimensionRegion(RIFF::List* _3ewl);
442             ~DimensionRegion();             ~DimensionRegion();
443              friend class Region;              friend class Region;
# Line 460  namespace gig { Line 475  namespace gig {
475              static uint              Instances;                  ///< Number of DimensionRegion instances.              static uint              Instances;                  ///< Number of DimensionRegion instances.
476              static VelocityTableMap* pVelocityTables;            ///< Contains the tables corresponding to the various velocity parameters (VelocityResponseCurve and VelocityResponseDepth).              static VelocityTableMap* pVelocityTables;            ///< Contains the tables corresponding to the various velocity parameters (VelocityResponseCurve and VelocityResponseDepth).
477              double*                  pVelocityAttenuationTable;  ///< Points to the velocity table corresponding to the velocity parameters of this DimensionRegion.              double*                  pVelocityAttenuationTable;  ///< Points to the velocity table corresponding to the velocity parameters of this DimensionRegion.
478                double*                  pVelocityReleaseTable;      ///< Points to the velocity table corresponding to the release velocity parameters of this DimensionRegion
479                double*                  pVelocityCutoffTable;       ///< Points to the velocity table corresponding to the filter velocity parameters of this DimensionRegion
480    
481              leverage_ctrl_t DecodeLeverageController(_lev_ctrl_t EncodedController);              leverage_ctrl_t DecodeLeverageController(_lev_ctrl_t EncodedController);
482                _lev_ctrl_t     EncodeLeverageController(leverage_ctrl_t DecodedController);
483                double* GetVelocityTable(curve_type_t curveType, uint8_t depth, uint8_t scaling);
484              double* CreateVelocityTable(curve_type_t curveType, uint8_t depth, uint8_t scaling);              double* CreateVelocityTable(curve_type_t curveType, uint8_t depth, uint8_t scaling);
485      };      };
486    
487      /** Encapsulates sample waves used for playback. */      /** @brief Encapsulates sample waves used for playback.
488         *
489         * In case you created a new sample with File::AddSample(), you should
490         * first update all attributes with the desired meta informations
491         * (amount of channels, bit depth, sample rate, etc.), then call
492         * Resize() with the desired sample size, followed by File::Save(), this
493         * will create the mandatory RIFF chunk which will hold the sample wave
494         * data and / or resize the file so you will be able to Write() the
495         * sample data directly to disk.
496         */
497      class Sample : public DLS::Sample {      class Sample : public DLS::Sample {
498          public:          public:
499              uint16_t       SampleGroup;              Group*         pGroup;            ///< pointer to the Group this sample belongs to, NULL otherwise
500              uint32_t       Manufacturer;      ///< Specifies the MIDI Manufacturer's Association (MMA) Manufacturer code for the sampler intended to receive this file's waveform. If no particular manufacturer is to be specified, a value of 0 should be used.              uint32_t       Manufacturer;      ///< Specifies the MIDI Manufacturer's Association (MMA) Manufacturer code for the sampler intended to receive this file's waveform. If no particular manufacturer is to be specified, a value of 0 should be used.
501              uint32_t       Product;           ///< Specifies the MIDI model ID defined by the manufacturer corresponding to the Manufacturer field. If no particular manufacturer's product is to be specified, a value of 0 should be used.              uint32_t       Product;           ///< Specifies the MIDI model ID defined by the manufacturer corresponding to the Manufacturer field. If no particular manufacturer's product is to be specified, a value of 0 should be used.
502              uint32_t       SamplePeriod;      ///< Specifies the duration of time that passes during the playback of one sample in nanoseconds (normally equal to 1 / Samplers Per Second, where Samples Per Second is the value found in the format chunk).              uint32_t       SamplePeriod;      ///< Specifies the duration of time that passes during the playback of one sample in nanoseconds (normally equal to 1 / Samples Per Second, where Samples Per Second is the value found in the format chunk), don't bother to update this attribute, it won't be saved.
503              uint32_t       MIDIUnityNote;     ///< Specifies the musical note at which the sample will be played at it's original sample rate.              uint32_t       MIDIUnityNote;     ///< Specifies the musical note at which the sample will be played at it's original sample rate.
504              uint32_t       FineTune;          ///< Specifies the fraction of a semitone up from the specified MIDI unity note field. A value of 0x80000000 means 1/2 semitone (50 cents) and a value of 0x00000000 means no fine tuning between semitones.              uint32_t       FineTune;          ///< Specifies the fraction of a semitone up from the specified MIDI unity note field. A value of 0x80000000 means 1/2 semitone (50 cents) and a value of 0x00000000 means no fine tuning between semitones.
505              smpte_format_t SMPTEFormat;       ///< Specifies the Society of Motion Pictures and Television E time format used in the following <i>SMPTEOffset</i> field. If a value of 0 is set, <i>SMPTEOffset</i> should also be set to 0.              smpte_format_t SMPTEFormat;       ///< Specifies the Society of Motion Pictures and Television E time format used in the following <i>SMPTEOffset</i> field. If a value of 0 is set, <i>SMPTEOffset</i> should also be set to 0.
# Line 499  namespace gig { Line 527  namespace gig {
527              static void     DestroyDecompressionBuffer(buffer_t& DecompressionBuffer);              static void     DestroyDecompressionBuffer(buffer_t& DecompressionBuffer);
528              // overridden methods              // overridden methods
529              void          ReleaseSampleData();              void          ReleaseSampleData();
530                void          Resize(int iNewSize);
531              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);
532              unsigned long GetPos();              unsigned long GetPos();
533              unsigned long Read(void* pBuffer, unsigned long SampleCount, buffer_t* pExternalDecompressionBuffer = NULL);              unsigned long Read(void* pBuffer, unsigned long SampleCount, buffer_t* pExternalDecompressionBuffer = NULL);
534              unsigned long ReadAndLoop(void* pBuffer, unsigned long SampleCount, playback_state_t* pPlaybackState, buffer_t* pExternalDecompressionBuffer = NULL);              unsigned long ReadAndLoop(void* pBuffer, unsigned long SampleCount, playback_state_t* pPlaybackState, DimensionRegion* pDimRgn, buffer_t* pExternalDecompressionBuffer = NULL);
535                unsigned long Write(void* pBuffer, unsigned long SampleCount);
536                virtual void  UpdateChunks();
537          protected:          protected:
538              static unsigned int  Instances;               ///< Number of instances of class Sample.              static unsigned int  Instances;               ///< Number of instances of class Sample.
539              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 513  namespace gig { Line 544  namespace gig {
544              unsigned long        WorstCaseFrameSize;      ///< For compressed samples only: size (in bytes) of the largest possible sample frame.              unsigned long        WorstCaseFrameSize;      ///< For compressed samples only: size (in bytes) of the largest possible sample frame.
545              unsigned long        SamplesPerFrame;         ///< For compressed samples only: number of samples in a full sample frame.              unsigned long        SamplesPerFrame;         ///< For compressed samples only: number of samples in a full sample frame.
546              buffer_t             RAMCache;                ///< Buffers samples (already uncompressed) in RAM.              buffer_t             RAMCache;                ///< Buffers samples (already uncompressed) in RAM.
547                unsigned long        FileNo;                  ///< File number (> 0 when sample is stored in an extension file, 0 when it's in the gig)
548                RIFF::Chunk*         pCk3gix;
549                RIFF::Chunk*         pCkSmpl;
550    
551              Sample(File* pFile, RIFF::List* waveList, unsigned long WavePoolOffset);              Sample(File* pFile, RIFF::List* waveList, unsigned long WavePoolOffset, unsigned long fileNo = 0);
552             ~Sample();             ~Sample();
             /**  
              * Swaps the order of the data words in the given memory area  
              * with a granularity given by \a WordSize.  
              *  
              * @param pData    - pointer to the memory area to be swapped  
              * @param AreaSize - size of the memory area to be swapped (in bytes)  
              * @param WordSize - size of the data words (in bytes)  
              */  
             inline void SwapMemoryArea(void* pData, unsigned long AreaSize, uint WordSize) {  
                 switch (WordSize) { // TODO: unefficient  
                     case 1: {  
                         uint8_t* pDst = (uint8_t*) pData;  
                         uint8_t  cache;  
                         unsigned long lo = 0, hi = AreaSize - 1;  
                         for (; lo < hi; hi--, lo++) {  
                             cache    = pDst[lo];  
                             pDst[lo] = pDst[hi];  
                             pDst[hi] = cache;  
                         }  
                         break;  
                     }  
                     case 2: {  
                         uint16_t* pDst = (uint16_t*) pData;  
                         uint16_t  cache;  
                         unsigned long lo = 0, hi = (AreaSize >> 1) - 1;  
                         for (; lo < hi; hi--, lo++) {  
                             cache    = pDst[lo];  
                             pDst[lo] = pDst[hi];  
                             pDst[hi] = cache;  
                         }  
                         break;  
                     }  
                     case 4: {  
                         uint32_t* pDst = (uint32_t*) pData;  
                         uint32_t  cache;  
                         unsigned long lo = 0, hi = (AreaSize >> 2) - 1;  
                         for (; lo < hi; hi--, lo++) {  
                             cache    = pDst[lo];  
                             pDst[lo] = pDst[hi];  
                             pDst[hi] = cache;  
                         }  
                         break;  
                     }  
                     default: {  
                         uint8_t* pCache = new uint8_t[WordSize]; // TODO: unefficient  
                         unsigned long lo = 0, hi = AreaSize - WordSize;  
                         for (; lo < hi; hi -= WordSize, lo += WordSize) {  
                             memcpy(pCache, (uint8_t*) pData + lo, WordSize);  
                             memcpy((uint8_t*) pData + lo, (uint8_t*) pData + hi, WordSize);  
                             memcpy((uint8_t*) pData + hi, pCache, WordSize);  
                         }  
                         delete[] pCache;  
                         break;  
                     }  
                 }  
             }  
             inline long Min(long A, long B) {  
                 return (A > B) ? B : A;  
             }  
             inline long Abs(long val) { return (val > 0) ? val : -val; }  
553    
554              // Guess size (in bytes) of a compressed sample              // Guess size (in bytes) of a compressed sample
555              inline unsigned long GuessSize(unsigned long samples) {              inline unsigned long GuessSize(unsigned long samples) {
# Line 608  namespace gig { Line 582  namespace gig {
582      /** Defines <i>Region</i> information of an <i>Instrument</i>. */      /** Defines <i>Region</i> information of an <i>Instrument</i>. */
583      class Region : public DLS::Region {      class Region : public DLS::Region {
584          public:          public:
585              unsigned int            Dimensions;               ///< Number of defined dimensions.              unsigned int            Dimensions;               ///< Number of defined dimensions, do not alter!
586              dimension_def_t         pDimensionDefinitions[8]; ///< Defines the five (gig2) or eight (gig3) possible dimensions (the dimension's controller and number of bits/splits).              dimension_def_t         pDimensionDefinitions[8]; ///< Defines the five (gig2) or eight (gig3) possible dimensions (the dimension's controller and number of bits/splits). Use AddDimension() and DeleteDimension() to create a new dimension or delete an existing one.
587              uint32_t                DimensionRegions;         ///< Total number of DimensionRegions this Region contains.              uint32_t                DimensionRegions;         ///< Total number of DimensionRegions this Region contains, do not alter!
588              DimensionRegion*        pDimensionRegions[256];   ///< Pointer array to the 32 (gig2) or 256 (gig3) possible dimension regions (reflects NULL for dimension regions not in use). Avoid to access the array directly and better use GetDimensionRegionByValue() instead, but of course in some cases it makes sense to use the array (e.g. iterating through all DimensionRegions).              DimensionRegion*        pDimensionRegions[256];   ///< Pointer array to the 32 (gig2) or 256 (gig3) possible dimension regions (reflects NULL for dimension regions not in use). Avoid to access the array directly and better use GetDimensionRegionByValue() instead, but of course in some cases it makes sense to use the array (e.g. iterating through all DimensionRegions). Use AddDimension() and DeleteDimension() to create a new dimension or delete an existing one (which will create or delete the respective dimension region(s) automatically).
589              unsigned int            Layers;                   ///< Amount of defined layers (1 - 32). A value of 1 actually means no layering, a value > 1 means there is Layer dimension. The same information can of course also be obtained by accessing pDimensionDefinitions.              unsigned int            Layers;                   ///< Amount of defined layers (1 - 32). A value of 1 actually means no layering, a value > 1 means there is Layer dimension. The same information can of course also be obtained by accessing pDimensionDefinitions. Do not alter this value!
590    
591              DimensionRegion* GetDimensionRegionByValue(const uint DimValues[8]);              DimensionRegion* GetDimensionRegionByValue(const uint DimValues[8]);
592              DimensionRegion* GetDimensionRegionByBit(const uint8_t DimBits[8]);              DimensionRegion* GetDimensionRegionByBit(const uint8_t DimBits[8]);
593              Sample*          GetSample();              Sample*          GetSample();
594                void             AddDimension(dimension_def_t* pDimDef);
595                void             DeleteDimension(dimension_def_t* pDimDef);
596                virtual void     UpdateChunks();
597          protected:          protected:
             uint8_t VelocityTable[128]; ///< For velocity dimensions with custom defined zone ranges only: used for fast converting from velocity MIDI value to dimension bit number.  
   
598              Region(Instrument* pInstrument, RIFF::List* rgnList);              Region(Instrument* pInstrument, RIFF::List* rgnList);
599              void LoadDimensionRegions(RIFF::List* rgn);              void LoadDimensionRegions(RIFF::List* rgn);
600              Sample* GetSampleFromWavePool(unsigned int WavePoolTableIndex);              void UpdateVelocityTable();
601                Sample* GetSampleFromWavePool(unsigned int WavePoolTableIndex, progress_t* pProgress = NULL);
602             ~Region();             ~Region();
603              friend class Instrument;              friend class Instrument;
604      };      };
# Line 654  namespace gig { Line 630  namespace gig {
630              // overridden methods              // overridden methods
631              Region*   GetFirstRegion();              Region*   GetFirstRegion();
632              Region*   GetNextRegion();              Region*   GetNextRegion();
633                Region*   AddRegion();
634                void      DeleteRegion(Region* pRegion);
635                virtual void UpdateChunks();
636              // own methods              // own methods
637              Region*   GetRegion(unsigned int Key);              Region*   GetRegion(unsigned int Key);
638          protected:          protected:
             Region**  pRegions;            ///< Pointer array to the regions  
639              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
             int       RegionIndex;  
640    
641              Instrument(File* pFile, RIFF::List* insList);              Instrument(File* pFile, RIFF::List* insList, progress_t* pProgress = NULL);
642             ~Instrument();             ~Instrument();
643                void UpdateRegionKeyTable();
644                friend class File;
645        };
646    
647        /** @brief Group of Gigasampler objects
648         *
649         * Groups help to organize a huge collection of Gigasampler objects.
650         * Groups are not concerned at all for the synthesis, but they help
651         * sound library developers when working on complex instruments with an
652         * instrument editor (as long as that instrument editor supports it ;-).
653         *
654         * At the moment, it seems as only samples can be grouped together in
655         * the Gigasampler format yet. If this is false in the meantime, please
656         * tell us !
657         */
658        class Group {
659            public:
660                String Name; ///< Stores the name of this Group.
661            protected:
662                Group(RIFF::File* file, RIFF::Chunk* ck3gnm);
663                virtual ~Group();
664                virtual void UpdateChunks();
665              friend class File;              friend class File;
666            private:
667                RIFF::File*  pFile;
668                RIFF::Chunk* pNameChunk;
669      };      };
670    
     // TODO: <3gnm> chunk not added yet (just contains the names of the sample groups)  
671      /** Parses Gigasampler files and provides abstract access to the data. */      /** Parses Gigasampler files and provides abstract access to the data. */
672      class File : protected DLS::File {      class File : protected DLS::File {
673          public:          public:
# Line 679  namespace gig { Line 680  namespace gig {
680    
681              // derived methods from DLS::Resource              // derived methods from DLS::Resource
682              DLS::Resource::GetParent;              DLS::Resource::GetParent;
683                // derived methods from DLS::File
684                DLS::File::Save;
685              // overridden  methods              // overridden  methods
686                File();
687              File(RIFF::File* pRIFF);              File(RIFF::File* pRIFF);
688              Sample*     GetFirstSample();     ///< 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.
689              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.
690                Sample*     AddSample();
691                void        DeleteSample(Sample* pSample);
692              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.
693              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.
694              Instrument* GetInstrument(uint index);              Instrument* GetInstrument(uint index, progress_t* pProgress = NULL);
695             ~File();              Instrument* AddInstrument();
696                void        DeleteInstrument(Instrument* pInstrument);
697                Group*      GetFirstGroup(); ///< Returns a pointer to the first <i>Group</i> object of the file, <i>NULL</i> otherwise.
698                Group*      GetNextGroup();  ///< Returns a pointer to the next <i>Group</i> object of the file, <i>NULL</i> otherwise.
699                Group*      GetGroup(uint index);
700                Group*      AddGroup();
701                void        DeleteGroup(Group* pGroup);
702                virtual    ~File();
703          protected:          protected:
704              typedef std::list<Sample*>     SampleList;              // overridden protected methods from DLS::File
705              typedef std::list<Instrument*> InstrumentList;              virtual void LoadSamples();
706                virtual void LoadInstruments();
707              SampleList*              pSamples;              virtual void LoadGroups();
708              SampleList::iterator     SamplesIterator;              // own protected methods
709              InstrumentList*          pInstruments;              virtual void LoadSamples(progress_t* pProgress);
710              InstrumentList::iterator InstrumentsIterator;              virtual void LoadInstruments(progress_t* pProgress);
   
             void LoadSamples();  
             void LoadInstruments();  
711              friend class Region;              friend class Region;
712                friend class Sample;
713            private:
714                std::list<Group*>*          pGroups;
715                std::list<Group*>::iterator GroupsIterator;
716      };      };
717    
718      /** Will be thrown whenever a gig specific error occurs while trying to access a Gigasampler File. */      /** Will be thrown whenever a gig specific error occurs while trying to access a Gigasampler File. */
# Line 708  namespace gig { Line 722  namespace gig {
722              void PrintMessage();              void PrintMessage();
723      };      };
724    
725        String libraryName();
726        String libraryVersion();
727    
728  } // namespace gig  } // namespace gig
729    
730  #endif // __GIG_H__  #endif // __GIG_H__
Legend:
Removed from v.437  
changed lines
  Added in v.929
  ViewVC Help
Powered by ViewVC