X-Git-Url: https://git.mxchange.org/?a=blobdiff_plain;f=simgear%2Fsound%2Fsoundmgr_openal.cxx;h=b156b8c5230b51601a95f6769ba865fab9c2f67f;hb=199437e8591a6cf55cd30388405999540d227129;hp=534c4430e4cb348c68866c15fcc6a0c0d1e71ab2;hpb=65a880e9fa4b3d9ef7e7e9b234237ff58198ecfd;p=simgear.git diff --git a/simgear/sound/soundmgr_openal.cxx b/simgear/sound/soundmgr_openal.cxx index 534c4430..b156b8c5 100644 --- a/simgear/sound/soundmgr_openal.cxx +++ b/simgear/sound/soundmgr_openal.cxx @@ -18,182 +18,211 @@ // General Public License for more details. // // You should have received a copy of the GNU General Public License -// along with this program; if not, write to the Free Software -// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. +// along with this program; if not, write to the Free Software Foundation, +// Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. // // $Id$ -#include - -#if defined(__APPLE__) -# include -# include -#else -# include -# include +#ifdef HAVE_CONFIG_H +# include #endif -#if defined (__APPLE__) -# ifdef __GNUC__ -# if ( __GNUC__ >= 3 ) && ( __GNUC_MINOR__ >= 3 ) -// # include -inline int (isnan)(double r) { return !(r <= 0 || r >= 0); } -# else - // any C++ header file undefines isinf and isnan - // so this should be included before - // the functions are STILL in libm (libSystem on mac os x) -extern "C" int isnan (double); -extern "C" int isinf (double); -# endif -# else -// inline int (isinf)(double r) { return isinf(r); } -// inline int (isnan)(double r) { return isnan(r); } -# endif +#if defined( __APPLE__ ) +# include +#else +# include #endif -#if defined (__FreeBSD__) -# if __FreeBSD_version < 500000 - extern "C" { - inline int isnan(double r) { return !(r <= 0 || r >= 0); } - } -# endif -#endif +#include -#include STL_IOSTREAM +#include "soundmgr_openal.hxx" +#include #include #include +#include -#include "soundmgr_openal.hxx" -#if defined(__MINGW32__) -#define isnan(x) _isnan(x) -#endif +#define MAX_SOURCES 128 // // Sound Manager // +int SGSoundMgr::_alut_init = 0; + // constructor -SGSoundMgr::SGSoundMgr() { +SGSoundMgr::SGSoundMgr() : + _working(false), + _changed(true), + _volume(0.0), + _device(NULL), + _context(NULL), + _listener_pos(SGVec3d::zeros().data()), + _listener_vel(SGVec3f::zeros().data()), + _devname(NULL) +{ +#if defined(ALUT_API_MAJOR_VERSION) && ALUT_API_MAJOR_VERSION >= 1 + if (_alut_init == 0) { + if ( !alutInitWithoutContext(NULL, NULL) ) { + testForALUTError("alut initialization"); + return; + } + _alut_init++; + } + _alut_init++; +#endif +} - SG_LOG( SG_GENERAL, SG_INFO, "Initializing OpenAL sound manager" ); +// destructor - // initialize OpenAL +SGSoundMgr::~SGSoundMgr() { + stop(); #if defined(ALUT_API_MAJOR_VERSION) && ALUT_API_MAJOR_VERSION >= 1 - if (!alutInit(NULL, NULL)) - { - ALenum error = alutGetError (); - SG_LOG( SG_GENERAL, SG_ALERT, "Audio initialization failed!" ); - SG_LOG( SG_GENERAL, SG_ALERT, " "+string(alutGetErrorString(error))); - working = false; - } - context = alcGetCurrentContext(); -#else - if ( (dev = alcOpenDevice( NULL )) != NULL - && ( context = alcCreateContext( dev, NULL )) != NULL ) { - working = true; - alcMakeContextCurrent( context ); - } else { - working = false; - context = 0; - SG_LOG( SG_GENERAL, SG_ALERT, "Audio initialization failed!" ); + _alut_init--; + if (_alut_init == 0) { + alutExit (); } #endif +} + +// initialize the sound manager +void SGSoundMgr::init() { - listener_pos[0] = 0.0; - listener_pos[1] = 0.0; - listener_pos[2] = 0.0; - - listener_vel[0] = 0.0; - listener_vel[1] = 0.0; - listener_vel[2] = 0.0; - - listener_ori[0] = 0.0; - listener_ori[1] = 0.0; - listener_ori[2] = -1.0; - listener_ori[3] = 0.0; - listener_ori[4] = 1.0; - listener_ori[5] = 0.0; - - alListenerf( AL_GAIN, 0.0f ); - alListenerfv( AL_POSITION, listener_pos ); - alListenerfv( AL_VELOCITY, listener_vel ); - alListenerfv( AL_ORIENTATION, listener_ori ); - alGetError(); - if ( alGetError() != AL_NO_ERROR) { - SG_LOG( SG_GENERAL, SG_ALERT, - "Oops AL error after audio initialization!" ); + SG_LOG( SG_GENERAL, SG_INFO, "Initializing OpenAL sound manager" ); + + ALCdevice *device = alcOpenDevice(_devname); + if ( testForError(device, "No default audio device available.") ) { + return; + } + + ALCcontext *context = alcCreateContext(device, NULL); + if ( testForError(context, "Unable to create a valid context.") ) { + return; } - // exaggerate the ear candy? + if ( !alcMakeContextCurrent(context) ) { + testForALCError("context initialization"); + return; + } + + _context = context; + _working = true; + + _listener_ori[0] = 0.0; _listener_ori[1] = 0.0; _listener_ori[2] = -1.0; + _listener_ori[3] = 0.0; _listener_ori[4] = 1.0; _listener_ori[5] = 0.0; + + alListenerf( AL_GAIN, 0.2f ); + alListenerfv( AL_POSITION, toVec3f(_listener_pos).data() ); + alListenerfv( AL_ORIENTATION, _listener_ori ); + alListenerfv( AL_VELOCITY, _listener_vel.data() ); + alDopplerFactor(1.0); - alDopplerVelocity(340.0); // speed of sound in meters per second. -} + alDopplerVelocity(340.3); // speed of sound in meters per second. -// destructor + if ( alIsExtensionPresent((const ALchar*)"EXT_exponent_distance") ) { + alDistanceModel(AL_EXPONENT_DISTANCE); + } else { + alDistanceModel(AL_INVERSE_DISTANCE); + } -SGSoundMgr::~SGSoundMgr() { + testForALError("listener initialization"); -#if defined(ALUT_API_MAJOR_VERSION) && ALUT_API_MAJOR_VERSION >= 1 - alutExit (); -#else - if (context) - alcDestroyContext( context ); -#endif - // - // Remove the samples from the sample manager. - // - sample_map_iterator sample_current = samples.begin(); - sample_map_iterator sample_end = samples.end(); - for ( ; sample_current != sample_end; ++sample_current ) { - SGSoundSample *sample = sample_current->second; - delete sample; + alGetError(); // clear any undetetced error, just to be sure + + // get a free source one at a time + // if an error is returned no more (hardware) sources are available + for (unsigned int i=0; isecond; - delete sample; + _context = alcGetCurrentContext(); + _device = alcGetContextsDevice(_context); + alcMakeContextCurrent(NULL); + alcDestroyContext(_context); + alcCloseDevice(_device); + } +} + +void SGSoundMgr::suspend() { + if (_working) { + sample_group_map_iterator sample_grp_current = _sample_groups.begin(); + sample_group_map_iterator sample_grp_end = _sample_groups.end(); + for ( ; sample_grp_current != sample_grp_end; ++sample_grp_current ) { + SGSampleGroup *sgrp = sample_grp_current->second; + sgrp->suspend(); + } } - samples.clear(); } void SGSoundMgr::bind () { - // no properties + _free_sources.clear(); + _free_sources.reserve( MAX_SOURCES ); + _sources_in_use.clear(); + _sources_in_use.reserve( MAX_SOURCES ); } void SGSoundMgr::unbind () { - // no properties -} + _sample_groups.clear(); + // delete free sources + for (unsigned int i=0; i<_free_sources.size(); i++) { + ALuint source = _free_sources.at( i ); + alDeleteSources( 1 , &source ); + } -// run the audio scheduler -void SGSoundMgr::update( double dt ) { + _free_sources.clear(); + _sources_in_use.clear(); } - -void -SGSoundMgr::pause () +void SGSoundMgr::update( double dt ) { - if (context) { - alcSuspendContext( context ); - if ( alGetError() != AL_NO_ERROR) { - SG_LOG( SG_GENERAL, SG_ALERT, - "Oops AL error after soundmgr pause()!" ); + // nothing to do in the regular update,e verything is done on the following + // function +} + + +// run the audio scheduler +void SGSoundMgr::update_late( double dt ) { + if (_working) { + // alcSuspendContext(_context); + + sample_group_map_iterator sample_grp_current = _sample_groups.begin(); + sample_group_map_iterator sample_grp_end = _sample_groups.end(); + for ( ; sample_grp_current != sample_grp_end; ++sample_grp_current ) { + SGSampleGroup *sgrp = sample_grp_current->second; + sgrp->update(dt); + } + + if (_changed) { + alListenerf( AL_GAIN, _volume ); + alListenerfv( AL_VELOCITY, _listener_vel.data() ); + alListenerfv( AL_ORIENTATION, _listener_ori ); + alListenerfv( AL_POSITION, toVec3f(_listener_pos).data() ); + // alDopplerVelocity(340.3); // TODO: altitude dependent + testForALError("update"); + _changed = false; } + // alcProcessContext(_context); } } @@ -201,153 +230,243 @@ SGSoundMgr::pause () void SGSoundMgr::resume () { - if (context) { - alcProcessContext( context ); - if ( alGetError() != AL_NO_ERROR) { - SG_LOG( SG_GENERAL, SG_ALERT, - "Oops AL error after soundmgr resume()!" ); + if (_working) { + sample_group_map_iterator sample_grp_current = _sample_groups.begin(); + sample_group_map_iterator sample_grp_end = _sample_groups.end(); + for ( ; sample_grp_current != sample_grp_end; ++sample_grp_current ) { + SGSampleGroup *sgrp = sample_grp_current->second; + sgrp->resume(); } } } -// add a sound effect, return true if successful -bool SGSoundMgr::add( SGSoundSample *sound, const string& refname ) { - - sample_map_iterator sample_it = samples.find( refname ); - if ( sample_it != samples.end() ) { - // sound already exists +// add a sampel group, return true if successful +bool SGSoundMgr::add( SGSampleGroup *sgrp, const string& refname ) +{ + sample_group_map_iterator sample_grp_it = _sample_groups.find( refname ); + if ( sample_grp_it != _sample_groups.end() ) { + // sample group already exists return false; } - samples[refname] = sound; + _sample_groups[refname] = sgrp; return true; } // remove a sound effect, return true if successful -bool SGSoundMgr::remove( const string &refname ) { - - sample_map_iterator sample_it = samples.find( refname ); - if ( sample_it != samples.end() ) { - // first stop the sound from playing (so we don't bomb the - // audio scheduler) - SGSoundSample *sample = sample_it->second; - delete sample; - samples.erase( sample_it ); - - // cout << "sndmgr: removed -> " << refname << endl; - return true; - } else { - // cout << "sndmgr: failed remove -> " << refname << endl; +bool SGSoundMgr::remove( const string &refname ) +{ + sample_group_map_iterator sample_grp_it = _sample_groups.find( refname ); + if ( sample_grp_it == _sample_groups.end() ) { + // sample group was not found. return false; } + + _sample_groups.erase( refname ); + + return true; } // return true of the specified sound exists in the sound manager system bool SGSoundMgr::exists( const string &refname ) { - sample_map_iterator sample_it = samples.find( refname ); - if ( sample_it != samples.end() ) { - return true; - } else { - return false; + sample_group_map_iterator sample_grp_it = _sample_groups.find( refname ); + if ( sample_grp_it == _sample_groups.end() ) { + // sample group was not found. + return false; } + + return true; } -// return a pointer to the SGSoundSample if the specified sound exists +// return a pointer to the SGSampleGroup if the specified sound exists // in the sound manager system, otherwise return NULL -SGSoundSample *SGSoundMgr::find( const string &refname ) { - sample_map_iterator sample_it = samples.find( refname ); - if ( sample_it != samples.end() ) { - return sample_it->second; - } else { - return NULL; +SGSampleGroup *SGSoundMgr::find( const string &refname, bool create ) { + sample_group_map_iterator sample_grp_it = _sample_groups.find( refname ); + if ( sample_grp_it == _sample_groups.end() ) { + // sample group was not found. + if (create) { + SGSampleGroup* sgrp = new SGSampleGroup(this, refname); + return sgrp; + } + else + return NULL; } -} + return sample_grp_it->second; +} -// tell the scheduler to play the indexed sample in a continuous -// loop -bool SGSoundMgr::play_looped( const string &refname ) { - SGSoundSample *sample; - if ( (sample = find( refname )) == NULL ) { - return false; - } else { - sample->play( true ); - return true; - } +void SGSoundMgr::set_volume( float v ) +{ + _volume = v; + if (_volume > 1.0) _volume = 1.0; + if (_volume < 0.0) _volume = 0.0; + _changed = true; } +// Get an unused source id +// +// The Sound Manager should keep track of the sources in use, the distance +// of these sources to the listener and the volume (also based on audio cone +// and hence orientation) of the sources. +// +// The Sound Manager is (and should be) the only one knowing about source +// management. Sources further away should be suspendped to free resources for +// newly added sounds close by. +unsigned int SGSoundMgr::request_source() +{ + unsigned int source = NO_SOURCE; -// tell the scheduler to play the indexed sample once -bool SGSoundMgr::play_once( const string& refname ) { - SGSoundSample *sample; + if (_free_sources.size() > 0) { + source = _free_sources.back(); + _free_sources.pop_back(); - if ( (sample = find( refname )) == NULL ) { - return false; - } else { - sample->play( false ); - return true; + _sources_in_use.push_back(source); } -} + return source; +} -// return true of the specified sound is currently being played -bool SGSoundMgr::is_playing( const string& refname ) { - SGSoundSample *sample; - - if ( (sample = find( refname )) == NULL ) { - return false; - } else { - return ( sample->is_playing() ); +// Free up a source id for further use +void SGSoundMgr::release_source( unsigned int source ) +{ + for (unsigned int i = 0; i<_sources_in_use.size(); i++) { + if ( _sources_in_use[i] == source ) { + ALint result; + + alGetSourcei( source, AL_SOURCE_STATE, &result ); + if ( result == AL_PLAYING ) { + alSourceStop( source ); + } + testForALError("release source"); + + _free_sources.push_back(source); + _sources_in_use.erase(_sources_in_use.begin()+i, + _sources_in_use.begin()+i+1); + break; + } } } +bool SGSoundMgr::load(string &samplepath, void **dbuf, int *fmt, + unsigned int *sz, int *frq ) +{ + ALenum format = (ALenum)*fmt; + ALsizei size = (ALsizei)*sz; + ALsizei freq = (ALsizei)*frq; + ALvoid *data; -// immediate stop playing the sound -bool SGSoundMgr::stop( const string& refname ) { - SGSoundSample *sample; +#if defined(ALUT_API_MAJOR_VERSION) && ALUT_API_MAJOR_VERSION >= 1 + ALfloat freqf; + data = alutLoadMemoryFromFile(samplepath.c_str(), &format, &size, &freqf ); + freq = (ALsizei)freqf; + if (data == NULL) { + int error = alutGetError(); + string msg = "Failed to load wav file: "; + msg.append(alutGetErrorString(error)); + throw sg_io_exception(msg.c_str(), sg_location(samplepath)); + return false; + } - if ( (sample = find( refname )) == NULL ) { +#else + ALbyte *fname = (ALbyte *)samplepath.c_str(); +# if defined (__APPLE__) + alutLoadWAVFile( fname, &format, &data, &size, &freq ); +# else + ALboolean loop; + alutLoadWAVFile( fname, &format, &data, &size, &freq, &loop ); +# endif + ALenum error = alutGetError(); + if ( error != ALUT_ERROR_NO_ERROR ) { + string msg = "Failed to load wav file: "; + msg.append(alutGetErrorString(error)); + throw sg_io_exception(msg.c_str(), sg_location(samplepath)); return false; - } else { - sample->stop(); - return true; } +#endif + + *dbuf = (void *)data; + *fmt = (int)format; + *sz = (unsigned int)size; + *frq = (int)freq; + + return true; } -// set source position of all managed sounds -void SGSoundMgr::set_source_pos_all( ALfloat *pos ) { - if ( isnan(pos[0]) || isnan(pos[1]) || isnan(pos[2]) ) { - // bail if a bad position is passed in - return; +/** + * set the orientation of the listener (in opengl coordinates) + * + * Description: ORIENTATION is a pair of 3-tuples representing the + * 'at' direction vector and 'up' direction of the Object in + * Cartesian space. AL expects two vectors that are orthogonal to + * each other. These vectors are not expected to be normalized. If + * one or more vectors have zero length, implementation behavior + * is undefined. If the two vectors are linearly dependent, + * behavior is undefined. + */ +void SGSoundMgr::set_orientation( SGQuatd ori ) +{ + SGVec3d sgv_up = ori.rotate(SGVec3d::e3()); + SGVec3d sgv_at = ori.rotate(SGVec3d::e2()); + for (int i=0; i<3; i++) { + _listener_ori[i] = sgv_at[i]; + _listener_ori[i+3] = sgv_up[i]; } + _changed = true; +} - sample_map_iterator sample_current = samples.begin(); - sample_map_iterator sample_end = samples.end(); - for ( ; sample_current != sample_end; ++sample_current ) { - SGSoundSample *sample = sample_current->second; - sample->set_source_pos( pos ); - } + +bool SGSoundMgr::testForError(void *p, string s) +{ + if (p == NULL) { + SG_LOG( SG_GENERAL, SG_ALERT, "Error: " << s); + return true; + } + return false; } -// set source velocity of all managed sounds -void SGSoundMgr::set_source_vel_all( ALfloat *vel ) { - if ( isnan(vel[0]) || isnan(vel[1]) || isnan(vel[2]) ) { - // bail if a bad velocity is passed in - return; +bool SGSoundMgr::testForALError(string s) +{ + ALenum error = alGetError(); + if (error != AL_NO_ERROR) { + SG_LOG( SG_GENERAL, SG_ALERT, "AL Error (sound manager): " + << alGetString(error) << " at " << s); + return true; } + return false; +} - sample_map_iterator sample_current = samples.begin(); - sample_map_iterator sample_end = samples.end(); - for ( ; sample_current != sample_end; ++sample_current ) { - SGSoundSample *sample = sample_current->second; - sample->set_source_vel( vel ); +bool SGSoundMgr::testForALCError(string s) +{ + ALCenum error; + error = alcGetError(_device); + if (error != ALC_NO_ERROR) { + SG_LOG( SG_GENERAL, SG_ALERT, "ALC Error (sound manager): " + << alcGetString(_device, error) << " at " + << s); + return true; } + return false; +} + +bool SGSoundMgr::testForALUTError(string s) +{ +#if defined(ALUT_API_MAJOR_VERSION) && ALUT_API_MAJOR_VERSION >= 1 + ALenum error; + error = alutGetError (); + if (error != ALUT_ERROR_NO_ERROR) { + SG_LOG( SG_GENERAL, SG_ALERT, "ALUT Error (sound manager): " + << alutGetErrorString(error) << " at " + << s); + return true; + } +#endif + return false; }