audio.c

Go to the documentation of this file.

#ifdef USE_AUDIO
#include "text.h"
#include <assert.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <SDL_mixer.h>
#include "audio.h"

#ifdef _MSC_VER
// For some reason it seems Microsoft's math.h in Visual Studio 2003 only has
// prototypes for the fabsf and sqrtf functions for C++. Or maybe I did
// something wrong. I can't imagine this wouldn't be a major problem. The
// following macros are a workaround. The problem doesn't exist in Visual
// Studio 2005.
#ifndef fabsf
#define fabsf(x)  (float)fabs(x)
#endif
#ifndef sqrtf
#define sqrtf(x)  (float)sqrt(x)
#endif
#endif

#ifndef SAMPLE_RATE

#define SAMPLE_RATE  48000
#endif

static Bool enabled = FALSE;

static Mix_Chunk *sounds[SND_MAX] = { 0 };

static const char * const soundFiles[SND_MAX] = {
    "idle.wav",
    "move.wav",
    "shoot.wav",
    "death.wav",
};

Bool static LoadSound(const char *fname, int index) {
    // assure that not too many sounds load
    assert(index < SND_MAX);
    // attempt to load the sound
    if ((sounds[index] = Mix_LoadWAV(fname)) == NULL) {
        // failure
        return FALSE;
    }
    return TRUE;
}

Bool PlaySound(int snd, int chan, int count) {
    Mix_Chunk *sound = sounds[snd];
    // the sound must be valid
    assert(snd < SND_MAX);
    // assure this happens on a valid channel
    assert((chan >= 0) && (chan < SND_CH_MAX));
    // quit now if auido output is not enabled
    if (!enabled) return FALSE;
    // stop the channel from playing whatever it was doing last
    //Mix_HaltChannel(chan);
    // assure no effects, like that distance one
    Mix_UnregisterAllEffects(chan);
    // check for a bad sound (probably didn't load), and if it's good, play
    // the sound and check for error
    if ((sounds[snd] == NULL) || (((count >= 0) || !Mix_Playing(chan) ||
    (Mix_GetChunk(chan) != sound)) &&
    ((chan = Mix_PlayChannel(chan, sound, count)) == -1))) {
        return FALSE;
    }
    // success
    return TRUE;
}

Bool PlaySoundDist(int snd, int chan, int distsq, int count) {
    Mix_Chunk *sound = sounds[snd];
    // distance must be between 0 & MAX_SQ_DIST, inclusive
    assert((distsq >= 0) && (distsq <= MAX_SQ_DIST));
    // sound and channel must be valid
    assert((snd < SND_MAX) && (chan < SND_CH_MAX));
    // for infinitely looping sounds, a predetermined channel must be used
    assert(((count == -1) && (chan != -1)) || (count != -1));
    // quit now if auido output is not enabled
    if (!enabled) return FALSE;
    // is this a sound that was already playing?
    if ((chan != -1) && (count == -1) && Mix_Paused(chan)) {
        // resume playback
        Mix_Resume(chan);
    }
    // check for a bad sound (probably didn't load), and if it's good, play
    // the sound and check for error
    else if ((sounds[snd] == NULL) || (((chan == -1) || !Mix_Playing(chan) ||
    (Mix_GetChunk(chan) != sound)) &&
    ((chan = Mix_PlayChannel(chan, sound, count)) == -1))) {
        return FALSE;
    }
    // set distance
    if (distsq > 0) {
        // compute the distance value
        distsq = (int)(sqrtf((float)distsq) * (160.0f / 212.0f));
        // set it
        Mix_SetDistance(chan, distsq);
    }
    else {
        // clear distance
        Mix_UnregisterAllEffects(chan);
    }
    // all good!
    return TRUE;
}

Bool PlayLocalDeath() {
    // quit now if auido output is not enabled
    if (!enabled) return FALSE;
    // stop all other sounds
    Mix_HaltChannel(-1);
    // if the death sound was loaded, play it now
    if ((sounds[SND_DEATH] == NULL) ||
    (Mix_PlayChannel(SND_CH_TANK, sounds[SND_DEATH], 0) == -1)) {
        return FALSE;
    }
    return TRUE;
}

void PauseSound(int chan) {
    // assure a valid channel
    assert((chan >= 0) && (chan < SND_CH_RESERVE));
    // quit now if auido output is not enabled
    if (!enabled) return;
    // pause it
    Mix_Pause(chan);
}

void StopAllSounds() {
    // quit now if auido output is not enabled
    if (!enabled) return;
    // stop all channels
    Mix_HaltChannel(-1);
}

Bool InitAudio() {
    int loop, errs;
    // attempt to initalize audio
    if (Mix_OpenAudio(SAMPLE_RATE, AUDIO_S16SYS, 1, 1024) != 0) {
        // failed to open an audio output device
        prnfile(stderr, strings[STRING_ERR_OPENAUDIO], Mix_GetError());
        // failed
        return FALSE;
    }
    // get the mixing channels
    Mix_AllocateChannels(SND_CH_MAX);
    // reserver some
    Mix_ReserveChannels(SND_CH_RESERVE);
    // becuase this setup always uses the same sounds, load them all
    for (errs = 0, loop = 0; loop < SND_MAX; loop++) {
        // load and check for error
        if (!LoadSound(soundFiles[loop], loop)) {
            // faild to load
            prnfile(stderr, strings[STRING_ERR_LOADSND], soundFiles[loop]);
            errs++;
        }
    }
    // sounds are enabled, even if there is nothing to play
    enabled = TRUE;
    // did no sounds load?
    if (errs == SND_MAX) {
        // no sounds!
        prnfile(stderr, strings[STRING_ERR_NOSNDS]);
        // nothing to play, so signal a failure
        return FALSE;
    }
    // success
    return TRUE;
}

void UninitAudio() {
    int loop;
    // quit now if auido output is not enabled
    if (!enabled) return;
    // stop playing all sounds
    Mix_HaltChannel(-1);
    // free all sounds
    for (loop = 0; loop < SND_MAX; loop++) {
        // allocated sound?
        if (sounds[loop]) {
            // deallocate it
            Mix_FreeChunk(sounds[loop]);
            // mark it as gone
            sounds[loop] = NULL;
        }
    }
    // put down SDL_mixer
    Mix_CloseAudio();
    // audio system is no longer enabled
    enabled = FALSE;
}

#endif

---