/[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 21 by schoenebeck, Thu Dec 25 01:09:08 2003 UTC revision 55 by schoenebeck, Tue Apr 27 09:06:07 2004 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 by Christian Schoenebeck                           *   *   Copyright (C) 2003, 2004 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  *
9   *   it under the terms of the GNU General Public License as published by  *   *   it under the terms of the GNU General Public License as published by  *
# Line 168  namespace gig { Line 168  namespace gig {
168          vcf_res_ctrl_genpurpose6 = 3            ///< General Purpose Controller 6 (Button, MIDI Controller 81)          vcf_res_ctrl_genpurpose6 = 3            ///< General Purpose Controller 6 (Button, MIDI Controller 81)
169      } vcf_res_ctrl_t;      } vcf_res_ctrl_t;
170    
171      /** Defines how attenuation (=gain / VCA) is controlled by. */      /**
172      typedef enum {       * Defines a controller that has a certain contrained influence on a
173          attenuation_ctrl_none              = 0x00,       * particular synthesis parameter (used to define attenuation controller,
174          attenuation_ctrl_modwheel          = 0x03, ///< Modulation Wheel (MIDI Controller 1)       * EG1 controller and EG2 controller).
175          attenuation_ctrl_breath            = 0x05, ///< Breath Controller (Coarse, MIDI Controller 2)       *
176          attenuation_ctrl_foot              = 0x07, ///< Foot Pedal (Coarse, MIDI Controller 4)       * You should use the respective <i>typedef</i> (means either
177          attenuation_ctrl_effect1           = 0x0d, ///< Effect Controller 1 (Coarse, MIDI Controller 12)       * attenuation_ctrl_t, eg1_ctrl_t or eg2_ctrl_t) in your code!
178          attenuation_ctrl_effect2           = 0x0f, ///< Effect Controller 2 (Coarse, MIDI Controller 13)       */
179          attenuation_ctrl_genpurpose1       = 0x11, ///< General Purpose Controller 1 (Slider, MIDI Controller 16)      struct leverage_ctrl_t {
180          attenuation_ctrl_genpurpose2       = 0x13, ///< General Purpose Controller 2 (Slider, MIDI Controller 17)          typedef enum {
181          attenuation_ctrl_genpurpose3       = 0x15, ///< General Purpose Controller 3 (Slider, MIDI Controller 18)              type_none              = 0x00, ///< No controller defined
182          attenuation_ctrl_genpurpose4       = 0x17, ///< General Purpose Controller 4 (Slider, MIDI Controller 19)              type_channelaftertouch = 0x2f, ///< Channel Key Pressure
183          attenuation_ctrl_portamentotime    = 0x0b, ///< Portamento Time (Coarse, MIDI Controller 5)              type_velocity          = 0xff, ///< Key Velocity
184          attenuation_ctrl_sustainpedal      = 0x01, ///< Sustain Pedal (MIDI Controller 64)              type_controlchange     = 0xfe  ///< Ordinary MIDI control change controller, see field 'controller_number'
185          attenuation_ctrl_portamento        = 0x19, ///< Portamento (MIDI Controller 65)          } type_t;
186          attenuation_ctrl_sostenutopedal    = 0x1b, ///< Sostenuto Pedal (MIDI Controller 66)  
187          attenuation_ctrl_softpedal         = 0x09, ///< Soft Pedal (MIDI Controller 67)          type_t type;              ///< Controller type
188          attenuation_ctrl_genpurpose5       = 0x1d, ///< General Purpose Controller 5 (Button, MIDI Controller 80)          uint   controller_number; ///< MIDI controller number if this controller is a control change controller, 0 otherwise
189          attenuation_ctrl_genpurpose6       = 0x1f, ///< General Purpose Controller 6 (Button, MIDI Controller 81)      };
190          attenuation_ctrl_genpurpose7       = 0x21, ///< General Purpose Controller 7 (Button, MIDI Controller 82)  
191          attenuation_ctrl_genpurpose8       = 0x23, ///< General Purpose Controller 8 (Button, MIDI Controller 83)      /**
192          attenuation_ctrl_effect1depth      = 0x25, ///< Effect 1 Depth (MIDI Controller 91)       * Defines controller influencing attenuation.
193          attenuation_ctrl_effect2depth      = 0x27, ///< Effect 2 Depth (MIDI Controller 92)       *
194          attenuation_ctrl_effect3depth      = 0x29, ///< Effect 3 Depth (MIDI Controller 93)       * @see leverage_ctrl_t
195          attenuation_ctrl_effect4depth      = 0x2b, ///< Effect 4 Depth (MIDI Controller 94)       */
196          attenuation_ctrl_effect5depth      = 0x2d, ///< Effect 5 Depth (MIDI Controller 95)      typedef leverage_ctrl_t attenuation_ctrl_t;
197          attenuation_ctrl_channelaftertouch = 0x2f, ///< Channel Key Pressure  
198          attenuation_ctrl_velocity          = 0xff  ///< Key Velocity      /**
199      } attenuation_ctrl_t, eg1_ctrl_t, eg2_ctrl_t;       * Defines controller influencing envelope generator 1.
200         *
201         * @see leverage_ctrl_t
202         */
203        typedef leverage_ctrl_t eg1_ctrl_t;
204    
205        /**
206         * Defines controller influencing envelope generator 2.
207         *
208         * @see leverage_ctrl_t
209         */
210        typedef leverage_ctrl_t eg2_ctrl_t;
211    
212      /**      /**
213       * Defines the type of dimension, that is how the dimension zones (and       * Defines the type of dimension, that is how the dimension zones (and
# Line 282  namespace gig { Line 293  namespace gig {
293          #endif // WORDS_BIGENDIAN          #endif // WORDS_BIGENDIAN
294      };      };
295    
296        /** Reflects the current playback state for a sample. */
297        struct playback_state_t {
298            unsigned long position;          ///< Current position within the sample.
299            bool          reverse;           ///< If playback direction is currently backwards (in case there is a pingpong or reverse loop defined).
300            unsigned long loop_cycles_left;  ///< How many times the loop has still to be passed, this value will be decremented with each loop cycle.
301        };
302    
303      // just symbol prototyping      // just symbol prototyping
304      class File;      class File;
305      class Instrument;      class Instrument;
# Line 314  namespace gig { Line 332  namespace gig {
332              bool               EG1Hold;                       ///< If <i>true</i>, Decay1 stage should be postponed until the sample reached the sample loop start.              bool               EG1Hold;                       ///< If <i>true</i>, Decay1 stage should be postponed until the sample reached the sample loop start.
333              eg1_ctrl_t         EG1Controller;                 ///< MIDI Controller which has influence on sample amplitude EG parameters (attack, decay, release).              eg1_ctrl_t         EG1Controller;                 ///< MIDI Controller which has influence on sample amplitude EG parameters (attack, decay, release).
334              bool               EG1ControllerInvert;           ///< Invert values coming from defined EG1 controller.              bool               EG1ControllerInvert;           ///< Invert values coming from defined EG1 controller.
335              uint8_t            EG1ControllerAttackInfluence;  ///< Amount EG1 Controller has influence on the EG1 Attack time.              uint8_t            EG1ControllerAttackInfluence;  ///< Amount EG1 Controller has influence on the EG1 Attack time (0 - 3, where 0 means off).
336              uint8_t            EG1ControllerDecayInfluence;   ///< Amount EG1 Controller has influence on the EG1 Decay time.              uint8_t            EG1ControllerDecayInfluence;   ///< Amount EG1 Controller has influence on the EG1 Decay time (0 - 3, where 0 means off).
337              uint8_t            EG1ControllerReleaseInfluence; ///< Amount EG1 Controller has influence on the EG1 Release time.              uint8_t            EG1ControllerReleaseInfluence; ///< Amount EG1 Controller has influence on the EG1 Release time (0 - 3, where 0 means off).
338              double             LFO1Frequency;                 ///< Frequency of the sample amplitude LFO (0.10 - 10.00 Hz).              double             LFO1Frequency;                 ///< Frequency of the sample amplitude LFO (0.10 - 10.00 Hz).
339              uint16_t           LFO1InternalDepth;             ///< Firm pitch of the sample amplitude LFO (0 - 1200 cents).              uint16_t           LFO1InternalDepth;             ///< Firm pitch of the sample amplitude LFO (0 - 1200 cents).
340              uint16_t           LFO1ControlDepth;              ///< Controller depth influencing sample amplitude LFO pitch (0 - 1200 cents).              uint16_t           LFO1ControlDepth;              ///< Controller depth influencing sample amplitude LFO pitch (0 - 1200 cents).
# Line 333  namespace gig { Line 351  namespace gig {
351              double             EG2Release;                    ///< Release time of the filter cutoff EG (0.000 - 60.000s).              double             EG2Release;                    ///< Release time of the filter cutoff EG (0.000 - 60.000s).
352              eg2_ctrl_t         EG2Controller;                 ///< MIDI Controller which has influence on filter cutoff EG parameters (attack, decay, release).              eg2_ctrl_t         EG2Controller;                 ///< MIDI Controller which has influence on filter cutoff EG parameters (attack, decay, release).
353              bool               EG2ControllerInvert;           ///< Invert values coming from defined EG2 controller.              bool               EG2ControllerInvert;           ///< Invert values coming from defined EG2 controller.
354              uint8_t            EG2ControllerAttackInfluence;  ///< Amount EG2 Controller has influence on the EG2 Attack time.              uint8_t            EG2ControllerAttackInfluence;  ///< Amount EG2 Controller has influence on the EG2 Attack time (0 - 3, where 0 means off).
355              uint8_t            EG2ControllerDecayInfluence;   ///< Amount EG2 Controller has influence on the EG2 Decay time.              uint8_t            EG2ControllerDecayInfluence;   ///< Amount EG2 Controller has influence on the EG2 Decay time (0 - 3, where 0 means off).
356              uint8_t            EG2ControllerReleaseInfluence; ///< Amount EG2 Controller has influence on the EG2 Release time.              uint8_t            EG2ControllerReleaseInfluence; ///< Amount EG2 Controller has influence on the EG2 Release time (0 - 3, where 0 means off).
357              double             LFO2Frequency;                 ///< Frequency of the filter cutoff LFO (0.10 - 10.00 Hz).              double             LFO2Frequency;                 ///< Frequency of the filter cutoff LFO (0.10 - 10.00 Hz).
358              uint16_t           LFO2InternalDepth;             ///< Firm pitch of the filter cutoff LFO (0 - 1200 cents).              uint16_t           LFO2InternalDepth;             ///< Firm pitch of the filter cutoff LFO (0 - 1200 cents).
359              uint16_t           LFO2ControlDepth;              ///< Controller depth influencing filter cutoff LFO pitch (0 - 1200).              uint16_t           LFO2ControlDepth;              ///< Controller depth influencing filter cutoff LFO pitch (0 - 1200).
# Line 376  namespace gig { Line 394  namespace gig {
394              dim_bypass_ctrl_t  DimensionBypass;               ///< If defined, the MIDI controller can switch on/off the dimension in realtime.              dim_bypass_ctrl_t  DimensionBypass;               ///< If defined, the MIDI controller can switch on/off the dimension in realtime.
395              int8_t             Pan;                           ///< Panorama / Balance (-64..0..63 <-> left..middle..right)              int8_t             Pan;                           ///< Panorama / Balance (-64..0..63 <-> left..middle..right)
396              bool               SelfMask;                      ///< If <i>true</i>: high velocity notes will stop low velocity notes at the same note, with that you can save voices that wouldn't be audible anyway.              bool               SelfMask;                      ///< If <i>true</i>: high velocity notes will stop low velocity notes at the same note, with that you can save voices that wouldn't be audible anyway.
397              attenuation_ctrl_t AttenuationControl;            ///< MIDI Controller which has influence on the volume level of the sample (or entire sample group).              attenuation_ctrl_t AttenuationController;         ///< MIDI Controller which has influence on the volume level of the sample (or entire sample group).
398              bool               InvertAttenuationControl;      ///< Inverts the values coming from the defined Attenuation Controller.              bool               InvertAttenuationController;   ///< Inverts the values coming from the defined Attenuation Controller.
399              uint8_t            AttenuationControlTreshold;    ///< 0-127              uint8_t            AttenuationControllerThreshold;///< 0-127
400              uint8_t            ChannelOffset;                 ///< Audio output where the audio signal of the dimension region should be routed to (0 - 9).              uint8_t            ChannelOffset;                 ///< Audio output where the audio signal of the dimension region should be routed to (0 - 9).
401              bool               SustainDefeat;                 ///< If <i>true</i>: Sustain pedal will not hold a note.              bool               SustainDefeat;                 ///< If <i>true</i>: Sustain pedal will not hold a note.
402              bool               MSDecode;                      ///< Gigastudio flag: defines if Mid Side Recordings should be decoded.              bool               MSDecode;                      ///< Gigastudio flag: defines if Mid Side Recordings should be decoded.
# Line 397  namespace gig { Line 415  namespace gig {
415             ~DimensionRegion();             ~DimensionRegion();
416              friend class Region;              friend class Region;
417          private:          private:
418                typedef enum { ///< Used to decode attenuation, EG1 and EG2 controller
419                    _lev_ctrl_none              = 0x00,
420                    _lev_ctrl_modwheel          = 0x03, ///< Modulation Wheel (MIDI Controller 1)
421                    _lev_ctrl_breath            = 0x05, ///< Breath Controller (Coarse, MIDI Controller 2)
422                    _lev_ctrl_foot              = 0x07, ///< Foot Pedal (Coarse, MIDI Controller 4)
423                    _lev_ctrl_effect1           = 0x0d, ///< Effect Controller 1 (Coarse, MIDI Controller 12)
424                    _lev_ctrl_effect2           = 0x0f, ///< Effect Controller 2 (Coarse, MIDI Controller 13)
425                    _lev_ctrl_genpurpose1       = 0x11, ///< General Purpose Controller 1 (Slider, MIDI Controller 16)
426                    _lev_ctrl_genpurpose2       = 0x13, ///< General Purpose Controller 2 (Slider, MIDI Controller 17)
427                    _lev_ctrl_genpurpose3       = 0x15, ///< General Purpose Controller 3 (Slider, MIDI Controller 18)
428                    _lev_ctrl_genpurpose4       = 0x17, ///< General Purpose Controller 4 (Slider, MIDI Controller 19)
429                    _lev_ctrl_portamentotime    = 0x0b, ///< Portamento Time (Coarse, MIDI Controller 5)
430                    _lev_ctrl_sustainpedal      = 0x01, ///< Sustain Pedal (MIDI Controller 64)
431                    _lev_ctrl_portamento        = 0x19, ///< Portamento (MIDI Controller 65)
432                    _lev_ctrl_sostenutopedal    = 0x1b, ///< Sostenuto Pedal (MIDI Controller 66)
433                    _lev_ctrl_softpedal         = 0x09, ///< Soft Pedal (MIDI Controller 67)
434                    _lev_ctrl_genpurpose5       = 0x1d, ///< General Purpose Controller 5 (Button, MIDI Controller 80)
435                    _lev_ctrl_genpurpose6       = 0x1f, ///< General Purpose Controller 6 (Button, MIDI Controller 81)
436                    _lev_ctrl_genpurpose7       = 0x21, ///< General Purpose Controller 7 (Button, MIDI Controller 82)
437                    _lev_ctrl_genpurpose8       = 0x23, ///< General Purpose Controller 8 (Button, MIDI Controller 83)
438                    _lev_ctrl_effect1depth      = 0x25, ///< Effect 1 Depth (MIDI Controller 91)
439                    _lev_ctrl_effect2depth      = 0x27, ///< Effect 2 Depth (MIDI Controller 92)
440                    _lev_ctrl_effect3depth      = 0x29, ///< Effect 3 Depth (MIDI Controller 93)
441                    _lev_ctrl_effect4depth      = 0x2b, ///< Effect 4 Depth (MIDI Controller 94)
442                    _lev_ctrl_effect5depth      = 0x2d, ///< Effect 5 Depth (MIDI Controller 95)
443                    _lev_ctrl_channelaftertouch = 0x2f, ///< Channel Key Pressure
444                    _lev_ctrl_velocity          = 0xff  ///< Key Velocity
445                } _lev_ctrl_t;
446              typedef std::map<uint32_t, double*> VelocityTableMap;              typedef std::map<uint32_t, double*> VelocityTableMap;
447    
448              static uint              Instances;                  ///< Number of DimensionRegion instances.              static uint              Instances;                  ///< Number of DimensionRegion instances.
449              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).
450              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.
451    
452                leverage_ctrl_t DecodeLeverageController(_lev_ctrl_t EncodedController);
453      };      };
454    
455      /** Encapsulates sample waves used for playback. */      /** Encapsulates sample waves used for playback. */
# Line 436  namespace gig { Line 484  namespace gig {
484              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);
485              unsigned long GetPos();              unsigned long GetPos();
486              unsigned long Read(void* pBuffer, unsigned long SampleCount);              unsigned long Read(void* pBuffer, unsigned long SampleCount);
487                unsigned long ReadAndLoop(void* pBuffer, unsigned long SampleCount, playback_state_t* pPlaybackState);
488          protected:          protected:
489              static unsigned int  Instances;               ///< Number of instances of class Sample.              static unsigned int  Instances;               ///< Number of instances of class Sample.
490              static unsigned long DecompressionBufferSize; ///< Current size of the decompression buffer.              static unsigned long DecompressionBufferSize; ///< Current size of the decompression buffer.
# Line 447  namespace gig { Line 496  namespace gig {
496    
497              Sample(File* pFile, RIFF::List* waveList, unsigned long WavePoolOffset);              Sample(File* pFile, RIFF::List* waveList, unsigned long WavePoolOffset);
498             ~Sample();             ~Sample();
499                /**
500                 * Swaps the order of the data words in the given memory area
501                 * with a granularity given by \a WordSize.
502                 *
503                 * @param pData    - pointer to the memory area to be swapped
504                 * @param AreaSize - size of the memory area to be swapped (in bytes)
505                 * @param WordSize - size of the data words (in bytes)
506                 */
507                inline void SwapMemoryArea(void* pData, unsigned long AreaSize, uint WordSize) {
508                    switch (WordSize) { // TODO: unefficient
509                        case 1: {
510                            uint8_t* pDst = (uint8_t*) pData;
511                            uint8_t  cache;
512                            unsigned long lo = 0, hi = AreaSize - 1;
513                            for (; lo < hi; hi--, lo++) {
514                                cache    = pDst[lo];
515                                pDst[lo] = pDst[hi];
516                                pDst[hi] = cache;
517                            }
518                            break;
519                        }
520                        case 2: {
521                            uint16_t* pDst = (uint16_t*) pData;
522                            uint16_t  cache;
523                            unsigned long lo = 0, hi = (AreaSize >> 1) - 1;
524                            for (; lo < hi; hi--, lo++) {
525                                cache    = pDst[lo];
526                                pDst[lo] = pDst[hi];
527                                pDst[hi] = cache;
528                            }
529                            break;
530                        }
531                        case 4: {
532                            uint32_t* pDst = (uint32_t*) pData;
533                            uint32_t  cache;
534                            unsigned long lo = 0, hi = (AreaSize >> 2) - 1;
535                            for (; lo < hi; hi--, lo++) {
536                                cache    = pDst[lo];
537                                pDst[lo] = pDst[hi];
538                                pDst[hi] = cache;
539                            }
540                            break;
541                        }
542                        default: {
543                            uint8_t* pCache = new uint8_t[WordSize]; // TODO: unefficient
544                            unsigned long lo = 0, hi = AreaSize - WordSize;
545                            for (; lo < hi; hi -= WordSize, lo += WordSize) {
546                                memcpy(pCache, (uint8_t*) pData + lo, WordSize);
547                                memcpy((uint8_t*) pData + lo, (uint8_t*) pData + hi, WordSize);
548                                memcpy((uint8_t*) pData + hi, pCache, WordSize);
549                            }
550                            delete[] pCache;
551                            break;
552                        }
553                    }
554                }
555                inline long Min(long A, long B) {
556                    return (A > B) ? B : A;
557                }
558                inline long Abs(long val) { return (val > 0) ? val : -val; }
559          private:          private:
560              void ScanCompressedSample();              void ScanCompressedSample();
561              friend class File;              friend class File;
Legend:
Removed from v.21  
changed lines
  Added in v.55
  ViewVC Help
Powered by ViewVC