X-Git-Url: https://git.jsancho.org/?a=blobdiff_plain;f=Source%2Fopenal_wrapper.cpp;h=5e832fb5bc6959099b292cc2eea29e4aeb22184b;hb=bbf8873b80baf3cb468ac12b3f62b0938320fef1;hp=bc80c0b8f5148b68d77b40a5a513b603248e82f9;hpb=cb32f6030c30cfd6b32f3f622da1cf148b68af8d;p=lugaru.git diff --git a/Source/openal_wrapper.cpp b/Source/openal_wrapper.cpp index bc80c0b..5e832fb 100644 --- a/Source/openal_wrapper.cpp +++ b/Source/openal_wrapper.cpp @@ -1,3 +1,23 @@ +/* +Copyright (C) 2003, 2010 - Wolfire Games + +This file is part of Lugaru. + +Lugaru is free software; you can redistribute it and/or +modify it under the terms of the GNU General Public License +as published by the Free Software Foundation; either version 2 +of the License, or (at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + +See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program; if not, write to the Free Software +Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +*/ #if USE_OPENAL @@ -5,20 +25,14 @@ #include #include -#include "MacCompatibility.h" -#include "fmod.h" - -#include "AL/al.h" -#include "AL/alc.h" - -#include "ogg/ogg.h" -#include "vorbis/vorbisfile.h" +#include "Quaternions.h" +#include "openal_wrapper.h" +#include "Sounds.h" // NOTE: // FMOD uses a Left Handed Coordinate system, OpenAL uses a Right Handed // one...so we just need to flip the sign on the Z axis when appropriate. - #define DYNAMIC_LOAD_OPENAL 0 #if DYNAMIC_LOAD_OPENAL @@ -86,102 +100,155 @@ static bool lookup_all_alsyms(const char *libname) #define unload_alsyms() #endif - typedef struct { ALuint sid; - FSOUND_SAMPLE *sample; + OPENAL_SAMPLE *sample; bool startpaused; + float position[3]; } OPENAL_Channels; -typedef struct FSOUND_SAMPLE +typedef struct OPENAL_SAMPLE { + char *name; ALuint bid; // buffer id. int mode; -} FSOUND_SAMPLE; + int is2d; +} OPENAL_SAMPLE; static size_t num_channels = 0; -static OPENAL_Channels *channels = NULL; +static OPENAL_Channels *impl_channels = NULL; static bool initialized = false; +static float listener_position[3]; + +static void set_channel_position(const int channel, const float x, + const float y, const float z) +{ + OPENAL_Channels *chan = &impl_channels[channel]; + + chan->position[0] = x; + chan->position[1] = y; + chan->position[2] = z; + + OPENAL_SAMPLE *sptr = chan->sample; + if (sptr == NULL) + return; + + const ALuint sid = chan->sid; + const bool no_attenuate = sptr->is2d; + + if (no_attenuate) + { + alSourcei(sid, AL_SOURCE_RELATIVE, AL_TRUE); + alSource3f(sid, AL_POSITION, 0.0f, 0.0f, 0.0f); + } + else + { + alSourcei(sid, AL_SOURCE_RELATIVE, AL_FALSE); + alSource3f(sid, AL_POSITION, x, y, z); + } +} -void F_API OPENAL_3D_Listener_SetAttributes(const float *pos, const float *vel, float fx, float fy, float fz, float tx, float ty, float tz) +AL_API void OPENAL_3D_Listener_SetAttributes(const float *pos, const float *vel, float fx, float fy, float fz, float tx, float ty, float tz) { if (!initialized) return; if (pos != NULL) + { alListener3f(AL_POSITION, pos[0], pos[1], -pos[2]); + listener_position[0] = pos[0]; + listener_position[1] = pos[1]; + listener_position[2] = -pos[2]; + } + ALfloat vec[6] = { fx, fy, -fz, tz, ty, -tz }; alListenerfv(AL_ORIENTATION, vec); // we ignore velocity, since doppler's broken in the Linux AL at the moment... + + // adjust existing positions... + for (int i = 0; i < num_channels; i++) + { + const float *p = impl_channels[i].position; + set_channel_position(i, p[0], p[1], p[2]); + } } -signed char F_API OPENAL_3D_SetAttributes(int channel, const float *pos, const float *vel) +AL_API signed char OPENAL_3D_SetAttributes(int channel, const float *pos, const float *vel) { - if (!initialized) return FALSE; - if ((channel < 0) || (channel >= num_channels)) return FALSE; + if (!initialized) return false; + if ((channel < 0) || (channel >= num_channels)) return false; if (pos != NULL) - alSource3f(channels[channel].sid, AL_POSITION, pos[0], pos[1], -pos[2]); + set_channel_position(channel, pos[0], pos[1], -pos[2]); // we ignore velocity, since doppler's broken in the Linux AL at the moment... - return TRUE; + + return true; } -void F_API OPENAL_3D_SetDopplerFactor(float scale) +AL_API signed char OPENAL_3D_SetAttributes_(int channel, const XYZ &pos, const float *vel) { - if (!initialized) return; - // unimplemented...looks like init routines just call this with scale == 0.0f anyhow. + if (!initialized) return false; + if ((channel < 0) || (channel >= num_channels)) return false; + + set_channel_position(channel, pos.x, pos.y, -pos.z); + + return true; } -signed char F_API OPENAL_Init(int mixrate, int maxsoftwarechannels, unsigned int flags) +AL_API signed char OPENAL_Init(int mixrate, int maxsoftwarechannels, unsigned int flags) { - if (initialized) return FALSE; - if (maxsoftwarechannels == 0) return FALSE; + if (initialized) return false; + if (maxsoftwarechannels == 0) return false; if (flags != 0) // unsupported. - return FALSE; + return false; if (!lookup_all_alsyms("./openal.so")) // !!! FIXME: linux specific lib name { if (!lookup_all_alsyms("openal.so.1")) // !!! FIXME: linux specific lib name { if (!lookup_all_alsyms("openal.so")) // !!! FIXME: linux specific lib name - return FALSE; + return false; } } ALCdevice *dev = alcOpenDevice(NULL); if (!dev) - return FALSE; + return false; ALint caps[] = { ALC_FREQUENCY, mixrate, 0 }; ALCcontext *ctx = alcCreateContext(dev, caps); if (!ctx) { alcCloseDevice(dev); - return FALSE; + return false; } alcMakeContextCurrent(ctx); alcProcessContext(ctx); - printf("AL_VENDOR: %s\n", (char *) alGetString(AL_VENDOR)); - printf("AL_RENDERER: %s\n", (char *) alGetString(AL_RENDERER)); - printf("AL_VERSION: %s\n", (char *) alGetString(AL_VERSION)); - printf("AL_EXTENSIONS: %s\n", (char *) alGetString(AL_EXTENSIONS)); + bool cmdline(const char *cmd); + if (cmdline("openalinfo")) + { + printf("AL_VENDOR: %s\n", (char *) alGetString(AL_VENDOR)); + printf("AL_RENDERER: %s\n", (char *) alGetString(AL_RENDERER)); + printf("AL_VERSION: %s\n", (char *) alGetString(AL_VERSION)); + printf("AL_EXTENSIONS: %s\n", (char *) alGetString(AL_EXTENSIONS)); + } num_channels = maxsoftwarechannels; - channels = new OPENAL_Channels[maxsoftwarechannels]; - memset(channels, '\0', sizeof (OPENAL_Channels) * num_channels); + impl_channels = new OPENAL_Channels[maxsoftwarechannels]; + memset(impl_channels, '\0', sizeof (OPENAL_Channels) * num_channels); for (int i = 0; i < num_channels; i++) - alGenSources(1, &channels[i].sid); // !!! FIXME: verify this didn't fail! + alGenSources(1, &impl_channels[i].sid); // !!! FIXME: verify this didn't fail! initialized = true; - return TRUE; + return true; } -void F_API OPENAL_Close() +AL_API void OPENAL_Close() { if (!initialized) return; @@ -190,9 +257,9 @@ void F_API OPENAL_Close() { for (int i = 0; i < num_channels; i++) { - alSourceStop(channels[i].sid); - alSourcei(channels[i].sid, AL_BUFFER, 0); - alDeleteSources(1, &channels[i].sid); + alSourceStop(impl_channels[i].sid); + alSourcei(impl_channels[i].sid, AL_BUFFER, 0); + alDeleteSources(1, &impl_channels[i].sid); } ALCdevice *dev = alcGetContextsDevice(ctx); alcMakeContextCurrent(NULL); @@ -202,63 +269,63 @@ void F_API OPENAL_Close() } num_channels = 0; - delete[] channels; - channels = NULL; + delete[] impl_channels; + impl_channels = NULL; unload_alsyms(); initialized = false; } -FSOUND_SAMPLE *F_API OPENAL_GetCurrentSample(int channel) +static OPENAL_SAMPLE *OPENAL_GetCurrentSample(int channel) { if (!initialized) return NULL; if ((channel < 0) || (channel >= num_channels)) return NULL; - return channels[channel].sample; + return impl_channels[channel].sample; } -signed char F_API OPENAL_GetPaused(int channel) +static signed char OPENAL_GetPaused(int channel) { - if (!initialized) return FALSE; - if ((channel < 0) || (channel >= num_channels)) return FALSE; - if (channels[channel].startpaused) - return(TRUE); + if (!initialized) return false; + if ((channel < 0) || (channel >= num_channels)) return false; + if (impl_channels[channel].startpaused) + return(true); ALint state = 0; - alGetSourceiv(channels[channel].sid, AL_SOURCE_STATE, &state); - return((state == AL_PAUSED) ? TRUE : FALSE); + alGetSourceiv(impl_channels[channel].sid, AL_SOURCE_STATE, &state); + return((state == AL_PAUSED) ? true : false); } -unsigned int F_API OPENAL_GetLoopMode(int channel) +static unsigned int OPENAL_GetLoopMode(int channel) { if (!initialized) return 0; if ((channel < 0) || (channel >= num_channels)) return 0; ALint loop = 0; - alGetSourceiv(channels[channel].sid, AL_LOOPING, &loop); + alGetSourceiv(impl_channels[channel].sid, AL_LOOPING, &loop); if (loop) - return(FSOUND_LOOP_NORMAL); - return FSOUND_LOOP_OFF; + return(OPENAL_LOOP_NORMAL); + return OPENAL_LOOP_OFF; } -signed char F_API OPENAL_IsPlaying(int channel) +static signed char OPENAL_IsPlaying(int channel) { - if (!initialized) return FALSE; - if ((channel < 0) || (channel >= num_channels)) return FALSE; + if (!initialized) return false; + if ((channel < 0) || (channel >= num_channels)) return false; ALint state = 0; - alGetSourceiv(channels[channel].sid, AL_SOURCE_STATE, &state); - return((state == AL_PLAYING) ? TRUE : FALSE); + alGetSourceiv(impl_channels[channel].sid, AL_SOURCE_STATE, &state); + return((state == AL_PLAYING) ? true : false); } -int F_API OPENAL_PlaySoundEx(int channel, FSOUND_SAMPLE *sptr, FSOUND_DSPUNIT *dsp, signed char startpaused) +static int OPENAL_PlaySoundEx(int channel, OPENAL_SAMPLE *sptr, OPENAL_DSPUNIT *dsp, signed char startpaused) { if (!initialized) return -1; if (sptr == NULL) return -1; if (dsp != NULL) return -1; - if (channel == FSOUND_FREE) + if (channel == OPENAL_FREE) { for (int i = 0; i < num_channels; i++) { ALint state = 0; - alGetSourceiv(channels[i].sid, AL_SOURCE_STATE, &state); + alGetSourceiv(impl_channels[i].sid, AL_SOURCE_STATE, &state); if ((state != AL_PLAYING) && (state != AL_PAUSED)) { channel = i; @@ -268,25 +335,32 @@ int F_API OPENAL_PlaySoundEx(int channel, FSOUND_SAMPLE *sptr, FSOUND_DSPUNIT *d } if ((channel < 0) || (channel >= num_channels)) return -1; - ALint state = 0; - alSourceStop(channels[channel].sid); - channels[channel].sample = sptr; - alSourcei(channels[channel].sid, AL_BUFFER, sptr->bid); - alSourcei(channels[channel].sid, AL_LOOPING, (sptr->mode == FSOUND_LOOP_OFF) ? AL_FALSE : AL_TRUE); - channels[channel].startpaused = ((startpaused) ? true : false); + alSourceStop(impl_channels[channel].sid); + impl_channels[channel].sample = sptr; + alSourcei(impl_channels[channel].sid, AL_BUFFER, sptr->bid); + alSourcei(impl_channels[channel].sid, AL_LOOPING, (sptr->mode == OPENAL_LOOP_OFF) ? AL_FALSE : AL_TRUE); + set_channel_position(channel, 0.0f, 0.0f, 0.0f); + + impl_channels[channel].startpaused = ((startpaused) ? true : false); if (!startpaused) - alSourcePlay(channels[channel].sid); + alSourcePlay(impl_channels[channel].sid); return channel; } static void *decode_to_pcm(const char *_fname, ALenum &format, ALsizei &size, ALuint &freq) { +#ifdef __POWERPC__ + const int bigendian = 1; +#else + const int bigendian = 0; +#endif + // !!! FIXME: if it's not Ogg, we don't have a decoder. I'm lazy. :/ char *fname = (char *) alloca(strlen(_fname) + 16); strcpy(fname, _fname); char *ptr = strchr(fname, '.'); - if (ptr) *ptr = NULL; + if (ptr) *ptr = '\0'; strcat(fname, ".ogg"); // just in case... @@ -297,6 +371,7 @@ static void *decode_to_pcm(const char *_fname, ALenum &format, ALsizei &size, AL ALubyte *retval = NULL; + #if 0 // untested, so disable this! // Can we just feed it to the AL compressed? if (alIsExtensionPresent((const ALubyte *) "AL_EXT_vorbis")) { @@ -315,6 +390,7 @@ static void *decode_to_pcm(const char *_fname, ALenum &format, ALsizei &size, AL } return retval; } + #endif // Uncompress and feed to the AL. OggVorbis_File vf; @@ -337,7 +413,7 @@ static void *decode_to_pcm(const char *_fname, ALenum &format, ALsizei &size, AL long rc = 0; size_t allocated = 64 * 1024; retval = (ALubyte *) malloc(allocated); - while ( (rc = ov_read(&vf, buf, sizeof (buf), 0, 2, 1, &bitstream)) != 0 ) + while ( (rc = ov_read(&vf, buf, sizeof (buf), bigendian, 2, 1, &bitstream)) != 0 ) { if (rc > 0) { @@ -366,15 +442,15 @@ static void *decode_to_pcm(const char *_fname, ALenum &format, ALsizei &size, AL } -FSOUND_SAMPLE * F_API OPENAL_Sample_Load(int index, const char *name_or_data, unsigned int mode, int offset, int length) +AL_API OPENAL_SAMPLE *OPENAL_Sample_Load(int index, const char *name_or_data, unsigned int mode, int offset, int length) { if (!initialized) return NULL; - if (index != FSOUND_FREE) return NULL; // this is all the game does... + if (index != OPENAL_FREE) return NULL; // this is all the game does... if (offset != 0) return NULL; // this is all the game does... if (length != 0) return NULL; // this is all the game does... - if ((mode != FSOUND_HW3D) && (mode != FSOUND_2D)) return NULL; // this is all the game does... + if ((mode != OPENAL_HW3D) && (mode != OPENAL_2D)) return NULL; // this is all the game does... - FSOUND_SAMPLE *retval = NULL; + OPENAL_SAMPLE *retval = NULL; ALuint bufferName = 0; ALenum format = AL_NONE; ALsizei size = 0; @@ -389,160 +465,237 @@ FSOUND_SAMPLE * F_API OPENAL_Sample_Load(int index, const char *name_or_data, un if (alGetError() == AL_NO_ERROR) { alBufferData(bid, format, data, size, frequency); - retval = new FSOUND_SAMPLE; + retval = new OPENAL_SAMPLE; retval->bid = bid; - retval->mode = FSOUND_LOOP_OFF; + retval->mode = OPENAL_LOOP_OFF; + retval->is2d = (mode == OPENAL_2D); + retval->name = new char[strlen(name_or_data) + 1]; + if (retval->name) + strcpy(retval->name, name_or_data); } free(data); return(retval); } -void F_API OPENAL_Sample_Free(FSOUND_SAMPLE *sptr) +AL_API void OPENAL_Sample_Free(OPENAL_SAMPLE *sptr) { if (!initialized) return; if (sptr) { for (int i = 0; i < num_channels; i++) { - if (channels[i].sample == sptr) + if (impl_channels[i].sample == sptr) { - alSourceStop(channels[i].sid); - alSourcei(channels[i].sid, AL_BUFFER, 0); - channels[i].sample = NULL; + alSourceStop(impl_channels[i].sid); + alSourcei(impl_channels[i].sid, AL_BUFFER, 0); + impl_channels[i].sample = NULL; } } alDeleteBuffers(1, &sptr->bid); + delete[] sptr->name; delete sptr; } } -signed char F_API OPENAL_Sample_SetMode(FSOUND_SAMPLE *sptr, unsigned int mode) +static signed char OPENAL_Sample_SetMode(OPENAL_SAMPLE *sptr, unsigned int mode) { - if (!initialized) return FALSE; - if (mode != FSOUND_LOOP_NORMAL) return FALSE; - if (!sptr) return FALSE; + if (!initialized) return false; + if ((mode != OPENAL_LOOP_NORMAL) && (mode != OPENAL_LOOP_OFF)) return false; + if (!sptr) return false; sptr->mode = mode; - return TRUE; -} - -signed char F_API OPENAL_Sample_SetMinMaxDistance(FSOUND_SAMPLE *sptr, float min, float max) -{ - if (!initialized) return FALSE; - if (sptr == NULL) return FALSE; - // !!! FIXME: write me - return 0; + return true; } -signed char F_API OPENAL_SetFrequency(int channel, int freq) +AL_API signed char OPENAL_SetFrequency(int channel, int freq) { - if (!initialized) return FALSE; - if (channel == FSOUND_ALL) + if (!initialized) return false; + if (channel == OPENAL_ALL) { for (int i = 0; i < num_channels; i++) OPENAL_SetFrequency(i, freq); - return TRUE; + return true; } - if ((channel < 0) || (channel >= num_channels)) return FALSE; + if ((channel < 0) || (channel >= num_channels)) return false; if (freq == 8012) // hack - alSourcef(channels[channel].sid, AL_PITCH, 8012.0f / 44100.0f); + alSourcef(impl_channels[channel].sid, AL_PITCH, 8012.0f / 44100.0f); else - alSourcef(channels[channel].sid, AL_PITCH, 1.0f); - return TRUE; // ignore this for now... + alSourcef(impl_channels[channel].sid, AL_PITCH, 1.0f); + return true; } -signed char F_API OPENAL_SetVolume(int channel, int vol) +AL_API signed char OPENAL_SetVolume(int channel, int vol) { - if (!initialized) return FALSE; - if ((channel < 0) || (channel >= num_channels)) return FALSE; - if ((vol < 0) || (vol > 255)) return FALSE; + if (!initialized) return false; + + if (channel == OPENAL_ALL) + { + for (int i = 0; i < num_channels; i++) + OPENAL_SetVolume(i, vol); + return true; + } + + if ((channel < 0) || (channel >= num_channels)) return false; + + if (vol < 0) vol = 0; + else if (vol > 255) vol = 255; ALfloat gain = ((ALfloat) vol) / 255.0f; - alSourcef(channels[channel].sid, AL_GAIN, gain); - return TRUE; + alSourcef(impl_channels[channel].sid, AL_GAIN, gain); + return true; } -signed char F_API OPENAL_SetPaused(int channel, signed char paused) +AL_API signed char OPENAL_SetPaused(int channel, signed char paused) { - if (!initialized) return FALSE; - if ((channel < 0) || (channel >= num_channels)) return FALSE; + if (!initialized) return false; + + if (channel == OPENAL_ALL) + { + for (int i = 0; i < num_channels; i++) + OPENAL_SetPaused(i, paused); + return true; + } + + if ((channel < 0) || (channel >= num_channels)) return false; ALint state = 0; - if (channels[channel].startpaused) + if (impl_channels[channel].startpaused) state = AL_PAUSED; else - alGetSourceiv(channels[channel].sid, AL_SOURCE_STATE, &state); + alGetSourceiv(impl_channels[channel].sid, AL_SOURCE_STATE, &state); if ((paused) && (state == AL_PLAYING)) - alSourcePause(channels[channel].sid); + alSourcePause(impl_channels[channel].sid); else if ((!paused) && (state == AL_PAUSED)) { - alSourcePlay(channels[channel].sid); - channels[channel].startpaused = false; + alSourcePlay(impl_channels[channel].sid); + impl_channels[channel].startpaused = false; } - return TRUE; + return true; } -void F_API OPENAL_SetSFXMasterVolume(int volume) +AL_API void OPENAL_SetSFXMasterVolume(int volume) { if (!initialized) return; ALfloat gain = ((ALfloat) volume) / 255.0f; alListenerf(AL_GAIN, gain); } -signed char F_API OPENAL_StopSound(int channel) +AL_API signed char OPENAL_StopSound(int channel) { - if (!initialized) return FALSE; - if ((channel < 0) || (channel >= num_channels)) return FALSE; - alSourceStop(channels[channel].sid); - return TRUE; -} + if (!initialized) return false; -FSOUND_STREAM * F_API OPENAL_Stream_Open(const char *name_or_data, unsigned int mode, int offset, int length) -{ - if (!initialized) return NULL; - return 0; + if (channel == OPENAL_ALL) + { + for (int i = 0; i < num_channels; i++) + OPENAL_StopSound(i); + return true; + } + + if ((channel < 0) || (channel >= num_channels)) return false; + alSourceStop(impl_channels[channel].sid); + impl_channels[channel].startpaused = false; + return true; } -signed char F_API OPENAL_Stream_Close(FSOUND_STREAM *stream) +AL_API void OPENAL_Stream_Close(OPENAL_STREAM *stream) { - if (!initialized) return FALSE; - return 0; + OPENAL_Sample_Free((OPENAL_SAMPLE *) stream); } -FSOUND_SAMPLE * F_API OPENAL_Stream_GetSample(FSOUND_STREAM *stream) +static OPENAL_SAMPLE *OPENAL_Stream_GetSample(OPENAL_STREAM *stream) { if (!initialized) return NULL; - return 0; + return (OPENAL_SAMPLE *) stream; } -int F_API OPENAL_Stream_PlayEx(int channel, FSOUND_STREAM *stream, FSOUND_DSPUNIT *dsp, signed char startpaused) +static int OPENAL_Stream_PlayEx(int channel, OPENAL_STREAM *stream, OPENAL_DSPUNIT *dsp, signed char startpaused) { - if (!initialized) return -1; - return 0; + return OPENAL_PlaySoundEx(channel, (OPENAL_SAMPLE *) stream, dsp, startpaused); } -signed char F_API OPENAL_Stream_Stop(FSOUND_STREAM *stream) +static signed char OPENAL_Stream_Stop(OPENAL_STREAM *stream) { - if (!initialized) return FALSE; - return 0; + if (!initialized) return false; + for (int i = 0; i < num_channels; i++) + { + if (impl_channels[i].sample == (OPENAL_SAMPLE *) stream) + { + alSourceStop(impl_channels[i].sid); + impl_channels[i].startpaused = false; + } + } + return true; } -signed char F_API OPENAL_Stream_SetMode(FSOUND_STREAM *stream, unsigned int mode) +AL_API signed char OPENAL_Stream_SetMode(OPENAL_STREAM *stream, unsigned int mode) { - if (!initialized) return FALSE; - return 0; + return OPENAL_Sample_SetMode((OPENAL_SAMPLE *) stream, mode); } -void F_API OPENAL_Update() +AL_API void OPENAL_Update() { if (!initialized) return; alcProcessContext(alcGetCurrentContext()); } -signed char F_API OPENAL_SetOutput(int outputtype) +AL_API signed char OPENAL_SetOutput(int outputtype) { - return TRUE; + return true; +} + +extern int channels[]; + +extern "C" void PlaySoundEx(int chan, OPENAL_SAMPLE *sptr, OPENAL_DSPUNIT *dsp, signed char startpaused) +{ + const OPENAL_SAMPLE * currSample = OPENAL_GetCurrentSample(channels[chan]); + if (currSample && currSample == samp[chan]) + { + if (OPENAL_GetPaused(channels[chan])) + { + OPENAL_StopSound(channels[chan]); + channels[chan] = OPENAL_FREE; + } + else if (OPENAL_IsPlaying(channels[chan])) + { + int loop_mode = OPENAL_GetLoopMode(channels[chan]); + if (loop_mode & OPENAL_LOOP_OFF) + { + channels[chan] = OPENAL_FREE; + } + } + } + else + { + channels[chan] = OPENAL_FREE; + } + + channels[chan] = OPENAL_PlaySoundEx(channels[chan], sptr, dsp, startpaused); + if (channels[chan] < 0) + { + channels[chan] = OPENAL_PlaySoundEx(OPENAL_FREE, sptr, dsp, startpaused); + } +} + +extern "C" void PlayStreamEx(int chan, OPENAL_STREAM *sptr, OPENAL_DSPUNIT *dsp, signed char startpaused) +{ + const OPENAL_SAMPLE * currSample = OPENAL_GetCurrentSample(channels[chan]); + if (currSample && currSample == OPENAL_Stream_GetSample(sptr)) + { + OPENAL_StopSound(channels[chan]); + OPENAL_Stream_Stop(sptr); + } + else + { + OPENAL_Stream_Stop(sptr); + channels[chan] = OPENAL_FREE; + } + + channels[chan] = OPENAL_Stream_PlayEx(channels[chan], sptr, dsp, startpaused); + if (channels[chan] < 0) + { + channels[chan] = OPENAL_Stream_PlayEx(OPENAL_FREE, sptr, dsp, startpaused); + } } #endif