/[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 406 by persson, Wed Feb 23 19:11:07 2005 UTC revision 518 by schoenebeck, Sun May 8 16:19:34 2005 UTC
# Line 225  namespace gig { Line 225  namespace gig {
225          dimension_channelaftertouch = 0x83, ///< Channel Key Pressure          dimension_channelaftertouch = 0x83, ///< Channel Key Pressure
226          dimension_releasetrigger    = 0x84, ///< Special dimension for triggering samples on releasing a key.          dimension_releasetrigger    = 0x84, ///< Special dimension for triggering samples on releasing a key.
227          dimension_keyboard          = 0x85, ///< Dimension for keyswitching          dimension_keyboard          = 0x85, ///< Dimension for keyswitching
228            dimension_roundrobin        = 0x86, ///< Different samples triggered each time a note is played, dimension regions selected in sequence
229            dimension_random            = 0x87, ///< Different samples triggered each time a note is played, random order
230          dimension_modwheel          = 0x01, ///< Modulation Wheel (MIDI Controller 1)          dimension_modwheel          = 0x01, ///< Modulation Wheel (MIDI Controller 1)
231          dimension_breath            = 0x02, ///< Breath Controller (Coarse, MIDI Controller 2)          dimension_breath            = 0x02, ///< Breath Controller (Coarse, MIDI Controller 2)
232          dimension_foot              = 0x04, ///< Foot Pedal (Coarse, MIDI Controller 4)          dimension_foot              = 0x04, ///< Foot Pedal (Coarse, MIDI Controller 4)
# Line 307  namespace gig { Line 309  namespace gig {
309          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.
310      };      };
311    
312        /**
313         * @brief Used for indicating the progress of a certain task.
314         *
315         * The function pointer argument has to be supplied with a valid
316         * function of the given signature which will then be called on
317         * progress changes. An equivalent progress_t structure will be passed
318         * back as argument to the callback function on each progress change.
319         * The factor field of the supplied progress_t structure will then
320         * reflect the current progress as value between 0.0 and 1.0. You might
321         * want to use the custom field for data needed in your callback
322         * function.
323         */
324        struct progress_t {
325            void (*callback)(progress_t*); ///< Callback function pointer which has to be assigned to a function for progress notification.
326            float factor;                  ///< Reflects current progress as value between 0.0 and 1.0.
327            void* custom;                  ///< This pointer can be used for arbitrary data.
328            float __range_min;             ///< Only for internal usage, do not modify!
329            float __range_max;             ///< Only for internal usage, do not modify!
330            progress_t();
331        };
332    
333      // just symbol prototyping      // just symbol prototyping
334      class File;      class File;
335      class Instrument;      class Instrument;
# Line 483  namespace gig { Line 506  namespace gig {
506              uint32_t       LoopFraction;      ///< The fractional value specifies a fraction of a sample at which to loop (only if Loops > 0). This allows a loop to be fine tuned at a resolution greater than one sample. A value of 0 means no fraction, a value of 0x80000000 means 1/2 of a sample length. 0xFFFFFFFF is the smallest fraction of a sample that can be represented.              uint32_t       LoopFraction;      ///< The fractional value specifies a fraction of a sample at which to loop (only if Loops > 0). This allows a loop to be fine tuned at a resolution greater than one sample. A value of 0 means no fraction, a value of 0x80000000 means 1/2 of a sample length. 0xFFFFFFFF is the smallest fraction of a sample that can be represented.
507              uint32_t       LoopPlayCount;     ///< Number of times the loop should be played (only if Loops > 0, a value of 0 = infinite).              uint32_t       LoopPlayCount;     ///< Number of times the loop should be played (only if Loops > 0, a value of 0 = infinite).
508              bool           Compressed;        ///< If the sample wave is compressed (probably just interesting for instrument and sample editors, as this library already handles the decompression in it's sample access methods anyway).              bool           Compressed;        ///< If the sample wave is compressed (probably just interesting for instrument and sample editors, as this library already handles the decompression in it's sample access methods anyway).
509                uint32_t       TruncatedBits;     ///< For 24-bit compressed samples only: number of bits truncated during compression (0, 4 or 6)
510                bool           Dithered;          ///< For 24-bit compressed samples only: if dithering was used during compression with bit reduction
511    
512              // own methods              // own methods
513              buffer_t      LoadSampleData();              buffer_t      LoadSampleData();
# Line 618  namespace gig { Line 643  namespace gig {
643    
644              Region(Instrument* pInstrument, RIFF::List* rgnList);              Region(Instrument* pInstrument, RIFF::List* rgnList);
645              void LoadDimensionRegions(RIFF::List* rgn);              void LoadDimensionRegions(RIFF::List* rgn);
646              Sample* GetSampleFromWavePool(unsigned int WavePoolTableIndex);              Sample* GetSampleFromWavePool(unsigned int WavePoolTableIndex, progress_t* pProgress = NULL);
647             ~Region();             ~Region();
648              friend class Instrument;              friend class Instrument;
649      };      };
# Line 657  namespace gig { Line 682  namespace gig {
682              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
683              int       RegionIndex;              int       RegionIndex;
684    
685              Instrument(File* pFile, RIFF::List* insList);              Instrument(File* pFile, RIFF::List* insList, progress_t* pProgress = NULL);
686             ~Instrument();             ~Instrument();
687              friend class File;              friend class File;
688      };      };
# Line 677  namespace gig { Line 702  namespace gig {
702              DLS::Resource::GetParent;              DLS::Resource::GetParent;
703              // overridden  methods              // overridden  methods
704              File(RIFF::File* pRIFF);              File(RIFF::File* pRIFF);
705              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.
706              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.
707              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.
708              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.
709              Instrument* GetInstrument(uint index);              Instrument* GetInstrument(uint index, progress_t* pProgress = NULL);
710             ~File();             ~File();
711          protected:          protected:
712              typedef std::list<Sample*>     SampleList;              typedef std::list<Sample*>     SampleList;
# Line 692  namespace gig { Line 717  namespace gig {
717              InstrumentList*          pInstruments;              InstrumentList*          pInstruments;
718              InstrumentList::iterator InstrumentsIterator;              InstrumentList::iterator InstrumentsIterator;
719    
720              void LoadSamples();              void LoadSamples(progress_t* pProgress = NULL);
721              void LoadInstruments();              void LoadInstruments(progress_t* pProgress = NULL);
722              friend class Region;              friend class Region;
723      };      };
724    
# Line 704  namespace gig { Line 729  namespace gig {
729              void PrintMessage();              void PrintMessage();
730      };      };
731    
732        String libraryName();
733        String libraryVersion();
734    
735  } // namespace gig  } // namespace gig
736    
737  #endif // __GIG_H__  #endif // __GIG_H__
Legend:
Removed from v.406  
changed lines
  Added in v.518
  ViewVC Help
Powered by ViewVC