diff -r a1e0306b9cd1 -r 51e5df1c8462 openalbridge/openalbridge.c --- a/openalbridge/openalbridge.c Sat Oct 17 13:47:58 2009 +0000 +++ b/openalbridge/openalbridge.c Sat Oct 17 13:51:16 2009 +0000 @@ -18,566 +18,481 @@ #include "openalbridge.h" -char oalbReady = 0; -int iNumSounds = 0; -char *prog; -/*Sources are points emitting sound*/ -ALuint Sources[MAX_SOURCES]; -/*structure that holds information about sounds*/ -SSound_t *theSounds; - -ALfloat SourcePos[] = { 0.0, 0.0, 0.0 }; /*Position of the source sound*/ -ALfloat SourceVel[] = { 0.0, 0.0, 0.0 }; /*Velocity of the source sound*/ - -/** - * const char oalb_init (const char* programname, const char usehardware) - * - * ARGUMENTS - * programname [const char*]: name of the program invoking OpenAL - * usehardware [const char] : flag to enable audio hardware acceleration - * DESCRIPTION - * - * RETURN - * 1 success - * 2 error - */ - -const char oalb_init (const char* programname, const char usehardware) { - /*Initialize an OpenAL contex and allocate memory space for data and buffers*/ - ALCcontext *context; - ALCdevice *device; - const ALCchar *default_device; - int i; +#ifdef __CPLUSPLUS +extern "C" { +#endif + + /*Sources are points emitting sound*/ + ALuint *Sources; + /*Buffers hold sound data*/ + ALuint *Buffers; + /*index for Sources and Buffers*/ + ALuint globalindex, globalsize, increment; + + ALboolean openalReady = AL_FALSE; - prog = (char *) programname; - - /*Position of the listener*/ - ALfloat ListenerPos[] = {0.0, 0.0, 0.0}; - /*Velocity of the listener*/ - ALfloat ListenerVel[] = {0.0, 0.0, 0.0}; - /*Orientation of the listener. (first 3 elements are "at", second 3 are "up")*/ - ALfloat ListenerOri[] = {0.0, 0.0, -1.0, 0.0, 1.0, 0.0}; - - if (oalbReady == 1) { - errno = EPERM; - err_ret("(%s) WARN - OpenAL already initialized", prog); - return AL_FALSE; + ALboolean openal_close (void) { + /*Stop all sounds, deallocate all memory and close OpenAL */ + ALCcontext *context; + ALCdevice *device; + + if (openalReady == AL_FALSE) { + errno = EPERM; + err_ret("(%s) WARN - OpenAL not initialized", prog); + return AL_FALSE; + } + + alSourceStopv (globalsize, Sources); + alDeleteSources (globalsize, Sources); + alDeleteBuffers (globalsize, Buffers); + + free(Sources); + free(Buffers); + + context = alcGetCurrentContext(); + device = alcGetContextsDevice(context); + + alcMakeContextCurrent(NULL); + alcDestroyContext(context); + alcCloseDevice(device); + + openalReady = AL_FALSE; + + return AL_TRUE; } -#ifdef _WIN32 - /* Hardware acceleration is broken on some windows card*/ - if (usehardware != 0) - device = alcOpenDevice(NULL); - else - { - device = alcOpenDevice("Generic Software"); - if(!device) - { - err_msg("(%s) WARN - Failed to open software device", prog); - device = alcOpenDevice(NULL); - } - } -#else - /*always hardware for UNIX systems*/ - device = alcOpenDevice(NULL); -#endif - - if (device == NULL) { - errno = ENODEV; - err_ret("(%s) WARN - Failed to open sound device", prog); - return AL_FALSE; - } - err_msg("(%s) INFO - Output device: %s", prog, alcGetString(device, ALC_DEVICE_SPECIFIER)); - - context = alcCreateContext(device, NULL); - alcMakeContextCurrent(context); - alcProcessContext(context); - - if (AlGetError("(%s) ERROR - Failed to create a new contex") != AL_TRUE) - return AL_FALSE; - - /*set the listener gain, position (on xyz axes), velocity (one value for each axe) and orientation*/ - alListenerf (AL_GAIN, 1.0f ); - alListenerfv(AL_POSITION, ListenerPos); - alListenerfv(AL_VELOCITY, ListenerVel); - alListenerfv(AL_ORIENTATION, ListenerOri); - - if (AlGetError("(%s) WARN - Failed to set Listener properties") != AL_TRUE) - return AL_FALSE; - - theSounds = (SSound_t*) Malloc(sizeof(SSound_t)*MAX_SOUNDS); - for (i = 0; i < MAX_SOUNDS; i++) { - theSounds->isLoaded = 0; - theSounds->sourceIndex = -1; - } - - alGenSources(MAX_SOURCES, Sources); - oalbReady = 1; - - alGetError(); /* clear any AL errors beforehand */ - return AL_TRUE; -} - - -/** - * void oalb_close (void) - * - * ARGUMENTS - * - - * DESCRIPTION - * Stop all sounds, deallocate all memory and close OpenAL - * RETURN - * - - */ - -void oalb_close (void) { - /*Stop all sounds, deallocate all memory and close OpenAL */ - ALCcontext *context; - ALCdevice *device; - int i; - - if (oalbReady == 0) { - errno = EPERM; - err_ret("(%s) WARN - OpenAL not initialized", prog); - return; + ALboolean openal_ready(void) { + return openalReady; } - alSourceStopv (MAX_SOURCES, Sources); - alDeleteSources (MAX_SOURCES, Sources); - - for (i = 0; i < MAX_SOUNDS; i++) { - free(theSounds[i].filename); - alDeleteBuffers (1, &theSounds[i].Buffer); + ALboolean openal_init(char* programname, ALboolean usehardware, uint32_t memorysize) { + /*Initialize an OpenAL contex and allocate memory space for data and buffers*/ + ALCcontext *context; + ALCdevice *device; + const ALCchar *default_device; + + prog = programname; + + /*Position of the listener*/ + ALfloat ListenerPos[] = { 0.0, 0.0, 0.0 }; + /*Velocity of the listener*/ + ALfloat ListenerVel[] = { 0.0, 0.0, 0.0 }; + /*Orientation of the listener. (first 3 elements are "at", second 3 are "up")*/ + ALfloat ListenerOri[] = { 0.0, 0.0, -1.0, 0.0, 1.0, 0.0 }; + + if (openalReady == AL_TRUE) { + errno = EPERM; + err_ret("(%s) WARN - OpenAL already initialized", prog); + return AL_FALSE; + } + + if (usehardware == AL_TRUE) + device = alcOpenDevice(NULL); + else + device = alcOpenDevice("Generic Software"); + + if (device == NULL) { + errno = ENODEV; + err_ret("(%s) WARN - Failed to open sound device", prog); + return AL_FALSE; + } + err_msg("(%s) INFO - Output device: %s", prog, alcGetString(device, ALC_DEVICE_SPECIFIER)); + + context = alcCreateContext(device, NULL); + alcMakeContextCurrent(context); + alcProcessContext(context); + + if (AlGetError("(%s) WARN - Failed to create a new contex") != AL_TRUE) + return AL_FALSE; + + /*allocate memory space for buffers and sources*/ + if (memorysize == 0) + globalsize = 50; + else + globalsize = memorysize; + increment = globalsize; + + Buffers = (ALuint*) Malloc(sizeof(ALuint)*globalsize); + Sources = (ALuint*) Malloc(sizeof(ALuint)*globalsize); + + /*set the listener gain, position (on xyz axes), velocity (one value for each axe) and orientation*/ + alListenerf (AL_GAIN, 1.0f ); + alListenerfv(AL_POSITION, ListenerPos); + alListenerfv(AL_VELOCITY, ListenerVel); + alListenerfv(AL_ORIENTATION, ListenerOri); + + if (AlGetError("(%s) WARN - Failed to set Listener properties") != AL_TRUE) + return AL_FALSE; + + openalReady = AL_TRUE; + + alGetError(); /* clear any AL errors beforehand */ + return AL_TRUE; } - free(theSounds); - - context = alcGetCurrentContext(); - device = alcGetContextsDevice(context); - - alcMakeContextCurrent(NULL); - alcDestroyContext(context); - alcCloseDevice(device); - - oalbReady = 0; - return; -} - -/** - * char oalb_ready (void) - * - * ARGUMENTS - * - - * DESCRIPTION - * - * RETURN - * - - */ - -char oalb_ready (void) { - return oalbReady; -} -/* - ALboolean helper_realloc (void) { - expands allocated memory when loading more sound files than expected - int oldsize = globalsize; - globalsize += increment; - - #ifdef DEBUG - err_msg("(%s) INFO - Realloc in process from %d to %d\n", prog, oldsize, globalsize); - #endif - - Buffers = (ALuint*) Realloc(Buffers, sizeof(ALuint)*globalsize); - Sources = (ALuint*) Realloc(Sources, sizeof(ALuint)*globalsize); - - return AL_TRUE; - }*/ - -/** - * const int32_t oalb_loadfile (const char *filename) - * - * ARGUMENTS - * - - * DESCRIPTION - * - * RETURN - * - - */ - -const int32_t oalb_loadfile (const char *filename){ - /*Open a file, load into memory and allocate the Source buffer for playing*/ - ALenum format, error; - ALsizei bitsize, freq; - char *data; - int namelength, i; - uint32_t magic; - FILE *fp; - - if (oalbReady == 0) { - errno = EPERM; - err_ret("(%s) WARN - OpenAL not initialized", prog); - return -1; + ALboolean helper_realloc (void) { + /*expands allocated memory when loading more sound files than expected*/ + int oldsize = globalsize; + globalsize += increment; + +#ifdef DEBUG + err_msg("(%s) INFO - Realloc in process from %d to %d\n", prog, oldsize, globalsize); +#endif + + Buffers = (ALuint*) Realloc(Buffers, sizeof(ALuint)*globalsize); + Sources = (ALuint*) Realloc(Sources, sizeof(ALuint)*globalsize); + + return AL_TRUE; } - /*when the buffers are all used, we can expand memory to accept new files*/ - // if (globalindex == globalsize) - // helper_realloc(); - namelength=strlen(filename); - /*if this sound is already loaded return the index from theSounds*/ - for (i = 0; i < iNumSounds; i++){ - if (theSounds[iNumSounds].isLoaded == 1) { - if (strncmp(theSounds[iNumSounds].filename, filename, namelength) == 0) - return i; + ALint openal_loadfile (const char *filename){ + /*Open a file, load into memory and allocate the Source buffer for playing*/ + ALfloat SourcePos[] = { 0.0, 0.0, 0.0 }; /*Position of the source sound*/ + ALfloat SourceVel[] = { 0.0, 0.0, 0.0 }; /*Velocity of the source sound*/ + ALenum format; + ALsizei bitsize, freq; + char *data; + uint32_t fileformat; + ALenum error; + FILE *fp; + + if (openalReady == AL_FALSE) { + errno = EPERM; + err_ret("(%s) WARN - OpenAL not initialized", prog); + return AL_FALSE; + } + + /*when the buffers are all used, we can expand memory to accept new files*/ + if (globalindex == globalsize) + helper_realloc(); + + /*detect the file format, as written in the first 4 bytes of the header*/ + fp = Fopen (filename, "rb"); + + if (fp == NULL) + return -1; + + error = fread (&fileformat, sizeof(uint32_t), 1, fp); + fclose (fp); + + if (error < 0) { + errno = EIO; + err_ret("(%s) ERROR - File %s is too short", prog, filename); + return -2; } - } - - /*else load it and store it into a theSounds cell*/ - - /*detect the file format, as written in the first 4 bytes of the header*/ - fp = Fopen (filename, "rb"); - - if (fp == NULL) - return -1; - - error = fread (&magic, sizeof(uint32_t), 1, fp); - fclose (fp); - - if (error < 0) { - errno = EIO; - err_ret("(%s) ERROR - File %s is too short", prog, filename); - return -2; - } - - switch (ENDIAN_BIG_32(magic)) { - case OGG_FILE_FORMAT: - error = load_oggvorbis (filename, &format, &data, &bitsize, &freq); - break; - case WAV_FILE_FORMAT: - error = load_wavpcm (filename, &format, &data, &bitsize, &freq); - break; - default: - errno = EINVAL; - err_ret ("(%s) ERROR - File format (%08X) not supported", prog, ENDIAN_BIG_32(magic)); - return -5; - break; - } - - theSounds[iNumSounds].filename = (char*) Malloc(sizeof(char) * namelength); - strncpy(theSounds[iNumSounds].filename, filename, namelength); - theSounds[iNumSounds].isLoaded = 1; - - /*prepare the buffer to receive data*/ - alGenBuffers(1, &theSounds[iNumSounds].Buffer); - - if (AlGetError("(%s) ERROR - Failed to allocate memory for buffers") != AL_TRUE) - return -3; - - /*copy pcm data in one buffer*/ - alBufferData(theSounds[iNumSounds].Buffer, format, data, bitsize, freq); - /*deallocate data to save memory*/ - free(data); - - if (AlGetError("(%s) ERROR - Failed to write data to buffers") != AL_TRUE) - return -6; - - alGetError(); /* clear any AL errors beforehand */ - - /*returns the index of the source you just loaded, increments it and exits*/ - return iNumSounds++; -} - - - -void oalb_setvolume (const uint32_t iIndex, const char cPercentage) { - float percentage; - - if (oalbReady == 0) { - errno = EPERM; - err_ret("(%s) WARN - OpenAL not initialized", prog); - return; + + /*prepare the buffer to receive data*/ + alGenBuffers(1, &Buffers[globalindex]); + + if (AlGetError("(%s) ERROR - Failed to allocate memory for buffers") != AL_TRUE) + return -3; + + /*prepare the source to emit sound*/ + alGenSources(1, &Sources[globalindex]); + + if (AlGetError("(%s) ERROR - Failed to allocate memory for sources") != AL_TRUE) + return -4; + + + switch (ENDIAN_BIG_32(fileformat)) { + case OGG_FILE_FORMAT: + error = load_oggvorbis (filename, &format, &data, &bitsize, &freq); + break; + case WAV_FILE_FORMAT: + error = load_wavpcm (filename, &format, &data, &bitsize, &freq); + break; + default: + errno = EINVAL; + err_ret ("(%s) ERROR - File format (%08X) not supported", prog, ENDIAN_BIG_32(fileformat)); + return -5; + break; + } + + + /*copy pcm data in one buffer*/ + alBufferData(Buffers[globalindex], format, data, bitsize, freq); + free(data); /*deallocate data to save memory*/ + + if (AlGetError("(%s) ERROR - Failed to write data to buffers") != AL_TRUE) + return -6; + + /*set source properties that it will use when it's in playback*/ + alSourcei (Sources[globalindex], AL_BUFFER, Buffers[globalindex] ); + alSourcef (Sources[globalindex], AL_PITCH, 1.0f ); + alSourcef (Sources[globalindex], AL_GAIN, 1.0f ); + alSourcefv(Sources[globalindex], AL_POSITION, SourcePos ); + alSourcefv(Sources[globalindex], AL_VELOCITY, SourceVel ); + alSourcei (Sources[globalindex], AL_LOOPING, 0 ); + + if (AlGetError("(%s) ERROR - Failed to set Source properties") != AL_TRUE) + return -7; + + alGetError(); /* clear any AL errors beforehand */ + + /*returns the index of the source you just loaded, increments it and exits*/ + return globalindex++; } - /*Set volume for sound number index*/ - if(iIndex < 0 || iIndex >= iNumSounds) { - errno = EINVAL; - err_ret("(%s) ERROR - Index (%d) out of bounds", prog, iIndex); - return; - } - if(cPercentage > 100) - percentage = 1.0f; - else - percentage = cPercentage / 100.0f; - - alSourcef(Sources[theSounds[iIndex].sourceIndex], AL_GAIN, percentage); - - if (AlGetError2("(%s) ERROR - Failed to set volume for sound %d\n", iIndex) != AL_TRUE) - return; - - alGetError(); /* clear any AL errors beforehand */ - - return; -} - - - -void oalb_setglobalvolume (const char cPercentage) { - if (oalbReady == 0) { - errno = EPERM; - err_ret("(%s) WARN - OpenAL not initialized", prog); - return; - } - - /*Set volume for all sounds*/ - if(cPercentage > 100) - alListenerf (AL_GAIN, 1.0f); - else - alListenerf (AL_GAIN, cPercentage / 100.0f); - - if (AlGetError("(%s) ERROR - Failed to set global volume") != AL_TRUE) - return; - - alGetError(); /* clear any AL errors beforehand */ - - return; -} - -void oalb_togglemute (void) { - /*Mute or unmute sound*/ - ALfloat mute; - - if (oalbReady == AL_FALSE) { - errno = EPERM; - err_ret("(%s) WARN - OpenAL not initialized", prog); - return; + ALboolean openal_toggleloop (uint32_t index){ + /*Set or unset looping mode*/ + ALint loop; + + if (openalReady == AL_FALSE) { + errno = EPERM; + err_ret("(%s) WARN - OpenAL not initialized", prog); + return AL_FALSE; + } + + if (index >= globalsize) { + errno = EINVAL; + err_ret("(%s) ERROR - Index out of bounds (got %d, max %d)", prog, index, globalindex); + return AL_FALSE; + } + + alGetSourcei (Sources[index], AL_LOOPING, &loop); + alSourcei (Sources[index], AL_LOOPING, !((uint8_t) loop) & 0x00000001); + if (AlGetError("(%s) ERROR - Failed to get or set loop property") != AL_TRUE) + return AL_FALSE; + + alGetError(); /* clear any AL errors beforehand */ + + return AL_TRUE; } - alGetListenerf (AL_GAIN, &mute); - if (mute > 0) - mute = 0; - else - mute = 1.0; - alListenerf (AL_GAIN, mute); - - if (AlGetError("(%s) ERROR - Failed to set mute property") != AL_TRUE) - return; - - alGetError(); /* clear any AL errors beforehand */ - - return; -} - - -void oalb_fade (uint32_t iIndex, uint16_t quantity, ALboolean direction) { - /*Fade in or out by calling a helper thread*/ -#ifndef _WIN32 - pthread_t thread; -#else - HANDLE Thread; - DWORD threadID; -#endif - fade_t *fade; - - if (oalbReady == 0) { - errno = EPERM; - err_ret("(%s) WARN - OpenAL not initialized", prog); - return ; + ALboolean openal_setvolume (uint32_t index, uint8_t percentage) { + if (openalReady == AL_FALSE) { + errno = EPERM; + err_ret("(%s) WARN - OpenAL not initialized", prog); + return AL_FALSE; + } + + /*Set volume for sound number index*/ + if (index >= globalsize) { + errno = EINVAL; + err_ret("(%s) ERROR - Index out of bounds (got %d, max %d)", prog, index, globalindex); + return AL_FALSE; + } + + if (percentage > 100) + percentage = 100; + alSourcef (Sources[index], AL_GAIN, (float) percentage/100.0f); + if (AlGetError2("(%s) ERROR - Failed to set volume for sound %d\n", index) != AL_TRUE) + return AL_FALSE; + + alGetError(); /* clear any AL errors beforehand */ + + return AL_TRUE; } - fade = (fade_t*) Malloc(sizeof(fade_t)); - fade->index = theSounds[iIndex].sourceIndex; - fade->quantity = quantity; - if(iIndex < 0 || iIndex >= iNumSounds) { - errno = EINVAL; - err_ret("(%s) ERROR - Index (%d) out of bounds", prog, iIndex); - return; + ALboolean openal_setglobalvolume (uint8_t percentage) { + if (openalReady == AL_FALSE) { + errno = EPERM; + err_ret("(%s) WARN - OpenAL not initialized", prog); + return AL_FALSE; + } + + /*Set volume for all sounds*/ + if (percentage > 100) + percentage = 100; + alListenerf (AL_GAIN, (float) percentage/100.0f); + if (AlGetError("(%s) ERROR - Failed to set global volume") != AL_TRUE) + return AL_FALSE; + + alGetError(); /* clear any AL errors beforehand */ + + return AL_TRUE; } - switch (direction) { - case FADE_IN: -#ifndef _WIN32 - pthread_create(&thread, NULL, helper_fadein, (void*) fade); -#else - Thread = _beginthread(&helper_fadein, 0, (void*) fade); -#endif - break; - case FADE_OUT: -#ifndef _WIN32 - pthread_create(&thread, NULL, helper_fadeout, (void*) fade); -#else - Thread = _beginthread(&helper_fadeout, 0, (void*) fade); -#endif - break; - default: - errno = EINVAL; - err_ret("(%s) ERROR - Unknown direction for fading", prog, iIndex); - free(fade); - return; - break; + + ALboolean openal_togglemute () { + /*Mute or unmute sound*/ + ALfloat mute; + + if (openalReady == AL_FALSE) { + errno = EPERM; + err_ret("(%s) WARN - OpenAL not initialized", prog); + return AL_FALSE; + } + + alGetListenerf (AL_GAIN, &mute); + if (mute > 0) + mute = 0; + else + mute = 1.0; + alListenerf (AL_GAIN, mute); + if (AlGetError("(%s) ERROR - Failed to set mute property") != AL_TRUE) + return AL_FALSE; + + alGetError(); /* clear any AL errors beforehand */ + + return AL_TRUE; } + + ALboolean openal_fade (uint32_t index, uint16_t quantity, ALboolean direction) { + /*Fade in or out by calling a helper thread*/ #ifndef _WIN32 - pthread_detach(thread); + pthread_t thread; +#else + HANDLE Thread; + DWORD threadID; #endif - - alGetError(); /* clear any AL errors beforehand */ - - return; -} - - -void oalb_fadeout (uint32_t index, uint16_t quantity) { - /*wrapper for fadeout*/ - oalb_fade(index, quantity, FADE_OUT); - return; -} - - -void oalb_fadein (uint32_t index, uint16_t quantity) { - /*wrapper for fadein*/ - oalb_fade(index, quantity, FADE_IN); - return; -} - - -/* ALboolean openal_setposition (uint32_t index, float x, float y, float z) { - if (openalReady == AL_FALSE) { - errno = EPERM; - err_ret("(%s) WARN - OpenAL not initialized", prog); - return AL_FALSE; - } - - if (index >= globalsize) { - errno = EINVAL; - err_ret("(%s) ERROR - Index out of bounds (got %d, max %d)", prog, index, globalindex); - return AL_FALSE; - } - - alSource3f(Sources[index], AL_POSITION, x, y, z); - if (AlGetError2("(%s) ERROR - Failed to set position for sound %d)", index) != AL_TRUE) - return AL_FALSE; - - return AL_TRUE; - }*/ - - -void oalb_playsound (const uint32_t iIndex, const char bLoop){ - int findNewSource; - int i, j, state; - - if (oalbReady == 0) { - errno = EPERM; - err_ret("(%s) WARN - OpenAL not initialized", prog); - return; + fade_t *fade; + + if (openalReady == AL_FALSE) { + errno = EPERM; + err_ret("(%s) WARN - OpenAL not initialized", prog); + return AL_FALSE; + } + + fade = (fade_t*) Malloc(sizeof(fade_t)); + fade->index = index; + fade->quantity = quantity; + + if (index >= globalsize) { + errno = EINVAL; + err_ret("(%s) ERROR - Index out of bounds (got %d, max %d)", prog, index, globalindex); + return AL_FALSE; + } + + switch (direction) { + case FADE_IN: +#ifndef _WIN32 + pthread_create(&thread, NULL, helper_fadein, (void*) fade); +#else + Thread = _beginthread(&helper_fadein, 0, (void*) fade); +#endif + break; + case FADE_OUT: +#ifndef _WIN32 + pthread_create(&thread, NULL, helper_fadeout, (void*) fade); +#else + Thread = _beginthread(&helper_fadeout, 0, (void*) fade); +#endif + break; + default: + errno = EINVAL; + err_ret("(%s) ERROR - Unknown direction for fading", prog, index, globalindex); + free(fade); + return AL_FALSE; + break; + } + +#ifndef _WIN32 + pthread_detach(thread); +#endif + + alGetError(); /* clear any AL errors beforehand */ + + return AL_TRUE; } - /*Play sound number index*/ - if(iIndex < 0 || iIndex >= iNumSounds) { - errno = EINVAL; - err_ret("(%s) ERROR - Index (%d) out of bounds", prog, iIndex); - return; + + ALboolean openal_fadeout (uint32_t index, uint16_t quantity) { + /*wrapper for fadeout*/ + return openal_fade(index, quantity, FADE_OUT); } - /*check if sound has already a source*/ - if (theSounds[iIndex].sourceIndex == -1) { - /*needs a new source*/ - findNewSource = 1; - } else { - /*already has a source -- check it's not playing*/ - alGetSourcei(Sources[theSounds[iIndex].sourceIndex], AL_SOURCE_STATE, &state); - if(state == AL_PLAYING || state == AL_PAUSED) { - /*it is being played, so we have to allocate a new source*/ - findNewSource = 1; - } else { - /*it is not being played, so we can use it safely*/ - findNewSource = 0; - } + + ALboolean openal_fadein (uint32_t index, uint16_t quantity) { + /*wrapper for fadein*/ + return openal_fade(index, quantity, FADE_IN); } - if (findNewSource == 1) { -#ifdef DEBUG - err_msg("(%s) DEBUG - Looking for a source for sound %d", prog, iIndex); -#endif - for (i = 0; i < MAX_SOURCES; i++) { - alGetSourcei(Sources[i], AL_SOURCE_STATE, &state); - if(state != AL_PLAYING && state != AL_PAUSED) { - // alSourceStop(Sources[i]); - // alGetError(); - for(j = 0; j < iNumSounds; j++) - if(theSounds[j].isLoaded && theSounds[j].sourceIndex == i) - theSounds[j].sourceIndex = -1; - break; - } else { - //TODO: what happens when all 16 sources are busy? - } + + ALboolean openal_setposition (uint32_t index, float x, float y, float z) { + if (openalReady == AL_FALSE) { + errno = EPERM; + err_ret("(%s) WARN - OpenAL not initialized", prog); + return AL_FALSE; + } + + if (index >= globalsize) { + errno = EINVAL; + err_ret("(%s) ERROR - Index out of bounds (got %d, max %d)", prog, index, globalindex); + return AL_FALSE; } - theSounds[iIndex].sourceIndex = i; + + alSource3f(Sources[index], AL_POSITION, x, y, z); + if (AlGetError2("(%s) ERROR - Failed to set position for sound %d)", index) != AL_TRUE) + return AL_FALSE; + + return AL_TRUE; + } + + + ALboolean openal_playsound (uint32_t index){ + if (openalReady == AL_FALSE) { + errno = EPERM; + err_ret("(%s) WARN - OpenAL not initialized", prog); + return AL_FALSE; + } + + /*Play sound number index*/ + if (index >= globalsize) { + errno = EINVAL; + err_ret("(%s) ERROR - Index out of bounds (got %d, max %d)", prog, index, globalindex); + return AL_FALSE; + } + alSourcePlay(Sources[index]); + if (AlGetError2("(%s) ERROR - Failed to play sound %d)", index) != AL_TRUE) + return AL_FALSE; + + alGetError(); /* clear any AL errors beforehand */ + + return AL_TRUE; } - alSourcei (Sources[theSounds[iIndex].sourceIndex], AL_BUFFER, theSounds[iIndex].Buffer); - alSourcef (Sources[theSounds[iIndex].sourceIndex], AL_PITCH, 1.0f ); - alSourcef (Sources[theSounds[iIndex].sourceIndex], AL_GAIN, 1.0f ); - alSourcefv(Sources[theSounds[iIndex].sourceIndex], AL_POSITION, SourcePos ); - alSourcefv(Sources[theSounds[iIndex].sourceIndex], AL_VELOCITY, SourceVel ); - alSourcei (Sources[theSounds[iIndex].sourceIndex], AL_LOOPING, bLoop ); - if (AlGetError("(%s) ERROR - Failed to set Source properties") != AL_TRUE) - return; - alSourcePlay(Sources[theSounds[iIndex].sourceIndex]); - if (AlGetError2("(%s) ERROR - Failed to play sound %d)", iIndex) != AL_TRUE) - return; - - alGetError(); /* clear any AL errors beforehand */ - - return; -} - - -void oalb_pausesound (const uint32_t iIndex) { - if (oalbReady == AL_FALSE) { - errno = EPERM; - err_ret("(%s) WARN - OpenAL not initialized", prog); - return; + ALboolean openal_pausesound(uint32_t index){ + if (openalReady == AL_FALSE) { + errno = EPERM; + err_ret("(%s) WARN - OpenAL not initialized", prog); + return AL_FALSE; + } + + /*Pause sound number index*/ + if (index >= globalsize) { + errno = EINVAL; + err_ret("(%s) ERROR - Index out of bounds (got %d, max %d)", prog, index, globalindex); + return AL_FALSE; + } + alSourcePause(Sources[index]); + if (AlGetError2("(%s) ERROR - Failed to pause sound %d)", index) != AL_TRUE) + return AL_FALSE; + + return AL_TRUE; } - /*Pause sound number index*/ - if(iIndex < 0 || iIndex >= iNumSounds) { - errno = EINVAL; - err_ret("(%s) ERROR - Index (%d) out of bounds", prog, iIndex); - return; - } - alSourcePause(Sources[theSounds[iIndex].sourceIndex]); - if (AlGetError2("(%s) ERROR - Failed to pause sound %d)", iIndex) != AL_TRUE) - return; - return; -} - - -void oalb_stopsound (const uint32_t iIndex) { - if (oalbReady == AL_FALSE) { - errno = EPERM; - err_ret("(%s) WARN - OpenAL not initialized", prog); - return; + ALboolean openal_stopsound(uint32_t index){ + if (openalReady == AL_FALSE) { + errno = EPERM; + err_ret("(%s) WARN - OpenAL not initialized", prog); + return AL_FALSE; + } + + /*Stop sound number index*/ + if (index >= globalsize) { + errno = EINVAL; + err_ret("(%s) ERROR - Index out of bounds (got %d, max %d)", prog, index, globalindex); + return AL_FALSE; + } + alSourceStop(Sources[index]); + if (AlGetError2("(%s) ERROR - Failed to stop sound %d)", index) != AL_TRUE) + return AL_FALSE; + + alGetError(); /* clear any AL errors beforehand */ + + return AL_TRUE; } - /*Stop sound number index*/ - if(iIndex < 0 || iIndex >= iNumSounds) { - errno = EINVAL; - err_ret("(%s) ERROR - Index (%d) out of bounds", prog, iIndex); - return; - } - alSourceStop(Sources[theSounds[iIndex].sourceIndex]); - - if (AlGetError2("(%s) ERROR - Failed to stop sound %d)", iIndex) != AL_TRUE) - return; - - alGetError(); /* clear any AL errors beforehand */ - - return; +#ifdef __CPLUSPLUS } +#endif