nevrax.org : docs

00001 
+00007 /* Copyright, 2001 Nevrax Ltd.
+00008  *
+00009  * This file is part of NEVRAX NEL.
+00010  * NEVRAX NEL is free software; you can redistribute it and/or modify
+00011  * it under the terms of the GNU General Public License as published by
+00012  * the Free Software Foundation; either version 2, or (at your option)
+00013  * any later version.
+00014 
+00015  * NEVRAX NEL is distributed in the hope that it will be useful, but
+00016  * WITHOUT ANY WARRANTY; without even the implied warranty of
+00017  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+00018  * General Public License for more details.
+00019 
+00020  * You should have received a copy of the GNU General Public License
+00021  * along with NEVRAX NEL; see the file COPYING. If not, write to the
+00022  * Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
+00023  * MA 02111-1307, USA.
+00024  */
+00025 
+00026 #include "stdopenal.h"
+00027 
+00028 #include "buffer_al.h"
+00029 #include "listener_al.h"
+00030 
+00031 using namespace std;
+00032 
+00033 
+00034 namespace NLSOUND {
+00035 
+00036 
+00037 #ifdef EAX_AVAILABLE
+00038 // EAXSet global function
+00039 EAXSet                                  EAXSetProp = NULL;
+00040 
+00041 // EAXGet global function
+00042 EAXGet                                  EAXGetProp = NULL;
+00043 #endif
+00044 
+00045 
+00046 // Currently, the OpenAL headers are different between Windows and Linux versions !
+00047 // AL_INVALID_XXXX are part of the spec, though.
+00048 #ifdef NL_OS_UNIX
+00049 #define AL_INVALID_ENUM AL_ILLEGAL_ENUM  
+00050 #define AL_INVALID_OPERATION AL_ILLEGAL_COMMAND 
+00051 #endif
+00052 
+00053 
+00054 #ifdef NL_DEBUG
+00055 // Test error in debug mode
+00056 void TestALError()
+00057 {
+00058         ALuint errcode = alGetError();
+00059         switch( errcode )
+00060         {
+00061         case AL_NO_ERROR : break;
+00062         case AL_INVALID_NAME : nlerror( "OpenAL: Invalid name" );
+00063         case AL_INVALID_ENUM  : nlerror( "OpenAL: Invalid enum" );
+00064         case AL_INVALID_VALUE  : nlerror( "OpenAL: Invalid value" );
+00065         case AL_INVALID_OPERATION  : nlerror( "OpenAL: Invalid operation" );
+00066         case AL_OUT_OF_MEMORY  : nlerror( "OpenAL: Out of memory" );
+00067         // alGetString( errcode ) seems to fail !
+00068         }
+00069 }
+00070 #endif
+00071 
+00072 
+00073 #define INITIAL_BUFFERS 8
+00074 #define INITIAL_SOURCES 8
+00075 #define BUFFER_ALLOC_RATE 8
+00076 #define SOURCE_ALLOC_RATE 8
+00077 
+00078 #define ROLLOFF_FACTOR_DEFAULT 1.0f
+00079 
+00080 /*
+00081  * Sound driver instance creation
+00082  */
+00083 #ifdef NL_OS_WINDOWS
+00084         
+00085 __declspec(dllexport) ISoundDriver *NLSOUND_createISoundDriverInstance()
+00086 {
+00087         CSoundDriverAL *driver = new CSoundDriverAL();
+00088         driver->init();
+00089         return driver;
+00090 }
+00091 
+00092 __declspec(dllexport) uint32 NLSOUND_interfaceVersion ()
+00093 {
+00094         return ISoundDriver::InterfaceVersion;
+00095 }
+00096 
+00097 #elif defined (NL_OS_UNIX)
+00098 
+00099 extern "C"
+00100 {
+00101 ISoundDriver* NLSOUND_createISoundDriverInstance ()
+00102 {
+00103         CSoundDriverAL *driver = new CSoundDriverAL();
+00104         driver->init();
+00105         return driver;
+00106 }
+00107 
+00108 uint32 NLSOUND_interfaceVersion ()
+00109 {
+00110         return ISoundDriver::InterfaceVersion;
+00111 }
+00112 }
+00113 
+00114 #endif // NL_OS_UNIX
+00115 
+00116 
+00117 // The instance of the singleton
+00118 CSoundDriverAL  *CSoundDriverAL::_Instance = NULL;
+00119 
+00120 
+00121 /*
+00122  * Constructor
+00123  */
+00124 CSoundDriverAL::CSoundDriverAL() :
+00125         ISoundDriver(), _NbExpBuffers( 0 ), _NbExpSources( 0 ), _RolloffFactor( 1.0f )
+00126 {
+00127         if ( _Instance == NULL )
+00128         {
+00129                 _Instance = this;
+00130         }
+00131         else
+00132         {
+00133                 nlerror( "Sound driver singleton instanciated twice" );
+00134         }
+00135 }
+00136 
+00137 
+00138 /*
+00139  * Destructor
+00140  */
+00141 CSoundDriverAL::~CSoundDriverAL()
+00142 {
+00143         // Remove the allocated (but not exported) source and buffer names
+00144         alDeleteSources( compactAliveNames( _Sources, alIsSource ), &*_Sources.begin() );
+00145         alDeleteBuffers( compactAliveNames( _Buffers, alIsBuffer ), &*_Buffers.begin() );
+00146 
+00147         // OpenAL exit
+00148         alutExit();
+00149 
+00150         _Instance = NULL;
+00151 }
+00152 
+00153 
+00154 /*
+00155  * Initialization
+00156  */
+00157 bool            CSoundDriverAL::init()
+00158 {
+00159         // OpenAL initialization
+00160         alutInit( NULL, NULL );
+00161 
+00162         // Display version information
+00163         const ALubyte *alversion, *alrenderer, *alvendor, *alext;
+00164         alversion = alGetString( AL_VERSION );
+00165         alrenderer = alGetString( AL_RENDERER );
+00166         alvendor = alGetString( AL_VENDOR );
+00167         alext = alGetString( AL_EXTENSIONS );
+00168         TestALError();
+00169         nlinfo( "Loading OpenAL lib: %s, %s, %s", alversion, alrenderer, alvendor );
+00170         nlinfo( "Listing extensions: %s", alext );
+00171 
+00172 #ifdef EAX_AVAILABLE
+00173     // Set EAX environment if EAX is available
+00174         if ( alIsExtensionPresent((ALubyte *)"EAX") == AL_TRUE ) // or EAX2.0
+00175         {
+00176                 nlinfo( "Initializing EAX" );
+00177             EAXSetProp = (EAXSet)alGetProcAddress((ALubyte*)"EAXSet");
+00178                 EAXGetProp = (EAXGet)alGetProcAddress((ALubyte*)"EAXGet");
+00179                 if ( EAXSetProp != NULL )
+00180                 {
+00181                         unsigned long ulEAXVal;
+00182                         long lGlobalReverb;
+00183                     lGlobalReverb = 0;
+00184                         EAXSetProp( &DSPROPSETID_EAX_ListenerProperties, DSPROPERTY_EAXLISTENER_ROOM, 0, &lGlobalReverb, sizeof(unsigned long) );
+00185                         ulEAXVal = EAX_ENVIRONMENT_GENERIC;
+00186                         EAXSetProp( &DSPROPSETID_EAX_ListenerProperties, DSPROPERTY_EAXLISTENER_ENVIRONMENT, 0, &ulEAXVal, sizeof(unsigned long) );
+00187                 }
+00188         }
+00189         else
+00190 #endif
+00191         {
+00192                 nlinfo( "EAX not available" );
+00193         }
+00194 
+00195         // Choose the I3DL2 model (same as DirectSound3D)
+00196         alDistanceModel( AL_INVERSE_DISTANCE_CLAMPED );
+00197         TestALError();
+00198 
+00199         // Initial buffers and sources allocation
+00200         allocateNewItems( alGenBuffers, alIsBuffer, _Buffers, _NbExpBuffers, INITIAL_BUFFERS );
+00201         allocateNewItems( alGenSources, alIsSource, _Sources, _NbExpSources, INITIAL_SOURCES );
+00202 
+00203         return true;
+00204 }
+00205 
+00206 
+00207 /*
+00208  * Allocate nb new items
+00209  */
+00210 void            CSoundDriverAL::allocateNewItems( TGenFunctionAL algenfunc, TTestFunctionAL altestfunc,
+00211                                                                                           vector<ALuint>& names, uint index, uint nb )
+00212 {
+00213         nlassert( index == names.size() );
+00214         names.resize( index + nb );
+00215         generateItems( algenfunc, altestfunc, nb, &(names[index]) );
+00216 }
+00217 
+00218 
+00219 /*
+00220  * throwGenException
+00221  */
+00222 void ThrowGenException( TGenFunctionAL algenfunc )
+00223 {
+00224         if ( algenfunc == alGenBuffers )
+00225                 throw ESoundDriverGenBuf();
+00226         else if ( algenfunc == alGenSources )
+00227                 throw ESoundDriverGenSrc();
+00228         else
+00229                 nlstop;
+00230 }
+00231 
+00232 /*
+00233  * Generate nb buffers/sources
+00234  */
+00235 void            CSoundDriverAL::generateItems( TGenFunctionAL algenfunc, TTestFunctionAL altestfunc, uint nb, ALuint *array )
+00236 {
+00237         algenfunc( nb, array );
+00238 
+00239         // Error handling
+00240         if ( alGetError() != AL_NO_ERROR )
+00241         {
+00242                 ThrowGenException( algenfunc );
+00243         }
+00244 
+00245         // Check buffers
+00246         uint i;
+00247         for ( i=0; i!=nb; i++ )
+00248         {
+00249                 if ( ! altestfunc( array[i] ) )
+00250                 {
+00251                         ThrowGenException( algenfunc );
+00252                 }
+00253         }
+00254 }
+00255 
+00256 
+00257 /*
+00258  * Create a sound buffer
+00259  */
+00260 IBuffer                 *CSoundDriverAL::createBuffer()
+00261 {
+00262         return new CBufferAL( createItem( alGenBuffers, alIsBuffer, _Buffers, _NbExpBuffers, BUFFER_ALLOC_RATE ) );
+00263 }
+00264 
+00265 
+00266 /*
+00267  * Create a source
+00268  */
+00269 ISource                 *CSoundDriverAL::createSource()
+00270 {
+00271         CSourceAL *sourceal = new CSourceAL( createItem( alGenSources, alIsSource, _Sources, _NbExpSources, SOURCE_ALLOC_RATE ) );
+00272         if ( _RolloffFactor != ROLLOFF_FACTOR_DEFAULT )
+00273         {
+00274                 alSourcef( sourceal->sourceName(), AL_ROLLOFF_FACTOR, _RolloffFactor );
+00275         }
+00276         return sourceal;
+00277 }
+00278 
+00279 
+00280 /*
+00281  * Create a sound buffer or a sound source
+00282  */
+00283 ALuint                  CSoundDriverAL::createItem( TGenFunctionAL algenfunc, TTestFunctionAL altestfunc,
+00284                                                                                         vector<ALuint>& names, uint& index, uint allocrate )
+00285 {
+00286         nlassert( index <= names.size() );
+00287         if ( index == names.size() )
+00288         {
+00289                 // Generate new items
+00290                 uint nbalive = compactAliveNames( names, altestfunc );
+00291                 if ( nbalive == names.size() )
+00292                 {
+00293                         // Extend vector of names
+00294                         allocateNewItems( algenfunc, altestfunc, names, index, allocrate );
+00295                 }
+00296                 else
+00297                 {
+00298                         // Take the room of the deleted names
+00299                         nlassert( nbalive < names.size() );
+00300                         index = nbalive;
+00301                         generateItems( algenfunc, altestfunc, names.size() - nbalive, &(names[nbalive]) );
+00302                 }
+00303         }
+00304 
+00305         // Return the name of the item
+00306         nlassert( index < names.size() );
+00307         ALuint itemname = names[index];
+00308         index++;
+00309         return itemname;
+00310 }
+00311 
+00312 
+00313 /*
+00314  * Remove names of deleted buffers and return the number of valid buffers
+00315  */
+00316 uint                    CSoundDriverAL::compactAliveNames( vector<ALuint>& names, TTestFunctionAL altestfunc )
+00317 {
+00318         vector<ALuint>::iterator iball, ibcompacted;
+00319         for ( iball=names.begin(), ibcompacted=names.begin(); iball!=names.end(); ++iball )
+00320         {
+00321                 // iball is incremented every iteration
+00322                 // ibcompacted is not incremented if a buffer is not valid anymore
+00323                 if ( altestfunc( *iball ) )
+00324                 {
+00325                         *ibcompacted = *iball;
+00326                         ++ibcompacted;
+00327                 }
+00328         }
+00329         nlassert( ibcompacted <= names.end() );
+00330         return ibcompacted - names.begin();
+00331 }
+00332 
+00333 
+00334 /*
+00335  * Remove a buffer
+00336  */
+00337 void                    CSoundDriverAL::removeBuffer( IBuffer *buffer )
+00338 {
+00339         nlassert( buffer != NULL );
+00340         CBufferAL *bufferAL = dynamic_cast<CBufferAL*>(buffer);
+00341         if ( ! deleteItem( bufferAL->bufferName(), alDeleteBuffers, _Buffers ) )
+00342         {
+00343                 nlwarning( "Deleting buffer: name not found" );
+00344         }
+00345 }
+00346 
+00347 
+00348 /*
+00349  * Remove a source
+00350  */
+00351 void                    CSoundDriverAL::removeSource( ISource *source )
+00352 {
+00353         nlassert( source != NULL );
+00354         CSourceAL *sourceAL = dynamic_cast<CSourceAL*>(source);
+00355         if ( ! deleteItem( sourceAL->sourceName(), alDeleteSources, _Sources ) )
+00356         {
+00357                 nlwarning( "Deleting source: name not found" );
+00358         }
+00359 }
+00360 
+00361 
+00362 /*
+00363  * Delete a buffer or a source
+00364  */
+00365 bool                    CSoundDriverAL::deleteItem( ALuint name, TGenFunctionAL aldeletefunc, vector<ALuint>& names )
+00366 {
+00367         vector<ALuint>::iterator ibn = find( names.begin(), names.end(), name );
+00368         if ( ibn == names.end() )
+00369         {
+00370                 return false;
+00371         }
+00372         aldeletefunc( 1, &*ibn );
+00373         *ibn = AL_NONE;
+00374         TestALError();
+00375         return true;
+00376 }
+00377 
+00378 
+00379 /*
+00380  * Create the listener instance
+00381  */
+00382 IListener               *CSoundDriverAL::createListener()
+00383 {
+00384         nlassert( CListenerAL::instance() == NULL );
+00385         return new CListenerAL();
+00386 }
+00387 
+00388 
+00389 /*
+00390  * Apply changes of rolloff factor to all sources
+00391  */
+00392 void                    CSoundDriverAL::applyRolloffFactor( float f )
+00393 {
+00394         _RolloffFactor = f;
+00395         vector<ALuint>::iterator ibn;
+00396         for ( ibn=_Sources.begin(); ibn!=_Sources.end(); ++ibn )
+00397         {
+00398                 alSourcef( *ibn, AL_ROLLOFF_FACTOR, _RolloffFactor );
+00399         }
+00400         TestALError();
+00401 }
+00402 
+00403 
+00404 /*
+00405  * Helper for loadWavFile()
+00406  */
+00407 TSampleFormat ALtoNLSoundFormat( ALenum alformat )
+00408 {
+00409         switch ( alformat )
+00410         {
+00411         case AL_FORMAT_MONO8 : return Mono8;
+00412         case AL_FORMAT_MONO16 : return Mono16;
+00413         case AL_FORMAT_STEREO8 : return Stereo8;
+00414         case AL_FORMAT_STEREO16 : return Stereo16;
+00415         default : nlstop; return Mono8;
+00416         }
+00417 }
+00418 
+00419 
+00420 /*
+00421  * Temp
+00422  */
+00423 bool                    CSoundDriverAL::loadWavFile( IBuffer *destbuffer, const char *filename )
+00424 {
+00425 // Currently, the OpenAL UT headers are different between Windows and Linux versions
+00426 #ifdef NL_OS_WINDOWS
+00427         ALsizei size,freq;
+00428         ALenum format;
+00429         ALvoid *data;
+00430         ALboolean loop;
+00431         alutLoadWAVFile( const_cast<char*>(filename), &format, &data, &size, &freq, &loop ); // last arg in some al.h
+00432 #else
+00433         ALsizei bits;
+00434         ALsizei size,freq;
+00435         ALsizei format;
+00436         ALvoid *data;
+00437         alutLoadWAV( const_cast<char*>(filename), &data, &format, &size, &bits, &freq ); 
+00438 #endif
+00439         if ( data == NULL )
+00440         {
+00441                 return false;
+00442         }
+00443         destbuffer->setFormat( ALtoNLSoundFormat(format), freq );
+00444         destbuffer->fillBuffer( data, size );
+00445 #ifdef NL_OS_WINDOWS
+00446         alutUnloadWAV(format,data,size,freq); // Where is it on Linux ?!?
+00447 #endif
+00448         return true;
+00449 }
+00450 
+00451 
+00452 } // NLSOUND
+
sound_driver_al.cpp
