X-Git-Url: https://git.mxchange.org/?a=blobdiff_plain;f=simgear%2Fsound%2Fsoundmgr_openal.cxx;h=24992a742560f894d36397c8cb8f58ac0b2f7fdc;hb=493aab8bab9df7d4ff13db3135703a899d0255c4;hp=47b437487e0a6899f687afdf3c3fc2f9e473813e;hpb=4950c96f1ce4888aac4382905201e35314b0ae83;p=simgear.git

diff --git a/simgear/sound/soundmgr_openal.cxx b/simgear/sound/soundmgr_openal.cxx
index 47b43748..24992a74 100644
--- a/simgear/sound/soundmgr_openal.cxx
+++ b/simgear/sound/soundmgr_openal.cxx
@@ -29,88 +29,159 @@
 #  include <simgear_config.h>
 #endif
 
-#if defined( __APPLE__ )
-# include <OpenAL/alut.h>
-#else
-# include <AL/alut.h>
-#endif
-
 #include <iostream>
 #include <algorithm>
+#include <cstring>
+
+#include <boost/foreach.hpp>
 
 #include "soundmgr_openal.hxx"
+#include "readwav.hxx"
+#include "soundmgr_openal_private.hxx"
+#include "sample_group.hxx"
 
+#include <simgear/sg_inlines.h>
 #include <simgear/structure/exception.hxx>
 #include <simgear/debug/logstream.hxx>
 #include <simgear/misc/sg_path.hxx>
-#include <simgear/math/SGMath.hxx>
 
-extern bool isNaN(float *v);
+using std::vector;
+
 
 #define MAX_SOURCES	128
 
+
+#ifndef ALC_ALL_DEVICES_SPECIFIER
+# define ALC_ALL_DEVICES_SPECIFIER	0x1013
+#endif
+
+class SGSoundMgr::SoundManagerPrivate
+{
+public:
+    SoundManagerPrivate() :
+        _device(NULL),
+        _context(NULL),
+        _absolute_pos(SGVec3d::zeros()),
+        _base_pos(SGVec3d::zeros()),
+        _orientation(SGQuatd::zeros())
+    {
+        
+        
+    }
+    
+    void init()
+    {
+        _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;
+    }
+    
+    void 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];
+
+        _absolute_pos = _base_pos;
+    }
+        
+    ALCdevice *_device;
+    ALCcontext *_context;
+    
+    std::vector<ALuint> _free_sources;
+    std::vector<ALuint> _sources_in_use;
+    
+    SGVec3d _absolute_pos;
+    SGVec3d _base_pos;
+    SGQuatd _orientation;
+    // Orientation of the listener. 
+    // first 3 elements are "at" vector, second 3 are "up" vector
+    ALfloat _at_up_vec[6];
+    
+    sample_group_map _sample_groups;
+    buffer_map _buffers;
+};
+
+
 //
 // Sound Manager
 //
 
-int SGSoundMgr::_alut_init = 0;
-
 // constructor
 SGSoundMgr::SGSoundMgr() :
-    _working(false),
     _active(false),
     _changed(true),
     _volume(0.0),
-    _device(NULL),
-    _context(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),
     _renderer("unknown"),
     _vendor("unknown")
 {
-#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++;
-#endif
+    d.reset(new SoundManagerPrivate);
+    d->_base_pos = SGVec3d::fromGeod(_geod_pos);
 }
 
 // destructor
 
 SGSoundMgr::~SGSoundMgr() {
 
-    stop();
-#if defined(ALUT_API_MAJOR_VERSION) && ALUT_API_MAJOR_VERSION >= 1
-    _alut_init--;
-    if (_alut_init == 0) {
-        alutExit ();
-    }
-#endif
+    if (is_working())
+        stop();
+    d->_sample_groups.clear();
 }
 
 // initialize the sound manager
-void SGSoundMgr::init(const char *devname) {
+void SGSoundMgr::init()
+{
+#ifdef ENABLE_SOUND
+    if (is_working())
+    {
+        SG_LOG( SG_SOUND, SG_ALERT, "Oops, OpenAL sound manager is already initialized." );
+        return;
+    }
+
+    SG_LOG( SG_SOUND, SG_INFO, "Initializing OpenAL sound manager" );
+
+    d->_free_sources.clear();
+    d->_free_sources.reserve( MAX_SOURCES );
+    d->_sources_in_use.clear();
+    d->_sources_in_use.reserve( MAX_SOURCES );
 
-    SG_LOG( SG_GENERAL, SG_INFO, "Initializing OpenAL sound manager" );
+    ALCdevice *device = NULL;
+    const char* devname = _device_name.c_str();
+    if (_device_name == "")
+        devname = NULL; // use default device
+    else
+    {
+        // try non-default device
+        device = alcOpenDevice(devname);
+    }
 
-    ALCdevice *device = alcOpenDevice(devname);
-    if ( testForError(device, "Audio device not available, trying default") ) {
+    if ((!devname)||(testForError(device, "Audio device not available, trying default.")) ) {
         device = alcOpenDevice(NULL);
-        if (testForError(device, "Default Audio device not available.") ) {
+        if (testForError(device, "Default audio device not available.") ) {
            return;
         }
     }
 
     ALCcontext *context = alcCreateContext(device, NULL);
+    testForALCError("context creation.");
     if ( testForError(context, "Unable to create a valid context.") ) {
         alcCloseDevice (device);
         return;
@@ -123,16 +194,17 @@ void SGSoundMgr::init(const char *devname) {
         return;
     }
 
-    if (_context != NULL)
-        SG_LOG(SG_GENERAL, SG_ALERT, "context is already assigned");
-    _context = context;
-    _working = true;
-
-    _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;
+    if (d->_context != NULL)
+    {
+        SG_LOG(SG_SOUND, SG_ALERT, "context is already assigned");
+    }
+    
+    d->_context = context;
+    d->_device = device;
+    d->init();
 
     alListenerf( AL_GAIN, 0.0f );
-    alListenerfv( AL_ORIENTATION, _at_up_vec );
+    alListenerfv( AL_ORIENTATION, d->_at_up_vec );
     alListenerfv( AL_POSITION, SGVec3f::zeros().data() );
     alListenerfv( AL_VELOCITY, SGVec3f::zeros().data() );
 
@@ -155,137 +227,148 @@ void SGSoundMgr::init(const char *devname) {
         alGenSources(1, &source);
         error = alGetError();
         if ( error == AL_NO_ERROR ) {
-            _free_sources.push_back( source );
+            d->_free_sources.push_back( source );
+        } else {
+            SG_LOG(SG_SOUND, SG_INFO, "allocating source failed:" << i);
+            break;
         }
-        else break;
     }
 
     _vendor = (const char *)alGetString(AL_VENDOR);
     _renderer = (const char *)alGetString(AL_RENDERER);
-    if ( _vendor != "OpenAL Community" ||
-        (_renderer != "Software" && _renderer != "OpenAL Sample Implementation")
-       )
-    {
+
+    if (_vendor == "Creative Labs Inc.") {
        _bad_doppler = true;
+    } else if (_vendor == "OpenAL Community" && _renderer == "OpenAL Soft") {
+       _bad_doppler = true;
+    }
+
+    if (d->_free_sources.empty()) {
+        SG_LOG(SG_SOUND, SG_ALERT, "Unable to grab any OpenAL sources!");
     }
+#endif
+}
+
+void SGSoundMgr::reinit()
+{
+    bool was_active = _active;
 
-    if (_free_sources.size() == 0) {
-        SG_LOG(SG_GENERAL, SG_ALERT, "Unable to grab any OpenAL sources!");
+    if (was_active)
+    {
+        suspend();
     }
+
+    SGSoundMgr::stop();
+    SGSoundMgr::init();
+
+    if (was_active)
+        resume();
 }
 
-void SGSoundMgr::activate() {
-    if ( _working ) {
+void SGSoundMgr::activate()
+{
+#ifdef ENABLE_SOUND
+    if ( is_working() ) {
         _active = true;
-        sample_group_map_iterator sample_grp_current = _sample_groups.begin();
-        sample_group_map_iterator sample_grp_end = _sample_groups.end();
+                
+        sample_group_map_iterator sample_grp_current = d->_sample_groups.begin();
+        sample_group_map_iterator sample_grp_end = d->_sample_groups.end();
         for ( ; sample_grp_current != sample_grp_end; ++sample_grp_current ) {
             SGSampleGroup *sgrp = sample_grp_current->second;
             sgrp->activate();
         }
     }
+#endif
 }
 
 // stop the sound manager
-void SGSoundMgr::stop() {
-
+void SGSoundMgr::stop()
+{
+#ifdef ENABLE_SOUND
     // 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();
+    sample_group_map_iterator sample_grp_current = d->_sample_groups.begin();
+    sample_group_map_iterator sample_grp_end = d->_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];
+    BOOST_FOREACH(ALuint source, d->_free_sources) {
         alDeleteSources( 1 , &source );
+        testForALError("SGSoundMgr::stop: delete sources");
     }
-    _free_sources.clear();
+    d->_free_sources.clear();
 
     // clear any OpenAL buffers before shutting down
-    buffer_map_iterator buffers_current = _buffers.begin();
-    buffer_map_iterator buffers_end = _buffers.end();
+    buffer_map_iterator buffers_current = d->_buffers.begin();
+    buffer_map_iterator buffers_end = d->_buffers.end();
     for ( ; buffers_current != buffers_end; ++buffers_current ) {
         refUint ref = buffers_current->second;
         ALuint buffer = ref.id;
         alDeleteBuffers(1, &buffer);
+        testForALError("SGSoundMgr::stop: delete buffers");
     }
-    _buffers.clear();
+    
+    d->_buffers.clear();
+    d->_sources_in_use.clear();
 
-    if (_working) {
-        _working = false;
+    if (is_working()) {
         _active = false;
-        _context = alcGetCurrentContext();
-        _device = alcGetContextsDevice(_context);
-        alcDestroyContext(_context);
-        alcCloseDevice(_device);
-        _context = NULL;
+        alcDestroyContext(d->_context);
+        alcCloseDevice(d->_device);
+        d->_context = NULL;
+        d->_device = NULL;
 
         _renderer = "unknown";
         _vendor = "unknown";
     }
+#endif
 }
 
-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();
+void SGSoundMgr::suspend()
+{
+#ifdef ENABLE_SOUND
+    if (is_working()) {
+        sample_group_map_iterator sample_grp_current = d->_sample_groups.begin();
+        sample_group_map_iterator sample_grp_end = d->_sample_groups.end();
         for ( ; sample_grp_current != sample_grp_end; ++sample_grp_current ) {
             SGSampleGroup *sgrp = sample_grp_current->second;
             sgrp->stop();
         }
         _active = false;
     }
+#endif
 }
 
-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();
+void SGSoundMgr::resume()
+{
+#ifdef ENABLE_SOUND
+    if (is_working()) {
+        sample_group_map_iterator sample_grp_current = d->_sample_groups.begin();
+        sample_group_map_iterator sample_grp_end = d->_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 ()
-{
-    _free_sources.clear();
-    _free_sources.reserve( MAX_SOURCES );
-    _sources_in_use.clear();
-    _sources_in_use.reserve( MAX_SOURCES );
-}
-
-
-void SGSoundMgr::unbind ()
-{
-    _sample_groups.clear();
-
-    // delete free sources
-    for (unsigned int i=0; i<_free_sources.size(); i++) {
-        ALuint source = _free_sources[i];
-        alDeleteSources( 1 , &source );
-    }
-
-    _free_sources.clear();
-    _sources_in_use.clear();
+#endif
 }
 
 // run the audio scheduler
-void SGSoundMgr::update( double dt ) {
+void SGSoundMgr::update( double dt )
+{
+#ifdef ENABLE_SOUND
     if (_active) {
-        alcSuspendContext(_context);
+        alcSuspendContext(d->_context);
 
         if (_changed) {
-            update_pos_and_orientation();
+            d->update_pos_and_orientation();
         }
 
-        sample_group_map_iterator sample_grp_current = _sample_groups.begin();
-        sample_group_map_iterator sample_grp_end = _sample_groups.end();
+        sample_group_map_iterator sample_grp_current = d->_sample_groups.begin();
+        sample_group_map_iterator sample_grp_end = d->_sample_groups.end();
         for ( ; sample_grp_current != sample_grp_end; ++sample_grp_current ) {
             SGSampleGroup *sgrp = sample_grp_current->second;
             sgrp->update(dt);
@@ -298,7 +381,7 @@ 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_ORIENTATION, _at_up_vec );
+            alListenerfv( AL_ORIENTATION, d->_at_up_vec );
             // alListenerfv( AL_POSITION, toVec3f(_absolute_pos).data() );
 
             SGQuatd hlOr = SGQuatd::fromLonLat( _geod_pos );
@@ -317,58 +400,54 @@ if (isNaN(_velocity.data())) printf("NaN in listener velocity\n");
             _changed = false;
         }
 
-        alcProcessContext(_context);
+        alcProcessContext(d->_context);
     }
+#endif
 }
 
 // add a sample group, return true if successful
-bool SGSoundMgr::add( SGSampleGroup *sgrp, const string& refname )
+bool SGSoundMgr::add( SGSampleGroup *sgrp, const std::string& refname )
 {
-    sample_group_map_iterator sample_grp_it = _sample_groups.find( refname );
-    if ( sample_grp_it != _sample_groups.end() ) {
+    sample_group_map_iterator sample_grp_it = d->_sample_groups.find( refname );
+    if ( sample_grp_it != d->_sample_groups.end() ) {
         // sample group already exists
         return false;
     }
 
     if (_active) sgrp->activate();
-    _sample_groups[refname] = sgrp;
+    d->_sample_groups[refname] = sgrp;
 
     return true;
 }
 
 
 // remove a sound effect, return true if successful
-bool SGSoundMgr::remove( const string &refname )
+bool SGSoundMgr::remove( const std::string &refname )
 {
-    sample_group_map_iterator sample_grp_it = _sample_groups.find( refname );
-    if ( sample_grp_it == _sample_groups.end() ) {
+    sample_group_map_iterator sample_grp_it = d->_sample_groups.find( refname );
+    if ( sample_grp_it == d->_sample_groups.end() ) {
         // sample group was not found.
         return false;
     }
 
-    _sample_groups.erase( sample_grp_it );
+    d->_sample_groups.erase( sample_grp_it );
 
     return true;
 }
 
 
 // return true of the specified sound exists in the sound manager system
-bool SGSoundMgr::exists( 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;
-    }
-
-    return true;
+bool SGSoundMgr::exists( const std::string &refname ) {
+    sample_group_map_iterator sample_grp_it = d->_sample_groups.find( refname );
+    return ( sample_grp_it != d->_sample_groups.end() );
 }
 
 
 // return a pointer to the SGSampleGroup if the specified sound exists
 // in the sound manager system, otherwise 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() ) {
+SGSampleGroup *SGSoundMgr::find( const std::string &refname, bool create ) {
+    sample_group_map_iterator sample_grp_it = d->_sample_groups.find( refname );
+    if ( sample_grp_it == d->_sample_groups.end() ) {
         // sample group was not found.
         if (create) {
             SGSampleGroup* sgrp = new SGSampleGroup(this, refname);
@@ -386,8 +465,7 @@ SGSampleGroup *SGSoundMgr::find( const string &refname, bool create ) {
 void SGSoundMgr::set_volume( float v )
 {
     _volume = v;
-    if (_volume > 1.0) _volume = 1.0;
-    if (_volume < 0.0) _volume = 0.0;
+    SG_CLAMP_RANGE(_volume, 0.0f, 1.0f);
     _changed = true;
 }
 
@@ -398,19 +476,19 @@ void SGSoundMgr::set_volume( float v )
 // 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
+// management. Sources further away should be suspended to free resources for
 // newly added sounds close by.
 unsigned int SGSoundMgr::request_source()
 {
     unsigned int source = NO_SOURCE;
 
-    if (_free_sources.size() > 0) {
-       source = _free_sources.back();
-       _free_sources.pop_back();
-       _sources_in_use.push_back(source);
+    if (!d->_free_sources.empty()) {
+       source = d->_free_sources.back();
+       d->_free_sources.pop_back();
+       d->_sources_in_use.push_back(source);
     }
     else
-       SG_LOG( SG_GENERAL, SG_INFO, "No more free sources available\n");
+       SG_LOG( SG_SOUND, SG_BULK, "Sound manager: No more free sources available!\n");
 
     return source;
 }
@@ -420,33 +498,36 @@ void SGSoundMgr::release_source( unsigned int source )
 {
     vector<ALuint>::iterator it;
 
-    it = std::find(_sources_in_use.begin(), _sources_in_use.end(), source);
-    if ( it != _sources_in_use.end() ) {
+    it = std::find(d->_sources_in_use.begin(), d->_sources_in_use.end(), source);
+    if ( it != d->_sources_in_use.end() ) {
+  #ifdef ENABLE_SOUND
         ALint result;
 
         alGetSourcei( source, AL_SOURCE_STATE, &result );
-        if ( result == AL_PLAYING )
+        if ( result == AL_PLAYING || result == AL_PAUSED ) {
             alSourceStop( source );
-        testForALError("release source");
+        }
 
-        alSourcei( source, AL_BUFFER, 0 );
-        _free_sources.push_back( source );
-        _sources_in_use.erase( it );
+        alSourcei( source, AL_BUFFER, 0 );	// detach the associated buffer
+        testForALError("release_source");
+  #endif
+        d->_free_sources.push_back( source );
+        d->_sources_in_use.erase( it );
     }
 }
 
 unsigned int SGSoundMgr::request_buffer(SGSoundSample *sample)
 {
     ALuint buffer = NO_BUFFER;
-
+#ifdef ENABLE_SOUND
     if ( !sample->is_valid_buffer() ) {
         // sample was not yet loaded or removed again
-        string sample_name = sample->get_sample_name();
+        std::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_map_iterator buffer_it = d->_buffers.find( sample_name );
+        if ( buffer_it != d->_buffers.end() ) {
             buffer_it->second.refctr++;
             buffer = buffer_it->second.id;
             sample->set_buffer( buffer );
@@ -457,17 +538,24 @@ unsigned int SGSoundMgr::request_buffer(SGSoundSample *sample)
         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;
 
+            try {
+              bool res = load(sample_name, &sample_data, &format, &size, &freq);
+              if (res == false) return NO_BUFFER;
+            } catch (sg_exception& e) {
+              SG_LOG(SG_SOUND, SG_ALERT,
+                    "failed to load sound buffer: " << e.getFormattedMessage());
+              sample->set_buffer( SGSoundMgr::FAILED_BUFFER );
+              return FAILED_BUFFER;
+            }
+            
             sample->set_frequency( freq );
             sample->set_format( format );
             sample->set_size( size );
-        }
-        else
+
+        } else {
             sample_data = sample->get_data();
+        }
 
         // create an OpenAL buffer handle
         alGenBuffers(1, &buffer);
@@ -479,105 +567,71 @@ unsigned int SGSoundMgr::request_buffer(SGSoundSample *sample)
             ALsizei freq = sample->get_frequency();
             alBufferData( buffer, format, sample_data, size, freq );
 
-            if ( sample->is_file() ) free(sample_data);
-
             if ( !testForALError("buffer add data") ) {
                 sample->set_buffer(buffer);
-                _buffers[sample_name] = refUint(buffer);
+                d->_buffers[sample_name] = refUint(buffer);
             }
         }
+
+        if ( sample->is_file() ) free(sample_data);
     }
     else {
         buffer = sample->get_buffer();
-}
-
+    }
+#endif
     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;
-    }
+    if ( !sample->is_queue() )
+    {
+        std::string sample_name = sample->get_sample_name();
+        buffer_map_iterator buffer_it = d->_buffers.find( sample_name );
+        if ( buffer_it == d->_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");
+        sample->no_valid_buffer();
+        buffer_it->second.refctr--;
+        if (buffer_it->second.refctr == 0) {
+#ifdef ENABLE_SOUND
+            ALuint buffer = buffer_it->second.id;
+            alDeleteBuffers(1, &buffer);
+#endif
+            d->_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,
-                                          size_t *sz, int *frq )
+bool SGSoundMgr::load( const std::string &samplepath,
+                       void **dbuf,
+                       int *fmt,
+                       size_t *sz,
+                       int *frq )
 {
-    if ( !_working ) return false;
+    if ( !is_working() )
+        return false;
 
     ALenum format;
     ALsizei size;
     ALsizei freq;
     ALvoid *data;
 
-#if defined(ALUT_API_MAJOR_VERSION) && ALUT_API_MAJOR_VERSION >= 1
     ALfloat freqf;
-    data = alutLoadMemoryFromFile(samplepath.c_str(), &format, &size, &freqf );
+
+    data = simgear::loadWAVFromFile(samplepath, format, size, freqf );
     freq = (ALsizei)freqf;
-    int error = alutGetError();
-    if (data == NULL || 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;
+    if (data == NULL) {
+        throw sg_io_exception("Failed to load wav file", sg_location(samplepath));
     }
 
-#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 =  alGetError();
-    if ( error != AL_NO_ERROR ) {
-        string msg = "Failed to load wav file: ";
-        msg.append(alGetString(error));
-        throw sg_io_exception(msg.c_str(), sg_location(samplepath));
-        return false;
+    if (format == AL_FORMAT_STEREO8 || format == AL_FORMAT_STEREO16) {
+        free(data);
+        throw sg_io_exception("Warning: STEREO files are not supported for 3D audio effects: " + samplepath);
     }
-#endif
 
     *dbuf = (void *)data;
     *fmt = (int)format;
@@ -590,6 +644,7 @@ bool SGSoundMgr::load(string &samplepath, void **dbuf, int *fmt,
 vector<const char*> SGSoundMgr::get_available_devices()
 {
     vector<const char*> devices;
+#ifdef ENABLE_SOUND
     const ALCchar *s;
 
     if (alcIsExtensionPresent(NULL, "ALC_enumerate_all_EXT") == AL_TRUE) {
@@ -609,56 +664,76 @@ vector<const char*> SGSoundMgr::get_available_devices()
         }
         devices.push_back(ptr);
     }
-
+#endif
     return devices;
 }
 
 
-bool SGSoundMgr::testForError(void *p, string s)
+bool SGSoundMgr::testForError(void *p, std::string s)
 {
    if (p == NULL) {
-      SG_LOG( SG_GENERAL, SG_ALERT, "Error: " << s);
+      SG_LOG( SG_SOUND, SG_ALERT, "Error: " << s);
       return true;
    }
    return false;
 }
 
 
-bool SGSoundMgr::testForALError(string s)
+bool SGSoundMgr::testForALError(std::string s)
 {
+#ifdef ENABLE_SOUND
     ALenum error = alGetError();
     if (error != AL_NO_ERROR)  {
-       SG_LOG( SG_GENERAL, SG_ALERT, "AL Error (sound manager): "
+       SG_LOG( SG_SOUND, SG_ALERT, "AL Error (sound manager): "
                                       << alGetString(error) << " at " << s);
        return true;
     }
+#endif
     return false;
 }
 
-bool SGSoundMgr::testForALCError(string s)
+bool SGSoundMgr::testForALCError(std::string s)
 {
+#ifdef ENABLE_SOUND
     ALCenum error;
-    error = alcGetError(_device);
+    error = alcGetError(d->_device);
     if (error != ALC_NO_ERROR) {
-        SG_LOG( SG_GENERAL, SG_ALERT, "ALC Error (sound manager): "
-                                       << alcGetString(_device, error) << " at "
+        SG_LOG( SG_SOUND, SG_ALERT, "ALC Error (sound manager): "
+                                       << alcGetString(d->_device, error) << " at "
                                        << s);
         return true;
     }
+#endif
     return false;
 }
 
-bool SGSoundMgr::testForALUTError(string s)
+bool SGSoundMgr::is_working() const 
 {
-#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;
+    return (d->_device != NULL);
+}
+
+const SGQuatd& SGSoundMgr::get_orientation() const
+{
+    return d->_orientation;
+}
+
+void SGSoundMgr::set_orientation( const SGQuatd& ori )
+{
+    d->_orientation = ori;
+    _changed = true;
+}
+
+const SGVec3d& SGSoundMgr::get_position() const
+{ 
+    return d->_absolute_pos;
+}
+
+void SGSoundMgr::set_position( const SGVec3d& pos, const SGGeod& pos_geod )
+{
+    d->_base_pos = pos; _geod_pos = pos_geod; _changed = true;
+}
+
+SGVec3f SGSoundMgr::get_direction() const
+{
+    return SGVec3f(d->_at_up_vec[0], d->_at_up_vec[1], d->_at_up_vec[2]);
 }