simgear/sound/soundmgr.hxx

   1 // soundmgr.hxx -- Sound effect management class
   2 //
   3 // Sound manager initially written by David Findlay
   4 // <david_j_findlay@yahoo.com.au> 2001
   5 //
   6 // C++-ified by Curtis Olson, started March 2001.
   7 //
   8 // Copyright (C) 2001  Curtis L. Olson - curt@flightgear.org
   9 //
  10 // This program is free software; you can redistribute it and/or
  11 // modify it under the terms of the GNU General Public License as
  12 // published by the Free Software Foundation; either version 2 of the
  13 // License, or (at your option) any later version.
  14 //
  15 // This program is distributed in the hope that it will be useful, but
  16 // WITHOUT ANY WARRANTY; without even the implied warranty of
  17 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18 // General Public License for more details.
  19 //
  20 // You should have received a copy of the GNU General Public License
  21 // along with this program; if not, write to the Free Software
  22 // Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  23 //
  24 // $Id$
  25
  26 /**
  27  * \file soundmgr.hxx
  28  * Provides a sound manager class to keep track of
  29  * multiple sounds and manage playing them with different effects and
  30  * timings.
  31  */
  32
  33 #ifndef _SG_SOUNDMGR_HXX
  34 #define _SG_SOUNDMGR_HXX 1
  35
  36 #ifndef __cplusplus
  37 # error This library requires C++
  38 #endif
  39
  40 #include <simgear/compiler.h>
  41 #include <simgear/timing/timestamp.hxx>
  42
  43 #include STL_STRING
  44 #include <map>
  45
  46 #include <plib/sl.h>
  47 #include <plib/sm.h>
  48
  49 SG_USING_STD(map);
  50 SG_USING_STD(string);
  51
  52
  53 /**
  54  * manages everything we need to know for an individual sound sample
  55  */
  56 class SGSimpleSound {
  57
  58 private:
  59
  60     slSample *sample;
  61     slEnvelope *pitch_envelope;
  62     slEnvelope *volume_envelope;
  63     double pitch;
  64     double volume;
  65
  66 public:
  67
  68     SGSimpleSound( const char *path, const char *file = NULL );
  69     SGSimpleSound( unsigned char *buffer, int len );
  70     ~SGSimpleSound();
  71
  72     void play( slScheduler *sched, bool looped );
  73     void stop( slScheduler *sched, bool quick = true );
  74
  75     inline void play_once( slScheduler *sched ) { play( sched, false); }
  76     inline void play_looped( slScheduler *sched ) { play( sched, true); }
  77     inline bool is_playing( ) {
  78         return ( sample->getPlayCount() > 0 );
  79     }
  80
  81     inline double get_pitch() const { return pitch; }
  82     inline void set_pitch( double p ) {
  83        pitch = p;
  84        pitch_envelope->setStep( 0, 0.01, pitch );
  85     }
  86     inline double get_volume() const { return volume; }
  87     inline void set_volume( double v ) {
  88        volume = v;
  89        volume_envelope->setStep( 0, 0.01, volume );
  90     }
  91
  92     inline slSample *get_sample() { return sample; }
  93     inline slEnvelope *get_pitch_envelope() { return pitch_envelope; }
  94     inline slEnvelope *get_volume_envelope() { return volume_envelope; }
  95 };
  96
  97
  98 typedef struct {
  99         int n;
 100         slSample *sample;
 101 } sample_ref;
 102
 103 typedef map < string, sample_ref * > sample_map;
 104 typedef sample_map::iterator sample_map_iterator;
 105 typedef sample_map::const_iterator const_sample_map_iterator;
 106
 107 typedef map < string, SGSimpleSound * > sound_map;
 108 typedef sound_map::iterator sound_map_iterator;
 109 typedef sound_map::const_iterator const_sound_map_iterator;
 110
 111
 112 /**
 113  * Manage a collection of SGSimpleSound instances
 114  */
 115 class SGSoundMgr
 116 {
 117
 118     slScheduler *audio_sched;
 119     smMixer *audio_mixer;
 120
 121     sound_map sounds;
 122     sample_map samples;
 123
 124     double safety;
 125
 126 public:
 127
 128     SGSoundMgr();
 129     ~SGSoundMgr();
 130
 131
 132     /**
 133      * (re) initialize the sound manager.
 134      */
 135     void init();
 136
 137
 138     /**
 139      * Bind properties for the sound manager.
 140      */
 141     void bind ();
 142
 143
 144     /**
 145      * Unbind properties for the sound manager.
 146      */
 147     void unbind ();
 148
 149
 150     /**
 151      * Run the audio scheduler.
 152      */
 153     void update(double dt);
 154
 155
 156     /**
 157      * Pause all sounds.
 158      */
 159     void pause ();
 160
 161
 162     /**
 163      * Resume all sounds.
 164      */
 165     void resume ();
 166
 167
 168     /**
 169      * is audio working?
 170      */
 171     inline bool is_working() const { return !audio_sched->notWorking(); }
 172
 173     /**
 174      * reinitialize the sound manager
 175      */
 176     inline void reinit() { init(); }
 177
 178     /**
 179      * add a sound effect, return true if successful
 180      */
 181     bool add( SGSimpleSound *sound, const string& refname);
 182
 183     /**
 184      * add a sound file, return the sample if successful, else return NULL
 185      */
 186     SGSimpleSound *add( const string& refname,
 187                       const char *path, const char *file = NULL );
 188
 189     /**
 190      * remove a sound effect, return true if successful
 191      */
 192     bool remove( const string& refname );
 193
 194     /**
 195      * return true of the specified sound exists in the sound manager system
 196      */
 197     bool exists( const string& refname );
 198
 199     /**
 200      * return a pointer to the SGSimpleSound if the specified sound
 201      * exists in the sound manager system, otherwise return NULL
 202      */
 203      SGSimpleSound *find( const string& refname );
 204
 205     /**
 206      * tell the scheduler to play the indexed sample in a continuous
 207      * loop
 208      */
 209     bool play_looped( const string& refname );
 210
 211     /**
 212      * tell the scheduler to play the indexed sample once
 213      */
 214     bool play_once( const string& refname );
 215
 216     /**
 217      * return true of the specified sound is currently being played
 218      */
 219     bool is_playing( const string& refname );
 220
 221     /**
 222      * immediate stop playing the sound
 223      */
 224     bool stop( const string& refname );
 225
 226     /**
 227      * return the audio scheduler
 228      */
 229     inline slScheduler *get_scheduler( ) { return audio_sched; };
 230 };
 231
 232
 233 #endif // _SG_SOUNDMGR_HXX
 234
 235