自学教程：C++ sound_GetError函数代码示例

/** Decodes an opened OggVorbis file into an OpenAL buffer *  /param psTrack pointer to object which will contain the final buffer *  /param PHYSFS_fileHandle file handle given by PhysicsFS to the opened file *  /return on success the psTrack pointer, otherwise it will be free'd and a NULL pointer is returned instead */static inline TRACK* sound_DecodeOggVorbisTrack(TRACK *psTrack, PHYSFS_file* PHYSFS_fileHandle){#ifndef WZ_NOSOUND	ALenum		format;	ALuint		buffer;	struct OggVorbisDecoderState *decoder;	soundDataBuffer	*soundBuffer;	if ( !openal_initialized )	{		return NULL;	}	decoder = sound_CreateOggVorbisDecoder(PHYSFS_fileHandle, true);	if (decoder == NULL)	{		debug(LOG_WARNING, "Failed to open audio file for decoding");		free(psTrack);		return NULL;	}	soundBuffer = sound_DecodeOggVorbis(decoder, 0);	sound_DestroyOggVorbisDecoder(decoder);	if (soundBuffer == NULL)	{		free(psTrack);		return NULL;	}	if (soundBuffer->size == 0)	{		debug(LOG_WARNING, "sound_DecodeOggVorbisTrack: OggVorbis track is entirely empty after decoding");// NOTE: I'm not entirely sure if a track that's empty after decoding should be//       considered an error condition. Therefore I'll only error out on DEBUG//       builds. (Returning NULL here __will__ result in a program termination.)#ifdef DEBUG		free(soundBuffer);		free(psTrack);		return NULL;#endif	}	// Determine PCM data format	format = (soundBuffer->channelCount == 1) ? AL_FORMAT_MONO16 : AL_FORMAT_STEREO16;	// Create an OpenAL buffer and fill it with the decoded data	alGenBuffers(1, &buffer);	sound_GetError();	alBufferData(buffer, format, soundBuffer->data, soundBuffer->size, soundBuffer->frequency);	sound_GetError();	free(soundBuffer);	// save buffer name in track	psTrack->iBufferName = buffer;#endif	return psTrack;}

//*// =======================================================================================================================// =======================================================================================================================//BOOL sound_Play3DSample( TRACK *psTrack, AUDIO_SAMPLE *psSample ){#ifndef WZ_NOSOUND	ALfloat zero[3] = { 0.0, 0.0, 0.0 };	ALfloat volume;	ALint error;	if (sfx3d_volume == 0.0)	{		return false;	}	volume = ((float)psTrack->iVol / 100.f);		// max range is 0-100	psSample->fVol = volume;						// store results for later	// If we can't hear it, then don't bother playing it.	if (volume == 0.0f)	{		return false;	}	// Clear error codes	alGetError();	alGenSources( 1, &(psSample->iSample) );	error = sound_GetError();	if (error != AL_NO_ERROR)	{		/* FIXME: We run out of OpenAL sources very quickly, so we		 * should handle the case where we've ran out of them.		 * Currently we don't do this, causing some unpleasant side		 * effects, e.g. crashing...		 */	}	// HACK: this is a workaround for a bug in the 64bit implementation of OpenAL on GNU/Linux	// The AL_PITCH value really should be 1.0.	alSourcef(psSample->iSample, AL_PITCH, 1.001f);	sound_SetObjectPosition( psSample );	alSourcefv( psSample->iSample, AL_VELOCITY, zero );	alSourcei( psSample->iSample, AL_BUFFER, psTrack->iBufferName );	alSourcei( psSample->iSample, AL_LOOPING, (sound_SetupChannel(psSample)) ? AL_TRUE : AL_FALSE );	// NOTE: this is only useful for debugging.#ifdef DEBUG	psSample->is3d = true;	psSample->isLooping = sound_TrackLooped(psSample->iTrack)? AL_TRUE : AL_FALSE;	memcpy(psSample->filename,psTrack->fileName, strlen(psTrack->fileName));	psSample->filename[strlen(psTrack->fileName)]='/0';#endif	// Clear error codes	alGetError();	alSourcePlay( psSample->iSample );	sound_GetError();#endif	return true;}

/** Destroy the given stream and release its associated resources. This function *  also handles calling of the /c onFinished callback function and closing of *  the PhysicsFS file handle. *  /param stream the stream to destroy */static void sound_DestroyStream(AUDIO_STREAM *stream){    ALint buffer_count;    ALuint *buffers;    ALint error;    // Stop the OpenAL source from playing    alSourceStop(stream->source);    error = sound_GetError();    if (error != AL_NO_ERROR)    {        // FIXME: We should really handle these errors.    }    // Retrieve the amount of buffers which were processed    alGetSourcei(stream->source, AL_BUFFERS_PROCESSED, &buffer_count);    error = sound_GetError();    if (error != AL_NO_ERROR)    {        /* FIXME: We're leaking memory and resources here when bailing         * out. But not doing so could cause stack overflows as a         * result of the below alloca() call (due to buffer_count not         * being properly initialised.         */        debug(LOG_SOUND, "alGetSourcei(AL_BUFFERS_PROCESSED) failed; bailing out...");        return;    }    // Detach all buffers and retrieve their ID numbers    buffers = (ALuint *)alloca(buffer_count * sizeof(ALuint));    alSourceUnqueueBuffers(stream->source, buffer_count, buffers);    sound_GetError();    // Destroy all of these buffers    alDeleteBuffers(buffer_count, buffers);    sound_GetError();    // Destroy the OpenAL source    alDeleteSources(1, &stream->source);    sound_GetError();    // Destroy the sound decoder    sound_DestroyOggVorbisDecoder(stream->decoder);    // Now close the file    PHYSFS_close(stream->fileHandle);    // Now call the finished callback    if (stream->onFinished)    {        stream->onFinished(stream->user_data);    }    // Free the memory used by this stream    free(stream);}

void sound_FreeTrack( TRACK *psTrack ){#ifndef WZ_NOSOUND	alDeleteBuffers(1, &psTrack->iBufferName);	sound_GetError();#endif}

//*// =======================================================================================================================// =======================================================================================================================//void sound_ResumeSample( AUDIO_SAMPLE *psSample ){#ifndef WZ_NOSOUND	alSourcePlay( psSample->iSample );	sound_GetError();#endif}

void sound_SetPlayerPos(Vector3f pos){#ifndef WZ_NOSOUND	alListener3f(AL_POSITION, pos.x, pos.y, pos.z);	sound_GetError();#endif}

/** Retrieve the playing volume of the given stream. * *  @param stream the stream to retrieve the volume for. * *  @return a floating point value between 0.f and 1.f, representing this *          stream's volume. */float sound_GetStreamVolume(const AUDIO_STREAM *stream){    ALfloat volume;    alGetSourcef(stream->source, AL_GAIN, &volume);    sound_GetError();    return volume;}

/** Set the playing volume of the given stream. * *  @param stream the stream to change the volume for. *  @param volume a floating point value between 0.f and 1.f, to use as this *                @c stream's volume. */void sound_SetStreamVolume(AUDIO_STREAM* stream, float volume){	stream->volume = volume;#if !defined(WZ_NOSOUND)	alSourcef(stream->source, AL_GAIN, stream->volume);	sound_GetError();#endif}

//*// =======================================================================================================================// Compute the sample's volume relative to AL_POSITION.// =======================================================================================================================//void sound_SetObjectPosition(AUDIO_SAMPLE *psSample){#ifndef WZ_NOSOUND	//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~	// coordinates	float	listenerX, listenerY, listenerZ, dX, dY, dZ;	// calculation results	float	distance, gain;	//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~	// only set it when we have a valid sample	if (!psSample)	{		return;	}	// compute distance	alGetListener3f( AL_POSITION, &listenerX, &listenerY, &listenerZ );	sound_GetError();	dX = psSample->x  - listenerX; // distances on all axis	dY = psSample->y - listenerY;	dZ = psSample->z - listenerZ;	distance = sqrtf(dX * dX + dY * dY + dZ * dZ); // Pythagorean theorem	// compute gain	gain = (1.0f - (distance * ATTENUATION_FACTOR)) * psSample->fVol * sfx3d_volume;	// max volume	if (gain > 1.0f)	{		gain = 1.0f;	}	if (gain < 0.0f)	{		// this sample can't be heard right now		gain = 0.0f;	}	alSourcef( psSample->iSample, AL_GAIN, gain );	// the alSource3i variant would be better, if it wouldn't provide linker errors however	alSource3f( psSample->iSample, AL_POSITION, (float)psSample->x,(float)psSample->y,(float)psSample->z );	sound_GetError();#endif	return;}

/** Resumes playing of a stream that's paused by means of sound_PauseStream(). *  /param stream the stream to resume playing for */void sound_ResumeStream(AUDIO_STREAM *stream){    ALint state;    // To be sure we won't go mutilating this OpenAL source, check wether    // it's paused first.    alGetSourcei(stream->source, AL_SOURCE_STATE, &state);    sound_GetError();    if (state != AL_PAUSED)    {        return;    }    // Resume playing of this OpenAL source    alSourcePlay(stream->source);    sound_GetError();}

/** Pauses playing of this stream until playing is resumed with *  sound_ResumeStream() or completely stopped with sound_StopStream(). *  /param stream the stream to pause playing for */void sound_PauseStream(AUDIO_STREAM *stream){	ALint state;	// To be sure we won't go mutilating this OpenAL source, check whether	// it's playing first.	alGetSourcei(stream->source, AL_SOURCE_STATE, &state);	sound_GetError();	if (state != AL_PLAYING)	{		return;	}	// Pause playing of this OpenAL source	alSourcePause(stream->source);	sound_GetError();}

/** Stops the current stream from playing. *  /param stream the stream to stop *  /post The stopped stream will be destroyed on the next invocation of *        sound_UpdateStreams(). So calling this function will result in the *        /c onFinished callback being called and the /c stream pointer becoming *        invalid. */void sound_StopStream(AUDIO_STREAM *stream){    assert(stream != NULL);    alGetError();	// clear error codes    // Tell OpenAL to stop playing on the given source    alSourceStop(stream->source);    sound_GetError();}

/** * Sets the player's orientation to use for sound * /param angle the angle in radians @NOTE the up vector is swapped because of qsound idiosyncrasies @FIXME we don't use qsound, but it still is in qsound 'format'...*/void sound_SetPlayerOrientation(float angle){    const ALfloat ori[6] =    {        -sinf(angle), cosf(angle), 0.0f,	// forward (at) vector        0.0f, 0.0f, 1.0f,					// up vector    };    alListenerfv(AL_ORIENTATION, ori);    sound_GetError();}

/** * Sets the player's orientation to use for sound * /param forward forward pointing vector * /param up      upward pointing vector */void sound_SetPlayerOrientationVector(Vector3f forward, Vector3f up){    const ALfloat ori[6] =    {        forward.x, forward.y, forward.z,        up.x,      up.y,      up.z,    };    alListenerfv(AL_ORIENTATION, ori);    sound_GetError();}

//*// =======================================================================================================================// =======================================================================================================================//bool sound_SampleIsFinished(AUDIO_SAMPLE *psSample){    ALenum	state;    alGetSourcei(psSample->iSample, AL_SOURCE_STATE, &state);    sound_GetError(); // check for an error and clear the error state for later on in this function    if (state == AL_PLAYING || state == AL_PAUSED)    {        return false;    }    if (psSample->iSample != (ALuint)AL_INVALID)    {        alDeleteSources(1, &(psSample->iSample));        sound_GetError();        psSample->iSample = AL_INVALID;    }    return true;}

/** Retrieve the playing volume of the given stream. * *  @param stream the stream to retrieve the volume for. * *  @return a floating point value between 0.f and 1.f, representing this *          stream's volume. */float sound_GetStreamVolume(const AUDIO_STREAM* stream){#if !defined(WZ_NOSOUND)	ALfloat volume;	alGetSourcef(stream->source, AL_GAIN, &volume);	sound_GetError();	return volume;#else	return 1.f;#endif}

//*// =======================================================================================================================// =======================================================================================================================//void sound_StopSample(AUDIO_SAMPLE *psSample){    if (psSample->iSample == (ALuint)SAMPLE_NOT_ALLOCATED)    {        debug(LOG_SOUND, "sound_StopSample: sample number (%u) out of range, we probably have run out of available OpenAL sources", psSample->iSample);        return;    }    alGetError();	// clear error codes    // Tell OpenAL to stop playing the given sample    alSourceStop(psSample->iSample);    sound_GetError();}

//*// =======================================================================================================================// =======================================================================================================================//bool sound_QueueSamplePlaying(void){    ALenum	state;    if (!openal_initialized)    {        return false;    }    if (current_queue_sample == (ALuint)AL_INVALID)    {        return false;    }    alGetSourcei(current_queue_sample, AL_SOURCE_STATE, &state);    // Check whether an error occurred while retrieving the state.    // If one did, the state returned is useless. So instead of    // using it return false.    if (sound_GetError() != AL_NO_ERROR)    {        return false;    }    if (state == AL_PLAYING)    {        return true;    }    if (current_queue_sample != (ALuint)AL_INVALID)    {        SAMPLE_LIST *node = active_samples;        SAMPLE_LIST *previous = NULL;        // We need to remove it from the queue of actively played samples        while (node != NULL)        {            if (node->curr->iSample == current_queue_sample)            {                sound_DestroyIteratedSample(&previous, &node);                current_queue_sample = AL_INVALID;                return false;            }            previous = node;            if (node)            {                node = node->next;            }        }        debug(LOG_ERROR, "Sample %u not deleted because it wasn't in the active queue!", current_queue_sample);        current_queue_sample = AL_INVALID;    }    return false;}

/** Update the given stream by making sure its buffers remain full *  /param stream the stream to update *  /return true when the stream is still playing, false when it has stopped */static bool sound_UpdateStream(AUDIO_STREAM *stream){    ALint state, buffer_count;    alGetSourcei(stream->source, AL_SOURCE_STATE, &state);    sound_GetError();    if (state != AL_PLAYING && state != AL_PAUSED)    {        return false;    }    // Retrieve the amount of buffers which were processed and need refilling    alGetSourcei(stream->source, AL_BUFFERS_PROCESSED, &buffer_count);    sound_GetError();    // Refill and reattach all buffers    for (; buffer_count != 0; --buffer_count)    {        soundDataBuffer *soundBuffer;        ALuint buffer;        // Retrieve the buffer to work on        alSourceUnqueueBuffers(stream->source, 1, &buffer);        sound_GetError();        // Decode some data to stuff in our buffer        soundBuffer = sound_DecodeOggVorbis(stream->decoder, stream->bufferSize);        // If we actually decoded some data        if (soundBuffer && soundBuffer->size > 0)        {            // Determine PCM data format            ALenum format = (soundBuffer->channelCount == 1) ? AL_FORMAT_MONO16 : AL_FORMAT_STEREO16;            // Insert the data into the buffer            alBufferData(buffer, format, soundBuffer->data, soundBuffer->size, soundBuffer->frequency);            sound_GetError();            // Reattach the buffer to the source            alSourceQueueBuffers(stream->source, 1, &buffer);            sound_GetError();        }        else        {            // If no data has been decoded we're probably at the end of our            // stream. So cleanup this buffer.            // Then remove OpenAL's buffer            alDeleteBuffers(1, &buffer);            sound_GetError();        }        // Now remove the data buffer itself        free(soundBuffer);    }    return true;}

/** Checks if the stream is playing. *  /param stream the stream to check *  /post true if playing, false otherwise. * */bool sound_isStreamPlaying(AUDIO_STREAM *stream){    ALint state;    if (stream)    {        alGetSourcei(stream->source, AL_SOURCE_STATE, &state);        sound_GetError();        if (state == AL_PLAYING)        {            return true;        }    }    return false;}

/** Deletes the given sample and updates the /c previous and /c current iterators *  /param previous iterator to the previous sample in the list *  /param sample iterator to the current sample in the list which you want to delete */static void sound_DestroyIteratedSample(SAMPLE_LIST **previous, SAMPLE_LIST **sample){    // If an OpenAL source is associated with this sample, release it    if ((*sample)->curr->iSample != (ALuint)AL_INVALID)    {        alDeleteSources(1, &(*sample)->curr->iSample);        sound_GetError();    }    // Do the cleanup of this sample    sound_FinishedCallback((*sample)->curr);    // Remove the sample from the list    sound_RemoveSample(*previous, *sample);    // Free it    free(*sample);    // Get a pointer to the next node, the previous pointer doesn't change    *sample = (*previous != NULL) ? (*previous)->next : active_samples;}

void sound_SetPlayerPos(Vector3f pos){    alListener3f(AL_POSITION, pos.x, pos.y, pos.z);    sound_GetError();}

//*// =======================================================================================================================// =======================================================================================================================//bool sound_InitLibrary(void){    int err;    const ALfloat listenerVel[3] = { 0.0, 0.0, 0.0 };    const ALfloat listenerOri[6] = { 0.0, 0.0, 1.0, 0.0, 1.0, 0.0 };    char buf[512];    const ALCchar *deviceName;#if 0    // This code is disabled because enumerating devices apparently crashes PulseAudio on Fedora12    /* Get the available devices and print them.     * Devices are separated by NUL chars ('/0') and the list of devices is     * terminated by two NUL chars.     */    deviceName = alcGetString(NULL, ALC_DEVICE_SPECIFIER);    while (deviceName != NULL && *deviceName != '/0')    {        debug(LOG_SOUND, "available OpenAL device(s) are: %s", deviceName);        deviceName += strlen(deviceName) + 1;    }#endif#ifdef WZ_OS_WIN    /* HACK: Select the "software" OpenAL device on Windows because it     *       provides 256 sound sources (unlike most Creative's default     *       which provides only 16), causing our lack of source-management     *       to be significantly less noticeable.     */    device = alcOpenDevice("Generic Software");    // If the software device isn't available, fall back to default    if (!device)#endif    {        // Open default device        device = alcOpenDevice(NULL);    }    if (!device)    {        debug(LOG_ERROR, "Couldn't open audio device.");        return false;    }    // Print current device name and add it to dump info    deviceName = alcGetString(device, ALC_DEVICE_SPECIFIER);    debug(LOG_SOUND, "Current audio device: %s", deviceName);    ssprintf(buf, "OpenAL Device Name: %s", deviceName);    addDumpInfo(buf);    context = alcCreateContext(device, NULL);		//NULL was contextAttributes    if (!context)    {        debug(LOG_ERROR, "Couldn't open audio context.");        return false;    }    alcMakeContextCurrent(context);    err = sound_GetContextError(device);    if (err != ALC_NO_ERROR)    {        debug(LOG_ERROR, "Couldn't initialize audio context: %s", alcGetString(device, err));        return false;    }    // Dump Open AL device info (depends on context)    // to the crash handler for the dump file and debug log    ssprintf(buf, "OpenAL Vendor: %s", alGetString(AL_VENDOR));    addDumpInfo(buf);    debug(LOG_SOUND, "%s", buf);    ssprintf(buf, "OpenAL Version: %s", alGetString(AL_VERSION));    addDumpInfo(buf);    debug(LOG_SOUND, "%s", buf);    ssprintf(buf, "OpenAL Renderer: %s", alGetString(AL_RENDERER));    addDumpInfo(buf);    debug(LOG_SOUND, "%s", buf);    ssprintf(buf, "OpenAL Extensions: %s", alGetString(AL_EXTENSIONS));    addDumpInfo(buf);    debug(LOG_SOUND, "%s", buf);    openal_initialized = true;    // Clear Error Codes    alGetError();    alcGetError(device);    alListener3f(AL_POSITION, 0.f, 0.f, 0.f);    alListenerfv(AL_VELOCITY, listenerVel);    alListenerfv(AL_ORIENTATION, listenerOri);    alDistanceModel(AL_NONE);    sound_GetError();//.........这里部分代码省略.........

/** Plays the audio data from the given file *  /param fileHandle,volume,onFinished,user_data see sound_PlayStream() *  /param streamBufferSize the size to use for the decoded audio buffers *  /param buffer_count the amount of audio buffers to use *  /see sound_PlayStream() for details about the rest of the function *       parameters and other details. */AUDIO_STREAM *sound_PlayStreamWithBuf(PHYSFS_file *fileHandle, float volume, void (*onFinished)(void *), void *user_data, size_t streamBufferSize, unsigned int buffer_count){    AUDIO_STREAM *stream;    ALuint       *buffers = (ALuint *)alloca(sizeof(ALuint) * buffer_count);    ALint error;    unsigned int i;    if (!openal_initialized)    {        debug(LOG_WARNING, "OpenAL isn't initialized, not creating an audio stream");        return NULL;    }    stream = (AUDIO_STREAM *)malloc(sizeof(AUDIO_STREAM));    if (stream == NULL)    {        debug(LOG_FATAL, "sound_PlayStream: Out of memory");        abort();        return NULL;    }    // Clear error codes    alGetError();    // Retrieve an OpenAL sound source    alGenSources(1, &(stream->source));    error = sound_GetError();    if (error != AL_NO_ERROR)    {        // Failed to create OpenAL sound source, so bail out...        debug(LOG_SOUND, "alGenSources failed, most likely out of sound sources");        free(stream);        return NULL;    }    stream->fileHandle = fileHandle;    stream->decoder = sound_CreateOggVorbisDecoder(stream->fileHandle, false);    if (stream->decoder == NULL)    {        debug(LOG_ERROR, "sound_PlayStream: Failed to open audio file for decoding");        free(stream);        return NULL;    }    stream->volume = volume;    stream->bufferSize = streamBufferSize;    alSourcef(stream->source, AL_GAIN, stream->volume);    // HACK: this is a workaround for a bug in the 64bit implementation of OpenAL on GNU/Linux    // The AL_PITCH value really should be 1.0.    alSourcef(stream->source, AL_PITCH, 1.001f);    // Create some OpenAL buffers to store the decoded data in    alGenBuffers(buffer_count, buffers);    sound_GetError();    // Fill some buffers with audio data    for (i = 0; i < buffer_count; ++i)    {        // Decode some audio data        soundDataBuffer *soundBuffer = sound_DecodeOggVorbis(stream->decoder, stream->bufferSize);        // If we actually decoded some data        if (soundBuffer && soundBuffer->size > 0)        {            // Determine PCM data format            ALenum format = (soundBuffer->channelCount == 1) ? AL_FORMAT_MONO16 : AL_FORMAT_STEREO16;            // Copy the audio data into one of OpenAL's own buffers            alBufferData(buffers[i], format, soundBuffer->data, soundBuffer->size, soundBuffer->frequency);            sound_GetError();            // Clean up our memory            free(soundBuffer);        }        else        {            // If no data has been decoded we're probably at the end of our            // stream. So cleanup the excess stuff here.            // First remove the data buffer itself            free(soundBuffer);            // Then remove OpenAL's buffers            alDeleteBuffers(buffer_count - i, &buffers[i]);            sound_GetError();            break;        }    }//.........这里部分代码省略.........

//*// =======================================================================================================================// =======================================================================================================================//bool sound_Play2DSample(TRACK *psTrack, AUDIO_SAMPLE *psSample, bool bQueued){    ALfloat zero[3] = { 0.0, 0.0, 0.0 };    ALfloat volume;    ALint error;    if (sfx_volume == 0.0)    {        return false;    }    volume = ((float)psTrack->iVol / 100.0f);		// each object can have OWN volume!    psSample->fVol = volume;						// save computed volume    volume *= sfx_volume;							// and now take into account the Users sound Prefs.    // We can't hear it, so don't bother creating it.    if (volume == 0.0f)    {        return false;    }    // Clear error codes    alGetError();    alGenSources(1, &(psSample->iSample));    error = sound_GetError();    if (error != AL_NO_ERROR)    {        /* FIXME: We run out of OpenAL sources very quickly, so we         * should handle the case where we've ran out of them.         * Currently we don't do this, causing some unpleasant side         * effects, e.g. crashing...         */    }    alSourcef(psSample->iSample, AL_PITCH, 1.0f);    alSourcef(psSample->iSample, AL_GAIN, volume);    alSourcefv(psSample->iSample, AL_POSITION, zero);    alSourcefv(psSample->iSample, AL_VELOCITY, zero);    alSourcei(psSample->iSample, AL_BUFFER, psTrack->iBufferName);    alSourcei(psSample->iSample, AL_SOURCE_RELATIVE, AL_TRUE);    alSourcei(psSample->iSample, AL_LOOPING, (sound_SetupChannel(psSample)) ? AL_TRUE : AL_FALSE);    // NOTE: this is only useful for debugging.#ifdef DEBUG    psSample->is3d = false;    psSample->isLooping = sound_TrackLooped(psSample->iTrack) ? AL_TRUE : AL_FALSE;    memcpy(psSample->filename, psTrack->fileName, strlen(psTrack->fileName));    psSample->filename[strlen(psTrack->fileName)] = '/0';#endif    // Clear error codes    alGetError();    alSourcePlay(psSample->iSample);    sound_GetError();    if (bQueued)    {        current_queue_sample = psSample->iSample;    }    else if (current_queue_sample == psSample->iSample)    {        current_queue_sample = -1;    }    return true;}

void sound_FreeTrack(TRACK *psTrack){    alDeleteBuffers(1, &psTrack->iBufferName);    sound_GetError();}

//*// =======================================================================================================================// =======================================================================================================================//void sound_PauseSample(AUDIO_SAMPLE *psSample){    alSourcePause(psSample->iSample);    sound_GetError();}

void sound_Update(){    SAMPLE_LIST *node = active_samples;    SAMPLE_LIST *previous = NULL;    ALCenum err;    ALfloat gain;    if (!openal_initialized)    {        return;    }    // Update all streaming audio    sound_UpdateStreams();    while (node != NULL)    {        ALenum state, err;        // query what the gain is for this sample        alGetSourcef(node->curr->iSample, AL_GAIN, &gain);        err = sound_GetError();        // if gain is 0, then we can't hear it, so we kill it.        if (gain == 0.0f)        {            sound_DestroyIteratedSample(&previous, &node);            continue;        }        //ASSERT(alIsSource(node->curr->iSample), "Not a valid source!");        alGetSourcei(node->curr->iSample, AL_SOURCE_STATE, &state);        // Check whether an error occurred while retrieving the state.        // If one did, the state returned is useless. So instead of        // using it continue with the next sample.        err = sound_GetError();        if (err != AL_NO_ERROR)        {            // Make sure to invoke the "finished" callback            sound_FinishedCallback(node->curr);            // Destroy this object and move to the next object            sound_DestroyIteratedSample(&previous, &node);            continue;        }        switch (state)        {        case AL_PLAYING:        case AL_PAUSED:            // If we haven't finished playing yet, just            // continue with the next item in the list.            // sound_SetObjectPosition(i->curr->iSample, i->curr->x, i->curr->y, i->curr->z);            // Move to the next object            previous = node;            node = node->next;            break;        // NOTE: if it isn't playing | paused, then it is most likely either done        // or a error.  In either case, we want to kill the sample in question.        default:            sound_DestroyIteratedSample(&previous, &node);            break;        }    }    // Reset the current error state    alcGetError(device);    alcProcessContext(context);    err = sound_GetContextError(device);    if (err != ALC_NO_ERROR)    {        debug(LOG_ERROR, "Error while processing audio context: %s", alGetString(err));    }}

/** Set the playing volume of the given stream. * *  @param stream the stream to change the volume for. *  @param volume a floating point value between 0.f and 1.f, to use as this *                @c stream's volume. */void sound_SetStreamVolume(AUDIO_STREAM *stream, float volume){    stream->volume = volume;    alSourcef(stream->source, AL_GAIN, stream->volume);    sound_GetError();}

//*// =======================================================================================================================// =======================================================================================================================//void sound_ResumeSample(AUDIO_SAMPLE *psSample){    alSourcePlay(psSample->iSample);    sound_GetError();}