simgear/sound/sample_openal.hxx

   1 // sample.hxx -- Sound sample encapsulation class
   2 //
   3 // Written by Curtis Olson, started April 2004.
   4 //
   5 // Copyright (C) 2004  Curtis L. Olson - http://www.flightgear.org/~curt
   6 //
   7 // This program is free software; you can redistribute it and/or
   8 // modify it under the terms of the GNU General Public License as
   9 // published by the Free Software Foundation; either version 2 of the
  10 // License, or (at your option) any later version.
  11 //
  12 // This program is distributed in the hope that it will be useful, but
  13 // WITHOUT ANY WARRANTY; without even the implied warranty of
  14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15 // General Public License for more details.
  16 //
  17 // You should have received a copy of the GNU General Public License
  18 // along with this program; if not, write to the Free Software
  19 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  20 //
  21 // $Id$
  22
  23 /**
  24  * \file sample.hxx
  25  * Provides a sound sample encapsulation
  26  */
  27
  28 #ifndef _SG_SAMPLE_HXX
  29 #define _SG_SAMPLE_HXX 1
  30
  31 #ifndef __cplusplus
  32 # error This library requires C++
  33 #endif
  34
  35 #include <string>
  36
  37 #include <simgear/compiler.h>
  38 #include <simgear/debug/logstream.hxx>
  39 #include <simgear/structure/SGReferenced.hxx>
  40 #include <simgear/structure/SGSharedPtr.hxx>
  41 #include <simgear/math/SGMath.hxx>
  42
  43 #include <plib/sg.h>
  44
  45 using std::string;
  46
  47 /**
  48  * manages everything we need to know for an individual sound sample
  49  */
  50
  51 class SGSoundSample : public SGReferenced {
  52
  53 private:
  54
  55     // Position of the source sound.
  56     SGVec3d _absolute_pos;      // absolute position
  57     SGVec3f _relative_pos;      // position relative to the base position
  58     SGVec3d _base_pos;          // base position
  59
  60     // The orientation of the sound (direction and cut-off angles)
  61     SGVec3f _direction;
  62
  63     // Velocity of the source sound.
  64     SGVec3f _velocity;
  65
  66     string _sample_name;
  67     unsigned char *_data;
  68
  69     // configuration values
  70     int _format;
  71     int _size;
  72     int _freq;
  73
  74     // Buffers hold sound data.
  75     bool _valid_buffer;
  76     unsigned int _buffer;
  77
  78     // Sources are points emitting sound.
  79     bool _valid_source;
  80     unsigned int _source;
  81
  82     // The orientation of the sound (direction and cut-off angles)
  83     float _inner_angle;
  84     float _outer_angle;
  85     float _outer_gain;
  86
  87     float _pitch;
  88     float _volume;
  89     float _master_volume;
  90     float _reference_dist;
  91     float _max_dist;
  92     bool _loop;
  93
  94     bool _playing;
  95     bool _changed;
  96     bool _static_changed;
  97     bool _is_file;
  98
  99     void update_absolute_position();
 100
 101 public:
 102
 103      /**
 104       * Empty constructor, can be used to read data to the systems
 105       * memory and not to the driver.
 106       */
 107     SGSoundSample();
 108
 109     /**
 110      * Constructor
 111      * @param path Path name to sound
 112      * @param file File name of sound
 113        should usually be true unless you want to manipulate the data
 114        later.)
 115      */
 116     SGSoundSample( const char *path, const char *file );
 117
 118     /**
 119      * Constructor.
 120      * @param _data Pointer to a memory buffer containing the sample data
 121        the application is responsible for freeing the buffer data.
 122      * @param len Byte length of array
 123      * @param _freq Frequency of the provided data (bytes per second)
 124        should usually be true unless you want to manipulate the data
 125        later.)
 126      */
 127     SGSoundSample( unsigned char *data, int len, int freq, int format = AL_FORMAT_MONO8 );
 128
 129     ~SGSoundSample ();
 130
 131     /**
 132      * detect wheter the sample holds the information of a sound file
 133      */
 134     inline bool is_file() const { return _is_file; }
 135
 136     /**
 137      * Test whether this sample has a changed configuration since the last
 138      * call. (Calling this function resets the value).
 139      */
 140     inline bool has_changed() {
 141         bool b = _changed; _changed = false; return b;
 142     }
 143
 144     inline bool has_static_data_changed() {
 145         bool b = _static_changed; _static_changed = false; return b;
 146     }
 147
 148
 149     /**
 150      * Start playing this sample.
 151      *
 152      * @param _loop Define whether the sound should be played in a loop.
 153      */
 154     inline void play( bool loop ) {
 155         _playing = true; _loop = loop; _changed = true;
 156     }
 157
 158     /**
 159      * Return if the sample is looping or not.
 160      */
 161     inline bool get_looping() { return _loop; }
 162
 163     /**
 164      * Stop playing this sample.
 165      *
 166      * @param sched A pointer to the appropriate scheduler.
 167      */
 168     inline void stop() {
 169         _playing = false; _changed = true;
 170     }
 171
 172     /**
 173      * Play this sample once.
 174      * @see #play
 175      */
 176     inline void play_once() { play(false); }
 177
 178     /**
 179      * Play this sample looped.
 180      * @see #play
 181      */
 182     inline void play_looped() { play(true); }
 183
 184     /**
 185      * Test if a sample is currently playing.
 186      * @return true if is is playing, false otherwise.
 187      */
 188     inline bool is_playing() { return _playing; }
 189
 190     /**
 191      * set the data associated with this sample
 192      */
 193     inline void set_data( unsigned char* data ) {
 194         _data = data;
 195     }
 196
 197     /**
 198      * @return the data associated with this sample
 199      */
 200     inline void* get_data() const { return _data; }
 201
 202     /**
 203      * free the data associated with this sample
 204      */
 205     inline void free_data() {
 206         if (_data != NULL) { delete[] _data; _data = NULL; }
 207     }
 208
 209     /**
 210      * set the source id of this source
 211      */
 212     inline void set_source(unsigned int s) {
 213         _source = s; _valid_source = true; _changed = true;
 214     }
 215
 216     /**
 217      * get the source id of this source
 218      */
 219     inline unsigned int get_source() { return _source; }
 220
 221     /**
 222      * detect wheter the source id of the sample is valid
 223      */
 224     inline bool is_valid_source() const { return _valid_source; }
 225
 226     /**
 227      * set the source id of the sample to invalid.
 228      */
 229     inline void no_valid_source() {
 230         _valid_source = false;
 231     }
 232
 233     /**
 234      * set the buffer id of this source
 235      */
 236     inline void set_buffer(unsigned int b) {
 237         _buffer = b; _valid_buffer = true; _changed = true;
 238     }
 239
 240     /**
 241      * get the buffer id of this source
 242      */
 243     inline unsigned int get_buffer() { return _buffer; }
 244
 245     /**
 246      * detect wheter the source id of the sample is valid
 247      */
 248     inline bool is_valid_buffer() const { return _valid_buffer; }
 249
 250     /**
 251      * set the source id of the sample to invalid.
 252      */
 253     inline void no_valid_buffer() {
 254         _valid_buffer = false;
 255     }
 256
 257     /**
 258      * Get the current pitch setting of this sample.
 259      */
 260     inline float get_pitch() { return _pitch; }
 261
 262     /**
 263      * Set the pitch of this sample.
 264      */
 265     inline void set_pitch( float p ) {
 266         _pitch = p; _changed = true;
 267     }
 268
 269     /**
 270      * Get the current volume setting of this sample.
 271      */
 272     inline float get_volume() { return _volume * _master_volume; }
 273
 274     /**
 275      * Set the master (sampel group) volume of this sample.
 276      */
 277     inline void set_master_volume( float v ) {
 278         _master_volume = v; _changed = true;
 279     }
 280
 281     /**
 282      * Set the volume of this sample.
 283      */
 284     inline void set_volume( float v ) {
 285         _volume = v; _changed = true;
 286     }
 287
 288     /**
 289      * Set the format of the sounds sample
 290      */
 291     inline void set_format( int format ) {
 292         _format = format;
 293     }
 294
 295     /**
 296      * Returns the format of the sounds sample
 297      */
 298     inline int get_format() { return _format; }
 299
 300
 301     /**
 302      * Set the frequency of the sounds sample
 303      */
 304     inline void set_frequency( int freq ) {
 305         _freq = freq; _changed = true;
 306     }
 307
 308     /**
 309      * Returns the frequency of the sounds sample
 310      */
 311     inline int get_frequency() { return _freq; }
 312
 313     /**
 314      * Returns the size of the sounds sample
 315      */
 316     inline void set_size( int size ) {
 317         _size = size;
 318     }
 319
 320     /**
 321      * Returns the size of the sounds sample
 322      */
 323     inline int get_size() const { return _size; }
 324
 325     /**
 326      * Set position of the sound source (uses same coordinate system as opengl)
 327      */
 328     void set_base_position( SGVec3d pos );
 329     void set_relative_position( SGVec3f pos );
 330
 331     /**
 332      * Get position of the sound source (uses same coordinate system as opengl)
 333      */
 334     inline float *get_position() const { return toVec3f(_absolute_pos).data(); }
 335
 336     /**
 337      * Set the orientation of the sound source, both for direction
 338      * and audio cut-off angles.
 339      */
 340     void set_orientation( SGVec3f dir );
 341
 342     /**
 343      * Define the audio cone parameters for directional audio
 344      */
 345     inline void set_audio_cone( float inner, float outer, float gain ) {
 346         _inner_angle = inner;
 347         _outer_angle = outer;
 348         _outer_gain = gain;
 349         _static_changed = true;
 350     }
 351
 352     /**
 353      * Get the orientation of the sound source, the inner or outer angle
 354      * or outer gain.
 355      */
 356     inline float *get_orientation() { return _direction.data(); }
 357     inline float *get_direction() { return _direction.data(); }
 358     inline float get_innerangle() { return _inner_angle; }
 359     inline float get_outerangle() { return _outer_angle; }
 360     inline float get_outergain() { return _outer_gain; }
 361
 362     /**
 363      * Set velocity of the sound source (uses same coordinate system as opengl)
 364      */
 365     inline void set_velocity( SGVec3f vel ) {
 366         _velocity = SGVec3f(vel); _changed = true;
 367     }
 368
 369     /**
 370      * Get velocity of the sound source (uses same coordinate system as opengl)
 371      */
 372     inline float *get_velocity() { return _velocity.data(); }
 373
 374
 375     /**
 376      * Set reference distance of sound (the distance where the gain
 377      * will be half.)
 378      */
 379     inline void set_reference_dist( float dist ) {
 380         _reference_dist = dist; _static_changed = true;
 381     }
 382
 383     /**
 384      * Get reference distance of sound (the distance where the gain
 385      * will be half.)
 386      */
 387     inline float get_reference_dist() { return _reference_dist; }
 388
 389
 390     /**
 391      * Set maximum distance of sound (the distance where the sound is
 392      * no longer audible.
 393      */
 394     void set_max_dist( float dist ) {
 395         _max_dist = dist; _static_changed = true;
 396     }
 397
 398     /**
 399      * Get maximum istance of sound (the distance where the sound is
 400      * no longer audible.
 401      */
 402     inline float get_max_dist() { return _max_dist; }
 403
 404     /**
 405      * Get the name of this sample
 406      */
 407     inline string get_sample_name() { return _sample_name; }
 408 };
 409
 410
 411 #endif // _SG_SAMPLE_HXX
 412
 413