Tribes2/engine
1
0
Fork 0
mirror of https://github.com/tribes2/engine.git synced 2026-01-19 19:24:45 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
engine/platformLinux/lokiOpenAL.cc
loop ff569bd2ae t2 engine svn checkout
2024-01-07 04:36:33 +00:00

867 lines
22 KiB
C++
Raw Blame History

//-----------------------------------------------------------------------------
// V12 Engine
//
// Copyright (c) 2001 GarageGames.Com
// Portions Copyright (c) 2001 by Sierra Online, Inc.
//-----------------------------------------------------------------------------
#ifdef DEDICATED
// Stubs for the dedicated server
bool bindOpenALFunctions(void)
{
return false;
}
void unbindOpenALFunctions(void)
{
return;
}
#else
// Code for the Linux client
#include <dlfcn.h>
#include "engine/console/console.h"
#include "engine/core/fileio.h"
#include "engine/core/tVector.h"
#include "engine/platformWIN32/platformAL.h"
// For the MP3 playback support
#include "SDL.h"
#include "smpeg.h"
static void *hinstOpenAL = NULL;
// declare DLL loaded OpenAL functions
#define AL_FUNCTION(fn_return,fn_name,fn_args) fn_return (*OpenAL_##fn_name)fn_args = NULL;
#define AL_EXT_FUNCTION(ext_name,fn_return,fn_name,fn_args) fn_return (*OpenAL_##fn_name)fn_args = NULL;
// An API change in OpenAL 1.0 - the context creation takes a device handle
AL_FUNCTION(ALCdevice *, alcOpenDevice, ( const ALubyte *tokstr ));
AL_FUNCTION(ALvoid, alcCloseDevice, ( ALCdevice *dev ));
AL_FUNCTION(ALvoid, alDistanceModel, ( ALenum distanceModel ));
ALvoid* (*OpenAL10_alcCreateContext)( struct _AL_device *dev, ALint* attrlist ) = NULL;
#include "lib/openal/win32/openALFn.h"
// Loki functions: ---------------------------------------------------------
// Used by alutInit() and alutExit() for device context handling
static void *context_id;
static ALCdevice *dev;
typedef struct fakeCallbackPair_s {
U32 sid;
void (*proc)(U32, bool);
} fakeCallbackPair_t;
static Vector< fakeCallbackPair_t > fakeCallbackFake(__FILE__, __LINE__);
void alxFakeCallbackUpdate( void )
{
fakeCallbackPair_t pi;
ALuint state;
int i;
i = fakeCallbackFake.size();
while( i-- ) {
pi = fakeCallbackFake.last();
fakeCallbackFake.pop_back();
state = AL_INITIAL;
alGetSourcei( pi.sid, AL_SOURCE_STATE, &state );
if( state == AL_STOPPED )
{
Con::printf( "Calling callback for %d", pi.sid);
pi.proc( pi.sid, false );
} else {
fakeCallbackFake.push_front( pi );
}
}
}
// Code for MP3 playback support
static SMPEG *mpeg = NULL;
#define MAX_MPEG_READ 512
static ALint MP3_Callback(ALuint sid,
ALuint bid,
ALshort *outdata,
ALenum format,
ALint freq,
ALint samples)
{
int bytesRequested = samples * sizeof( ALshort );
int bytesPlayed;
int i;
if(samples > MAX_MPEG_READ) {
int first, second;
first = MP3_Callback(sid, bid, outdata, format, freq, MAX_MPEG_READ);
second = MP3_Callback(sid, bid, outdata + MAX_MPEG_READ, format, freq, samples - MAX_MPEG_READ);
return first + second;
}
if( SMPEG_status(mpeg) != SMPEG_PLAYING ) {
SMPEG_play( mpeg );
}
memset( outdata, 0, bytesRequested );
bytesPlayed = SMPEG_playAudio( mpeg, (ALubyte *) outdata, bytesRequested );
bytesPlayed /= sizeof( ALshort );
if(bytesPlayed < samples) {
SMPEG_stop( mpeg );
SMPEG_rewind( mpeg );
return bytesPlayed;
}
return samples;
}
ALboolean alutLoadMP3_LOKI(ALuint bid, ALvoid *data, ALint size)
{
void (*alBufferDataWithCallback)(ALuint bid,
int (*Callback)(ALuint, ALuint, ALshort *, ALenum, ALint, ALint));
SDL_AudioSpec spec;
alBufferDataWithCallback = (void (*)(ALuint bid,
int (*Callback)(ALuint, ALuint, ALshort *, ALenum, ALint, ALint)))
alGetProcAddress((ALubyte *) "alBufferDataWithCallback_LOKI");
if(alBufferDataWithCallback == NULL) {
Con::errorf(ConsoleLogEntry::General, "Need alBufferDataWithCallback()");
return AL_FALSE;
}
if ( mpeg != NULL ) {
SMPEG_stop(mpeg);
SMPEG_delete(mpeg);
}
mpeg = SMPEG_new_data( data, size, NULL, 0 );
if ( mpeg == NULL ) {
Con::errorf( ConsoleLogEntry::General, "Unable to allocate MP3 data");
return AL_FALSE;
}
SMPEG_wantedSpec( mpeg, &spec );
spec.freq = Con::getIntVariable( "$pref::Audio::frequency", 22050 );
spec.format = AUDIO_S16;
/* implicitly multichannel */
alBufferi_EXT( bid, AL_CHANNELS, spec.channels );
SMPEG_actualSpec( mpeg, &spec );
SMPEG_enableaudio( mpeg, 1 );
SMPEG_enablevideo( mpeg, 0 ); /* sanity check */
alBufferDataWithCallback(bid, MP3_Callback);
return AL_TRUE;
}
// AL functions
ALvoid loki_alEnable( ALenum capability )
{
OpenAL_alEnable( capability );
}
ALvoid loki_alDisable( ALenum capability )
{
OpenAL_alDisable( capability );
}
ALboolean loki_alIsEnabled( ALenum capability )
{
return OpenAL_alIsEnabled( capability );
}
ALvoid loki_alHint( ALenum target, ALenum mode )
{
OpenAL_alHint( target, mode );
}
ALboolean loki_alGetBoolean( ALenum param )
{
return OpenAL_alGetBoolean( param );
}
ALint loki_alGetInteger( ALenum param )
{
return OpenAL_alGetInteger( param );
}
ALfloat loki_alGetFloat( ALenum param )
{
return OpenAL_alGetFloat( param );
}
ALdouble loki_alGetDouble( ALenum param )
{
return OpenAL_alGetDouble( param );
}
ALvoid loki_alGetBooleanv( ALenum param, ALboolean* data )
{
OpenAL_alGetBooleanv( param, data );
}
ALvoid loki_alGetIntegerv( ALenum param, ALint* data )
{
OpenAL_alGetIntegerv( param, data );
}
ALvoid loki_alGetFloatv( ALenum param, ALfloat* data )
{
OpenAL_alGetFloatv( param, data );
}
ALvoid loki_alGetDoublev( ALenum param, ALdouble* data )
{
OpenAL_alGetDoublev( param, data );
}
const ALubyte* loki_alGetString( ALenum param )
{
const ALubyte* string;
switch (param) {
case AL_EXTENSIONS:
string = "AL_EXT_DYNAMIX";
break;
default:
string = OpenAL_alGetString( param );
break;
}
return string;
}
ALenum loki_alGetError( ALvoid )
{
ALenum error;
error = AL_NO_ERROR;
error += OpenAL_alGetError( );
error += OpenAL_alcGetError( );
return error;
}
ALboolean loki_alIsExtensionPresent( const ALubyte* fname )
{
ALboolean value;
if ( dStrcmp(fname, "AL_EXT_DYNAMIX") == 0 ) {
value = true;
} else {
value = OpenAL_alIsExtensionPresent( fname );
}
return value;
}
ALvoid* loki_alGetProcAddress( const ALubyte* fname )
{
return OpenAL_alGetProcAddress( fname );
}
ALenum loki_alGetEnumValue( const ALubyte* ename )
{
return OpenAL_alGetEnumValue( ename );
}
ALvoid loki_alListenerf( ALenum pname, ALfloat param )
{
OpenAL_alListenerf( pname, param );
}
ALvoid loki_alListener3f( ALenum pname, ALfloat param1, ALfloat param2, ALfloat param3 )
{
OpenAL_alListener3f( pname, param1, param2, param3 );
}
ALvoid loki_alListenerfv( ALenum pname, ALfloat* param )
{
OpenAL_alListenerfv( pname, param );
}
ALvoid loki_alGetListeneri( ALenum pname, ALint* value )
{
OpenAL_alGetListeneri( pname, value );
}
ALvoid loki_alGetListenerf( ALenum pname, ALfloat* values )
{
OpenAL_alGetListenerf( pname, values );
}
ALvoid loki_alGetListenerfv( ALenum pname, ALfloat* values )
{
OpenAL_alGetListenerfv( pname, values );
}
ALvoid loki_alGenSources( ALsizei n, ALuint* sources )
{
OpenAL_alGenSources( n, sources );
}
ALvoid loki_alDeleteSources( ALsizei n, ALuint* sources )
{
OpenAL_alDeleteSources( n, sources );
}
ALboolean loki_alIsSource( ALuint sid )
{
return OpenAL_alIsSource( sid );
}
ALvoid loki_alSourcei( ALuint sid, ALenum param, ALint value )
{
switch (param) {
case AL_STREAMING:
case AL_ENV_SAMPLE_DIRECT_EXT:
case AL_ENV_SAMPLE_DIRECT_HF_EXT:
case AL_ENV_SAMPLE_ROOM_EXT:
case AL_ENV_SAMPLE_ROOM_HF_EXT:
case AL_ENV_SAMPLE_OUTSIDE_VOLUME_HF_EXT:
case AL_ENV_SAMPLE_FLAGS_EXT:
// Not yet supported
break;
case AL_SOURCE_AMBIENT:
// Special case, emulated by positioning relative sources
if ( value ) {
alSourcei(sid, AL_SOURCE_RELATIVE, AL_TRUE);
alSource3f(sid, AL_POSITION, 0.0, 0.0, 0.0);
} else {
alSourcei(sid, AL_SOURCE_RELATIVE, AL_FALSE);
}
break;
default:
// Pass through to OpenAL 1.0
OpenAL_alSourcei( sid, param, value );
break;
}
}
ALvoid loki_alSourcef( ALuint sid, ALenum param, ALfloat value )
{
switch (param) {
case AL_PAN:
case AL_ENV_SAMPLE_REVERB_MIX_EXT:
case AL_ENV_SAMPLE_OBSTRUCTION_EXT:
case AL_ENV_SAMPLE_OBSTRUCTION_LF_RATIO_EXT:
case AL_ENV_SAMPLE_OCCLUSION_EXT:
case AL_ENV_SAMPLE_OCCLUSION_ROOM_RATIO_EXT:
case AL_ENV_SAMPLE_ROOM_ROLLOFF_EXT:
case AL_ENV_SAMPLE_AIR_ABSORPTION_EXT:
// Not yet supported
break;
default:
// Pass through to OpenAL 1.0
OpenAL_alSourcef( sid, param, value );
break;
}
}
ALvoid loki_alSource3f( ALuint sid, ALenum param, ALfloat v1, ALfloat v2, ALfloat v3 )
{
OpenAL_alSource3f( sid, param, v1, v2, v3 );
}
ALvoid loki_alSourcefv( ALuint sid, ALenum param, ALfloat* values )
{
OpenAL_alSourcefv( sid, param, values );
}
ALvoid loki_alGetSourcei( ALuint sid, ALenum pname, ALint* value )
{
switch (pname) {
case AL_SOURCE_AMBIENT:
// Special case, emulated by positioning relative sources
alGetSourcei(sid, AL_SOURCE_RELATIVE, value);
break;
default:
// Pass through to OpenAL 1.0
OpenAL_alGetSourcei( sid, pname, value );
break;
}
}
ALvoid loki_alGetSourcef( ALuint sid, ALenum pname, ALfloat* value )
{
OpenAL_alGetSourcef( sid, pname, value );
}
ALvoid loki_alGetSourcefv( ALuint sid, ALenum pname, ALfloat* values )
{
OpenAL_alGetSourcefv( sid, pname, values );
}
ALvoid loki_alSourcePlayv( ALuint ns, ALuint* ids )
{
OpenAL_alSourcePlayv( ns, ids );
}
ALvoid loki_alSourceStopv( ALuint ns, ALuint* ids )
{
OpenAL_alSourceStopv( ns, ids );
}
ALvoid loki_alSourcePlay( ALuint sid )
{
OpenAL_alSourcePlay( sid );
}
ALvoid loki_alSourcePause( ALuint sid )
{
OpenAL_alSourcePause( sid );
}
ALvoid loki_alSourceStop( ALuint sid )
{
OpenAL_alSourceStop( sid );
}
ALvoid loki_alGenBuffers( ALsizei n, ALuint* samples )
{
OpenAL_alGenBuffers( n, samples );
}
ALvoid loki_alDeleteBuffers( ALsizei n, ALuint* samples )
{
OpenAL_alDeleteBuffers( n, samples );
}
ALboolean loki_alIsBuffer( ALuint buffer )
{
return OpenAL_alIsBuffer( buffer );
}
ALvoid loki_alBufferData( ALuint buffer, ALenum format, ALvoid* data, ALsizei size, ALsizei freq )
{
OpenAL_alBufferData( buffer, format, data, size, freq );
}
ALsizei loki_alBufferAppendData( ALuint buffer, ALenum format, ALvoid* data, ALsizei size, ALsizei freq )
{
return OpenAL_alBufferAppendData( buffer, format, data, size, freq );
}
ALvoid loki_alGetBufferi( ALuint buffer, ALenum param, ALint* value )
{
OpenAL_alGetBufferi( buffer, param, value );
}
ALvoid loki_alGetBufferf( ALuint buffer, ALenum param, ALfloat* value )
{
OpenAL_alGetBufferf( buffer, param, value );
}
// ALC functions
ALvoid* loki_alcCreateContext( ALint* attrlist )
{
return OpenAL10_alcCreateContext( dev, attrlist );
}
ALCenum loki_alcMakeContextCurrent( ALvoid* context )
{
return OpenAL_alcMakeContextCurrent( context );
}
ALvoid* loki_alcUpdateContext( ALvoid* context )
{
return OpenAL_alcUpdateContext( context );
}
ALCenum loki_alcDestroyContext( ALvoid* context )
{
return OpenAL_alcDestroyContext( context );
}
ALCenum loki_alcGetError( ALvoid )
{
return OpenAL_alcGetError( );
}
const ALubyte * loki_alcGetErrorString( ALvoid )
{
return OpenAL_alcGetErrorString( );
}
ALvoid* loki_alcGetCurrentContext( ALvoid )
{
return OpenAL_alcGetCurrentContext( );
}
// ALUT functions
void loki_alutInit( int* argc, char** argv )
{
char devstr_buf[1024];
const char *devstr;
const char *paren;
int refresh, frequency;
ALint attrlist[5];
// Get some basic configuration variables
refresh = Con::getIntVariable( "$pref::Audio::refresh", 15 );
frequency = Con::getIntVariable( "$pref::Audio::frequency", 22050 );
// Open the audio device
devstr = Con::getVariable("$pref::OpenAL::driver");
if ( devstr && ((paren=strrchr(devstr, ')')) != NULL) ) {
// Make sure a sane sampling rate is specified
if ( strstr(devstr, "sampling-rate") == NULL ) {
strcpy(devstr_buf, devstr);
sprintf(&devstr_buf[paren-devstr],
" (sampling-rate %d ))", frequency);
devstr = devstr_buf;
}
} else {
sprintf(devstr_buf, "'( (sampling-rate %d ))", frequency);
devstr = devstr_buf;
}
dev = OpenAL_alcOpenDevice( (const ALubyte *) devstr );
if( dev == NULL ) {
Con::errorf( ConsoleLogEntry::General, "Audio device open failed..." );
return;
}
attrlist[0] = ALC_FREQUENCY;
attrlist[1] = frequency;
attrlist[2] = ALC_REFRESH;
attrlist[3] = refresh;
attrlist[4] = 0;
context_id = alcCreateContext( attrlist );
if( context_id == NULL ) {
Con::errorf( ConsoleLogEntry::General, "Audio context creation failed, exiting..." );
Platform::forceShutdown( 1 );
return;
}
alcMakeContextCurrent( context_id );
// Set the distance attenuation model
OpenAL_alDistanceModel(AL_INVERSE_DISTANCE_CLAMPED);
}
void loki_alutExit( ALvoid )
{
if( context_id != NULL ) {
alcDestroyContext( context_id );
OpenAL_alcCloseDevice( dev );
context_id = NULL;
}
}
ALboolean loki_alutLoadWAV( const char* fname, ALvoid** data, ALsizei* format, ALsizei* size, ALsizei* bits, ALsizei* freq )
{
return OpenAL_alutLoadWAV( fname, data, format, size, bits, freq );
}
// Extensions
ALvoid loki_alGenEnvironmentIASIG( ALsizei n, ALuint* environs )
{
OpenAL_alGenEnvironmentIASIG( n, environs );
}
ALvoid loki_alDeleteEnvironmentIASIG( ALsizei n, ALuint* environs )
{
OpenAL_alDeleteEnvironmentIASIG( n, environs );
}
ALboolean loki_alIsEnvironmentIASIG( ALuint environment )
{
return OpenAL_alIsEnvironmentIASIG( environment );
}
ALvoid loki_alEnvironmentiIASIG( ALuint eid, ALenum param, ALint value )
{
OpenAL_alEnvironmentiIASIG( eid, param, value );
}
ALboolean loki_alBufferi_EXT( ALuint buffer, ALenum pname, ALint value )
{
ALboolean status;
alGetError();
switch (pname) {
case AL_BUFFER_KEEP_RESIDENT:
status = false;
break;
default:
OpenAL_alBufferi_EXT( buffer, pname, value );
status = (alGetError() == AL_NO_ERROR);
break;
}
return status;
}
ALboolean loki_alBufferSyncData_EXT( ALuint buffer, ALenum format, ALvoid* data, ALsizei size, ALsizei freq )
{
ALboolean status;
// alBufferData doesn't return a value,
// so clear the error setting, execute,
// and check again.
alGetError( );
alBufferData(buffer, format, data, size, freq);
if( alGetError( ) == AL_NO_ERROR ) {
// let AL manage the memory
dFree( data );
status = true;
} else {
status = false;
}
return status;
}
ALboolean loki_alBufferStreamFile_EXT( ALuint buffer, const ALubyte* filename )
{
File file;
file.open( (const char*) filename, File::Read );
if( file.getStatus( ) != File::Ok ) {
return AL_FALSE;
}
U32 size = file.getSize( );
char* data = (char*) dMalloc( size );
if( data == NULL ) {
// technically, 'file' will go out of scope and
// close itself, but still...
file.close( );
return AL_FALSE;
}
file.read( size, data );
if( file.getStatus( ) != File::Ok ) {
file.close( );
dFree( data );
return AL_FALSE;
}
U32 ext = dStrlen( filename );
ext -= 3;
ext = ( ext >= 0 ) ? ext : 0;
ALuint ok = AL_FALSE;
if( dStrnicmp( &filename[ ext ], "mp3", 3 ) != 0 ) {
alGetError();
alBufferData( buffer, AL_FORMAT_WAVE_EXT, data, size, 0 );
ok = (alGetError() == AL_NO_ERROR);
} else {
ok = alutLoadMP3_LOKI( buffer, data, size );
}
dFree( data );
file.close( );
if( ok == AL_FALSE ) {
Con::warnf( ConsoleLogEntry::General,
"could not buffer and convert %s", filename );
return AL_FALSE;
}
return AL_TRUE;
}
ALboolean loki_alSourceCallback_EXT( ALuint source, ALvoid* callback )
{
fakeCallbackPair_t pusher;
if( alIsSource( source ) == AL_FALSE) {
Con::errorf(ConsoleLogEntry::General,
"alSourceCallback_EXT: %d not a source id", source );
return;
}
pusher.sid = source;
pusher.proc = callback;
fakeCallbackFake.push_back( pusher );
}
ALvoid loki_alSourceResetEnvironment_EXT( ALuint source )
{
return; // Nothing we can do here yet...
}
ALboolean loki_alContexti_EXT( ALenum pname, ALint value )
{
return false;
}
ALboolean loki_alGetContexti_EXT( ALenum pname, ALint* value )
{
ALboolean status;
status = false;
if( value ) {
switch( pname ) {
case ALC_PROVIDER:
*value = 0;
status = true;
break;
case ALC_PROVIDER_COUNT:
*value = 1;
status = true;
break;
case ALC_SPEAKER:
*value = 0;
status = true;
break;
case ALC_SPEAKER_COUNT:
*value = 1;
status = true;
break;
case ALC_BUFFER_MEMORY_USAGE:
*value = 0;
status = true;
break;
case ALC_BUFFER_MEMORY_SIZE:
*value = 1 << 16;
status = true;
break;
case ALC_BUFFER_MEMORY_COUNT:
*value = 0;
status = true;
break;
case ALC_BUFFER_COUNT:
*value = 0;
status = true;
break;
default:
// error
break;
}
}
return status;
}
ALboolean loki_alGetContextstr_EXT( ALenum pname, ALuint idx, ALubyte** value )
{
ALboolean status;
status = false;
if( value ) {
switch( pname ) {
case ALC_PROVIDER_NAME:
*value = "Loki Software, Inc.";
status = true;
break;
case ALC_SPEAKER_NAME:
*value = "Stereo, 2-Speaker";
status = true;
break;
default:
// error
break;
}
}
return status;
}
ALboolean loki_alCaptureInit_EXT( ALenum format, ALuint rate, ALsizei bufferSize )
{
return OpenAL_alCaptureInit_EXT( format, rate, bufferSize );
}
ALboolean loki_alCaptureDestroy_EXT( ALvoid )
{
return OpenAL_alCaptureDestroy_EXT( );
}
ALboolean loki_alCaptureStart_EXT( ALvoid )
{
return OpenAL_alCaptureStart_EXT( );
}
ALboolean loki_alCaptureStop_EXT( ALvoid )
{
return OpenAL_alCaptureStop_EXT( );
}
ALsizei loki_alCaptureGetData_EXT( ALvoid* data, ALsizei n, ALenum format, ALuint rate )
{
return OpenAL_alCaptureGetData_EXT( data, n, format, rate );
}
ALvoid loki_alEnvironmentfIASIG( ALuint eid, ALenum param, ALfloat value )
{
return; // Nothing we can do here yet...
}
ALvoid loki_alGetEnvironmentiIASIG_EXT( ALuint eid, ALenum param, ALint * value )
{
return; // Nothing we can do here yet...
}
ALvoid loki_alGetEnvironmentfIASIG_EXT( ALuint eid, ALenum param, ALfloat * value )
{
return; // Nothing we can do here yet...
}
// DLL's: ------------------------------------------------------------------
static bool findExtension( const char* name )
{
bool result = false;
if (alGetString != NULL)
{
result = dStrstr( (const char*)alGetString(AL_EXTENSIONS), name) != NULL;
}
return result;
}
static bool bindFunction( void *&fnAddress, const char *name )
{
fnAddress = dlsym( hinstOpenAL, name );
#ifdef DEBUG_OPENAL
if( !fnAddress ) {
Con::errorf(ConsoleLogEntry::General, " Missing OpenAL function '%s'", name);
}
#endif
return (fnAddress != NULL);
}
static void bindExtension( void *&fnAddress, const char *name, bool &supported )
{
if (supported)
{
bindFunction(fnAddress, name);
#if 0
if (fnAddress == NULL)
supported = false;
#endif
}
else
fnAddress = NULL;
}
static bool bindDLLFunctions()
{
bool result = true;
/* It's okay if the following functions are not found:
alGetBoolean()
alGetInteger()
alGetFloat()
alGetDouble()
alcUpdateContext()
alcGetErrorString()
*/
#define AL_EXTENSION(ext_name) \
gDoesSupport_##ext_name = findExtension(#ext_name);
#define AL_FUNCTION(fn_return,fn_name,fn_args) \
{ const char *name = #fn_name; \
/* Do some renaming of functions to match OpenAL 1.0 API */ \
if ( dStrcmp(name, "alGetListeneri") == 0 ) \
name = "alGetListeneriv"; \
else \
if ( dStrcmp(name, "alGetListenerf") == 0 ) \
name = "alGetListenerfv"; \
else \
if ( dStrcmp(name, "alGetSourcei") == 0 ) \
name = "alGetSourceiv"; \
else \
if ( dStrcmp(name, "alGetSourcef") == 0 ) \
name = "alGetSourcefv"; \
else \
if ( dStrcmp(name, "alBufferi_EXT") == 0 ) \
name = "alBufferi_LOKI"; \
result &= bindFunction( *(void**)&OpenAL_##fn_name, name); \
}
#define AL_EXT_FUNCTION(ext_name,fn_return,fn_name,fn_args) \
{ const char *name = #fn_name; \
/* Do some renaming of functions to match OpenAL 1.0 API */ \
if ( dStrcmp(name, "alBufferi_EXT") == 0 ) \
name = "alBufferi_LOKI"; \
bindExtension( *(void**)&OpenAL_##fn_name, name, gDoesSupport_##ext_name); \
}
AL_FUNCTION(ALCdevice *, alcOpenDevice, ( const ALubyte *tokstr ));
AL_FUNCTION(ALvoid, alcCloseDevice, ( ALCdevice *dev ));
AL_FUNCTION(ALvoid, alDistanceModel, ( ALenum distanceModel ));
result &= bindFunction( *(void**)&OpenAL10_alcCreateContext, "alcCreateContext");
#include "lib/openal/win32/openALFn.h"
return result;
}
bool bindOpenALFunctions(void)
{
hinstOpenAL = dlopen( "./libopenal.so.0", RTLD_NOW );
if(hinstOpenAL == NULL)
{
return false;
}
// Set the Loki OpenAL function pointers (needed for extension loading)
#define AL_EXTENSION(ext_name) gDoesSupport_##ext_name = false;
#define AL_FUNCTION(fn_return,fn_name,fn_parms) fn_name = loki_##fn_name;
#define AL_EXT_FUNCTION(ext_name,fn_return,fn_name,fn_args) fn_name = loki_##fn_name;
#include "lib/openal/win32/openALFn.h"
// Load the real OpenAL functions from the shared library
bindDLLFunctions();
// Yay, we're done!
return true;
}
void unbindOpenALFunctions(void)
{
if (hinstOpenAL)
dlclose(hinstOpenAL);
hinstOpenAL = NULL;
}
#endif // DEDICATED
Reference in a new issue View git blame Copy permalink