X-Git-Url: https://git.mxchange.org/?a=blobdiff_plain;f=simgear%2Fsound%2Fsoundmgr_openal.cxx;h=ea5e44db0f4c69100b24ceb8a4a8ca9bb47f3f0a;hb=1fe9755d01b9b0c06e8cfd05272e17a3ce0f1bf3;hp=9bc3e2a098fb84f6cdbcbea25936896a0eaca48f;hpb=bcccd06cee0d2372df5b2d40cb4473d3156f3668;p=simgear.git

diff --git a/simgear/sound/soundmgr_openal.cxx b/simgear/sound/soundmgr_openal.cxx
index 9bc3e2a0..ea5e44db 100644
--- a/simgear/sound/soundmgr_openal.cxx
+++ b/simgear/sound/soundmgr_openal.cxx
@@ -4,8 +4,10 @@
 // <david_j_findlay@yahoo.com.au> 2001
 //
 // C++-ified by Curtis Olson, started March 2001.
+// Modified for the new SoundSystem by Erik Hofman, October 2009
 //
 // Copyright (C) 2001  Curtis L. Olson - http://www.flightgear.org/~curt
+// Copyright (C) 2009 Erik Hofman <erik@ehofman.com>
 //
 // This program is free software; you can redistribute it and/or
 // modify it under the terms of the GNU General Public License as
@@ -34,6 +36,7 @@
 #endif
 
 #include <iostream>
+#include <algorithm>
 
 #include "soundmgr_openal.hxx"
 
@@ -42,6 +45,7 @@
 #include <simgear/misc/sg_path.hxx>
 #include <simgear/math/SGMath.hxx>
 
+extern bool isNaN(float *v);
 
 #define MAX_SOURCES	128
 
@@ -54,13 +58,18 @@ int SGSoundMgr::_alut_init = 0;
 // constructor
 SGSoundMgr::SGSoundMgr() :
     _working(false),
+    _active(false),
     _changed(true),
     _volume(0.0),
     _device(NULL),
     _context(NULL),
-    _listener_pos(SGVec3d::zeros().data()),
-    _listener_vel(SGVec3f::zeros().data()),
-    _devname(NULL)
+    _absolute_pos(SGVec3d::zeros()),
+    _offset_pos(SGVec3d::zeros()),
+    _base_pos(SGVec3d::zeros()),
+    _geod_pos(SGGeod::fromCart(SGVec3d::zeros())),
+    _velocity(SGVec3d::zeros()),
+    _orientation(SGQuatd::zeros()),
+    _bad_doppler(false)
 {
 #if defined(ALUT_API_MAJOR_VERSION) && ALUT_API_MAJOR_VERSION >= 1
     if (_alut_init == 0) {
@@ -68,7 +77,6 @@ SGSoundMgr::SGSoundMgr() :
             testForALUTError("alut initialization");
             return;
         }
-        _alut_init++;
     }
     _alut_init++;
 #endif
@@ -77,6 +85,7 @@ SGSoundMgr::SGSoundMgr() :
 // destructor
 
 SGSoundMgr::~SGSoundMgr() {
+
     stop();
 #if defined(ALUT_API_MAJOR_VERSION) && ALUT_API_MAJOR_VERSION >= 1
     _alut_init--;
@@ -87,49 +96,53 @@ SGSoundMgr::~SGSoundMgr() {
 }
 
 // initialize the sound manager
-void SGSoundMgr::init() {
+void SGSoundMgr::init(const char *devname) {
 
     SG_LOG( SG_GENERAL, SG_INFO, "Initializing OpenAL sound manager" );
 
-    ALCdevice *device = alcOpenDevice(_devname);
-    if ( testForError(device, "No default audio device available.") ) {
-        return;
+    ALCdevice *device = alcOpenDevice(devname);
+    if ( testForError(device, "Audio device not available, trying default") ) {
+        device = alcOpenDevice(NULL);
+        if (testForError(device, "Default Audio device not available.") ) {
+           return;
+        }
     }
 
     ALCcontext *context = alcCreateContext(device, NULL);
     if ( testForError(context, "Unable to create a valid context.") ) {
+        alcCloseDevice (device);
         return;
     }
 
     if ( !alcMakeContextCurrent(context) ) {
         testForALCError("context initialization");
+        alcDestroyContext (context);
+        alcCloseDevice (device);
         return;
     }
 
+    if (_context != NULL)
+        SG_LOG(SG_GENERAL, SG_ALERT, "context is already assigned");
     _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;
+    _at_up_vec[0] = 0.0; _at_up_vec[1] = 0.0; _at_up_vec[2] = -1.0;
+    _at_up_vec[3] = 0.0; _at_up_vec[4] = 1.0; _at_up_vec[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() );
+    alListenerf( AL_GAIN, 0.0f );
+    alListenerfv( AL_ORIENTATION, _at_up_vec );
+    alListenerfv( AL_POSITION, SGVec3f::zeros().data() );
+    alListenerfv( AL_VELOCITY, SGVec3f::zeros().data() );
 
     alDopplerFactor(1.0);
     alDopplerVelocity(340.3);   // speed of sound in meters per second.
 
-    if ( alIsExtensionPresent((const ALchar*)"EXT_exponent_distance") ) {
-        alDistanceModel(AL_EXPONENT_DISTANCE);
-    } else {
-        alDistanceModel(AL_INVERSE_DISTANCE);
-    }
+    // gain = AL_REFERENCE_DISTANCE / (AL_REFERENCE_DISTANCE +
+    //        AL_ROLLOFF_FACTOR * (distance - AL_REFERENCE_DISTANCE));
+    alDistanceModel(AL_INVERSE_DISTANCE_CLAMPED);
 
     testForALError("listener initialization");
 
-    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; i<MAX_SOURCES; i++) {
@@ -144,18 +157,69 @@ void SGSoundMgr::init() {
         }
         else break;
     }
+
+    string vendor = alGetString(AL_VENDOR);
+    string renderer = alGetString(AL_RENDERER);
+    if ( vendor != "OpenAL Community" ||
+         (renderer != "Software" && renderer != "OpenAL Sample Implementation")
+       )
+    {
+       _bad_doppler = true;
+    }
+
+    if (_free_sources.size() == 0) {
+        SG_LOG(SG_GENERAL, SG_ALERT, "Unable to grab any OpenAL sources!");
+    }
 }
 
-// suspend the sound manager
+void SGSoundMgr::activate() {
+    if ( _working ) {
+        _active = true;
+        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->activate();
+        }
+    }
+}
+
+// stop the sound manager
 void SGSoundMgr::stop() {
+
+    // first stop all sample groups
+    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->stop();
+    }
+
+    // clear all OpenAL sources
+    for (unsigned int i=0; i<_free_sources.size(); i++) {
+        ALuint source = _free_sources[i];
+        alDeleteSources( 1 , &source );
+    }
+    _free_sources.clear();
+
+    // clear any OpenAL buffers before shutting down
+    buffer_map_iterator buffers_current = _buffers.begin();
+    buffer_map_iterator buffers_end = _buffers.end();
+    for ( ; buffers_current != buffers_end; ++buffers_current ) {
+        refUint ref = buffers_current->second;
+        ALuint buffer = ref.id;
+        alDeleteBuffers(1, &buffer);
+    }
+    _buffers.clear();
+
     if (_working) {
         _working = false;
-
+        _active = false;
         _context = alcGetCurrentContext();
         _device = alcGetContextsDevice(_context);
-        alcMakeContextCurrent(NULL);
         alcDestroyContext(_context);
         alcCloseDevice(_device);
+        _context = NULL;
     }
 }
 
@@ -165,11 +229,23 @@ void SGSoundMgr::suspend() {
         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();
+            sgrp->stop();
         }
+        _active = false;
     }
 }
 
+void SGSoundMgr::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();
+        }
+        _active = true;
+    }
+}
 
 void SGSoundMgr::bind ()
 {
@@ -186,7 +262,7 @@ void SGSoundMgr::unbind ()
 
     // delete free sources
     for (unsigned int i=0; i<_free_sources.size(); i++) {
-        ALuint source = _free_sources.at( i );
+        ALuint source = _free_sources[i];
         alDeleteSources( 1 , &source );
     }
 
@@ -194,17 +270,14 @@ void SGSoundMgr::unbind ()
     _sources_in_use.clear();
 }
 
-void SGSoundMgr::update( double dt )
-{
-    // 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);
+void SGSoundMgr::update( double dt ) {
+    if (_active) {
+        alcSuspendContext(_context);
+
+        if (_changed) {
+            update_pos_and_orientation();
+        }
 
         sample_group_map_iterator sample_grp_current = _sample_groups.begin();
         sample_group_map_iterator sample_grp_end = _sample_groups.end();
@@ -214,34 +287,36 @@ void SGSoundMgr::update_late( double dt ) {
         }
 
         if (_changed) {
+#if 0
+if (isNaN(_at_up_vec)) printf("NaN in listener orientation\n");
+if (isNaN(toVec3f(_absolute_pos).data())) printf("NaN in listener position\n");
+if (isNaN(_velocity.data())) printf("NaN in listener velocity\n");
+#endif
             alListenerf( AL_GAIN, _volume );
-            alListenerfv( AL_VELOCITY, _listener_vel.data() );
-            alListenerfv( AL_ORIENTATION, _listener_ori );
-            alListenerfv( AL_POSITION, toVec3f(_listener_pos).data() );
+            alListenerfv( AL_ORIENTATION, _at_up_vec );
+            // alListenerfv( AL_POSITION, toVec3f(_absolute_pos).data() );
+
+            SGQuatd hlOr = SGQuatd::fromLonLat( _geod_pos );
+            SGVec3d velocity = SGVec3d::zeros();
+            if ( _velocity[0] || _velocity[1] || _velocity[2] ) {
+                velocity = hlOr.backTransform(_velocity*SG_FEET_TO_METER);
+            }
+
+            if ( _bad_doppler ) {
+                velocity *= 100.0f;
+            }
+
+            alListenerfv( AL_VELOCITY, toVec3f(velocity).data() );
             // alDopplerVelocity(340.3);	// TODO: altitude dependent
             testForALError("update");
             _changed = false;
         }
-        // alcProcessContext(_context);
-    }
-}
-
 
-void
-SGSoundMgr::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();
-        }
+        alcProcessContext(_context);
     }
 }
 
-
-// add a sampel group, return true if successful
+// add a sample group, return true if successful
 bool SGSoundMgr::add( SGSampleGroup *sgrp, const string& refname )
 {
     sample_group_map_iterator sample_grp_it = _sample_groups.find( refname );
@@ -250,6 +325,7 @@ bool SGSoundMgr::add( SGSampleGroup *sgrp, const string& refname )
         return false;
     }
 
+    if (_active) sgrp->activate();
     _sample_groups[refname] = sgrp;
 
     return true;
@@ -265,7 +341,7 @@ bool SGSoundMgr::remove( const string &refname )
         return false;
     }
 
-    _sample_groups.erase( refname );
+    _sample_groups.erase( sample_grp_it );
 
     return true;
 }
@@ -291,6 +367,7 @@ SGSampleGroup *SGSoundMgr::find( const string &refname, bool create ) {
         // sample group was not found.
         if (create) {
             SGSampleGroup* sgrp = new SGSampleGroup(this, refname);
+            add( sgrp, refname );
             return sgrp;
         }
         else 
@@ -325,9 +402,10 @@ unsigned int SGSoundMgr::request_source()
     if (_free_sources.size() > 0) {
        source = _free_sources.back();
        _free_sources.pop_back();
-
        _sources_in_use.push_back(source);
     }
+    else
+       SG_LOG( SG_GENERAL, SG_INFO, "No more free sources available\n");
 
     return source;
 }
@@ -335,30 +413,136 @@ unsigned int SGSoundMgr::request_source()
 // 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;
+    vector<ALuint>::iterator it;
 
-            alGetSourcei( source, AL_SOURCE_STATE, &result );
-            if ( result == AL_PLAYING ) {
-                alSourceStop( source );
-            }
-            testForALError("release source");
+    it = std::find(_sources_in_use.begin(), _sources_in_use.end(), source);
+    if ( it != _sources_in_use.end() ) {
+        ALint result;
+
+        alGetSourcei( source, AL_SOURCE_STATE, &result );
+        if ( result == AL_PLAYING )
+            alSourceStop( source );
+        testForALError("release source");
+
+        alSourcei( source, AL_BUFFER, 0 );
+        _free_sources.push_back( source );
+        _sources_in_use.erase( it );
+    }
+}
+
+unsigned int SGSoundMgr::request_buffer(SGSoundSample *sample)
+{
+    ALuint buffer = NO_BUFFER;
+
+    if ( !sample->is_valid_buffer() ) {
+        // sample was not yet loaded or removed again
+        string sample_name = sample->get_sample_name();
+        void *sample_data = NULL;
+
+        // see if the sample name is already cached
+        buffer_map_iterator buffer_it = _buffers.find( sample_name );
+        if ( buffer_it != _buffers.end() ) {
+            buffer_it->second.refctr++;
+            buffer = buffer_it->second.id;
+            sample->set_buffer( buffer );
+            return buffer;
+        }
+
+        // sample name was not found in the buffer cache.
+        if ( sample->is_file() ) {
+            int freq, format;
+            size_t size;
+            bool res;
+
+            res = load(sample_name, &sample_data, &format, &size, &freq);
+            if (res == false) return buffer;
+
+            sample->set_frequency( freq );
+            sample->set_format( format );
+            sample->set_size( size );
+        }
+        else
+            sample_data = sample->get_data();
+
+        // create an OpenAL buffer handle
+        alGenBuffers(1, &buffer);
+        if ( !testForALError("generate buffer") ) {
+            // Copy data to the internal OpenAL buffer
+
+            ALenum format = sample->get_format();
+            ALsizei size = sample->get_size();
+            ALsizei freq = sample->get_frequency();
+            alBufferData( buffer, format, sample_data, size, freq );
 
-            _free_sources.push_back(source);
-            _sources_in_use.erase(_sources_in_use.begin()+i,
-                                  _sources_in_use.begin()+i+1);
-            break;
+            if ( sample->is_file() ) free(sample_data);
+
+            if ( !testForALError("buffer add data") ) {
+                sample->set_buffer(buffer);
+                _buffers[sample_name] = refUint(buffer);
+            }
         }
     }
+    else {
+        buffer = sample->get_buffer();
+}
+
+    return buffer;
+}
+
+void SGSoundMgr::release_buffer(SGSoundSample *sample)
+{
+    string sample_name = sample->get_sample_name();
+    buffer_map_iterator buffer_it = _buffers.find( sample_name );
+    if ( buffer_it == _buffers.end() ) {
+        // buffer was not found
+        return;
+    }
+
+    sample->no_valid_buffer();
+    buffer_it->second.refctr--;
+    if (buffer_it->second.refctr == 0) {
+        ALuint buffer = buffer_it->second.id;
+        alDeleteBuffers(1, &buffer);
+        _buffers.erase( buffer_it );
+        testForALError("release buffer");
+    }
+}
+
+void SGSoundMgr::update_pos_and_orientation() {
+    /**
+     * 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.
+     *
+     * This is in the same coordinate system as OpenGL; y=up, z=back, x=right.
+     */
+    SGVec3d sgv_at = _orientation.backTransform(-SGVec3d::e3());
+    SGVec3d sgv_up = _orientation.backTransform(SGVec3d::e2());
+    _at_up_vec[0] = sgv_at[0];
+    _at_up_vec[1] = sgv_at[1];
+    _at_up_vec[2] = sgv_at[2];
+    _at_up_vec[3] = sgv_up[0];
+    _at_up_vec[4] = sgv_up[1];
+    _at_up_vec[5] = sgv_up[2];
+
+    // static const SGQuatd q(-0.5, -0.5, 0.5, 0.5);
+    // SGQuatd hlOr = SGQuatd::fromLonLat(SGGeod::fromCart(_base_pos));
+    // SGQuatd ec2body = hlOr*_orientation;
+    _absolute_pos = _base_pos; // + ec2body.backTransform( _offset_pos );
 }
 
 bool SGSoundMgr::load(string &samplepath, void **dbuf, int *fmt,
-                                          unsigned int *sz, int *frq )
+                                          size_t *sz, int *frq )
 {
-    ALenum format = (ALenum)*fmt;
-    ALsizei size = (ALsizei)*sz;
-    ALsizei freq = (ALsizei)*frq;
+    if ( !_working ) return false;
+
+    ALenum format;
+    ALsizei size;
+    ALsizei freq;
     ALvoid *data;
 
 #if defined(ALUT_API_MAJOR_VERSION) && ALUT_API_MAJOR_VERSION >= 1
@@ -381,10 +565,10 @@ bool SGSoundMgr::load(string &samplepath, void **dbuf, int *fmt,
     ALboolean loop;
     alutLoadWAVFile( fname, &format, &data, &size, &freq, &loop );
 # endif
-    ALenum error =  alutGetError();
-    if ( error != ALUT_ERROR_NO_ERROR ) {
+    ALenum error =  alGetError();
+    if ( error != AL_NO_ERROR ) {
         string msg = "Failed to load wav file: ";
-        msg.append(alutGetErrorString(error));
+        msg.append(alGetString(error));
         throw sg_io_exception(msg.c_str(), sg_location(samplepath));
         return false;
     }
@@ -392,33 +576,36 @@ bool SGSoundMgr::load(string &samplepath, void **dbuf, int *fmt,
 
     *dbuf = (void *)data;
     *fmt = (int)format;
-    *sz = (unsigned int)size;
+    *sz = (size_t)size;
     *frq = (int)freq;
 
     return true;
 }
 
-
-/**
- * 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 )
+vector<const char*> SGSoundMgr::get_available_devices()
 {
-    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];
+    vector<const char*> devices;
+    const ALCchar *s;
+
+    if (alcIsExtensionPresent(NULL, "ALC_enumerate_all_EXT") == AL_TRUE) {
+        s = alcGetString(NULL, ALC_ALL_DEVICES_SPECIFIER);
+    } else {
+        s = alcGetString(NULL, ALC_DEVICE_SPECIFIER);
     }
-    _changed = true;
+
+    if (s) {
+        ALCchar *nptr, *ptr = (ALCchar *)s;
+
+        nptr = ptr;
+        while (*(nptr += strlen(ptr)+1) != 0)
+        {
+            devices.push_back(ptr);
+            ptr = nptr;
+        }
+        devices.push_back(ptr);
+    }
+
+    return devices;
 }
 
 
@@ -458,6 +645,7 @@ bool SGSoundMgr::testForALCError(string s)
 
 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) {
@@ -466,5 +654,6 @@ bool SGSoundMgr::testForALUTError(string s)
                                        << s);
         return true;
     }
+#endif
     return false;
 }