/*

    SDL - Simple DirectMedia Layer

    Copyright (C) 1997-2006 Sam Lantinga

    This library is free software; you can redistribute it and/or

    modify it under the terms of the GNU Lesser General Public

    License as published by the Free Software Foundation; either

    version 2.1 of the License, or (at your option) any later version.

    This library 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

    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public

    License along with this library; if not, write to the Free Software

    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

    Sam Lantinga

    slouken@libsdl.org

*/

#include "SDL_config.h"

/* Allow access to a raw mixing buffer */

#include "SDL.h"

#include "SDL_audio_c.h"

#include "SDL_audiomem.h"

#include "SDL_sysaudio.h"

#define _THIS	SDL_AudioDevice *this

static SDL_AudioDriver current_audio;

static SDL_AudioDevice *open_devices[16];

/* !!! FIXME: These are wordy and unlocalized... */

#define DEFAULT_OUTPUT_DEVNAME "System audio output device"

#define DEFAULT_INPUT_DEVNAME "System audio capture device"

/*

 * Not all of these will be compiled and linked in, but it's convenient

 *  to have a complete list here and saves yet-another block of #ifdefs...

 *  Please see bootstrap[], below, for the actual #ifdef mess.

 */

extern AudioBootStrap BSD_AUDIO_bootstrap;

extern AudioBootStrap DSP_bootstrap;

extern AudioBootStrap DMA_bootstrap;

extern AudioBootStrap ALSA_bootstrap;

extern AudioBootStrap PULSEAUDIO_bootstrap;

extern AudioBootStrap QNXNTOAUDIO_bootstrap;

extern AudioBootStrap SUNAUDIO_bootstrap;

extern AudioBootStrap DMEDIA_bootstrap;

extern AudioBootStrap ARTS_bootstrap;

extern AudioBootStrap ESD_bootstrap;

extern AudioBootStrap NAS_bootstrap;

extern AudioBootStrap DSOUND_bootstrap;

extern AudioBootStrap WINWAVEOUT_bootstrap;

extern AudioBootStrap PAUDIO_bootstrap;

extern AudioBootStrap BEOSAUDIO_bootstrap;

extern AudioBootStrap COREAUDIO_bootstrap;

extern AudioBootStrap SNDMGR_bootstrap;

extern AudioBootStrap MINTAUDIO_GSXB_bootstrap;

extern AudioBootStrap MINTAUDIO_MCSN_bootstrap;

extern AudioBootStrap MINTAUDIO_STFA_bootstrap;

extern AudioBootStrap MINTAUDIO_XBIOS_bootstrap;

extern AudioBootStrap MINTAUDIO_DMA8_bootstrap;

extern AudioBootStrap DISKAUD_bootstrap;

extern AudioBootStrap DUMMYAUD_bootstrap;

extern AudioBootStrap DCAUD_bootstrap;

extern AudioBootStrap MMEAUDIO_bootstrap;

extern AudioBootStrap DART_bootstrap;

/* Available audio drivers */

static AudioBootStrap *bootstrap[] = {

#if SDL_AUDIO_DRIVER_BSD

    &BSD_AUDIO_bootstrap,

#endif

#if SDL_AUDIO_DRIVER_OSS

    &DSP_bootstrap,

    &DMA_bootstrap,

#endif

#if SDL_AUDIO_DRIVER_ALSA

    &ALSA_bootstrap,

#endif

#if SDL_AUDIO_DRIVER_PULSEAUDIO

    &PULSEAUDIO_bootstrap,

#endif

#if SDL_AUDIO_DRIVER_QNXNTO

    &QNXNTOAUDIO_bootstrap,

#endif

#if SDL_AUDIO_DRIVER_SUNAUDIO

    &SUNAUDIO_bootstrap,

#endif

#if SDL_AUDIO_DRIVER_DMEDIA

    &DMEDIA_bootstrap,

#endif

#if SDL_AUDIO_DRIVER_ARTS

    &ARTS_bootstrap,

#endif

#if SDL_AUDIO_DRIVER_ESD

    &ESD_bootstrap,

#endif

#if SDL_AUDIO_DRIVER_NAS

    &NAS_bootstrap,

#endif

#if SDL_AUDIO_DRIVER_DSOUND

    &DSOUND_bootstrap,

#endif

#if SDL_AUDIO_DRIVER_WINWAVEOUT

    &WINWAVEOUT_bootstrap,

#endif

#if SDL_AUDIO_DRIVER_PAUDIO

    &PAUDIO_bootstrap,

#endif

#if SDL_AUDIO_DRIVER_BEOSAUDIO

    &BEOSAUDIO_bootstrap,

#endif

#if SDL_AUDIO_DRIVER_COREAUDIO

    &COREAUDIO_bootstrap,

#endif

#if SDL_AUDIO_DRIVER_SNDMGR

    &SNDMGR_bootstrap,

#endif

#if SDL_AUDIO_DRIVER_MINT

    &MINTAUDIO_GSXB_bootstrap,

    &MINTAUDIO_MCSN_bootstrap,

    &MINTAUDIO_STFA_bootstrap,

    &MINTAUDIO_XBIOS_bootstrap,

    &MINTAUDIO_DMA8_bootstrap,

#endif

#if SDL_AUDIO_DRIVER_DISK

    &DISKAUD_bootstrap,

#endif

#if SDL_AUDIO_DRIVER_DUMMY

    &DUMMYAUD_bootstrap,

#endif

#if SDL_AUDIO_DRIVER_DC

    &DCAUD_bootstrap,

#endif

#if SDL_AUDIO_DRIVER_MMEAUDIO

    &MMEAUDIO_bootstrap,

#endif

#if SDL_AUDIO_DRIVER_DART

    &DART_bootstrap,

#endif

    NULL

};

static SDL_AudioDevice *

get_audio_device(SDL_AudioDeviceID id)

{

    id--;

    if ((id >= SDL_arraysize(open_devices)) || (open_devices[id] == NULL)) {

        SDL_SetError("Invalid audio device ID");

        return NULL;

    }

    return open_devices[id];

}

/* stubs for audio drivers that don't need a specific entry point... */

static int

SDL_AudioDetectDevices_Default(int iscapture)

{

    return -1;

}

static void

SDL_AudioThreadInit_Default(_THIS)

{                               /* no-op. */

}

static void

SDL_AudioWaitDevice_Default(_THIS)

{                               /* no-op. */

}

static void

SDL_AudioPlayDevice_Default(_THIS)

{                               /* no-op. */

}

static Uint8 *

SDL_AudioGetDeviceBuf_Default(_THIS)

{

    return NULL;

}

static void

SDL_AudioWaitDone_Default(_THIS)

{                               /* no-op. */

}

static void

SDL_AudioCloseDevice_Default(_THIS)

{                               /* no-op. */

}

static void

SDL_AudioDeinitialize_Default(void)

{                               /* no-op. */

}

static int

SDL_AudioOpenDevice_Default(_THIS, const char *devname, int iscapture)

{

    return 0;

}

static const char *

SDL_AudioGetDeviceName_Default(int index, int iscapture)

{

    SDL_SetError("No such device");

    return NULL;

}

static void

SDL_AudioLockDevice_Default(SDL_AudioDevice * device)

{

    if (device->thread && (SDL_ThreadID() == device->threadid)) {

        return;

    }

    SDL_mutexP(device->mixer_lock);

}

static void

SDL_AudioUnlockDevice_Default(SDL_AudioDevice * device)

{

    if (device->thread && (SDL_ThreadID() == device->threadid)) {

        return;

    }

    SDL_mutexV(device->mixer_lock);

}

static void

finalize_audio_entry_points(void)

{

    /*

     * Fill in stub functions for unused driver entry points. This lets us

     *  blindly call them without having to check for validity first.

     */

#define FILL_STUB(x) \

        if (current_audio.impl.x == NULL) { \

            current_audio.impl.x = SDL_Audio##x##_Default; \

        }

    FILL_STUB(DetectDevices);

    FILL_STUB(GetDeviceName);

    FILL_STUB(OpenDevice);

    FILL_STUB(ThreadInit);

    FILL_STUB(WaitDevice);

    FILL_STUB(PlayDevice);

    FILL_STUB(GetDeviceBuf);

    FILL_STUB(WaitDone);

    FILL_STUB(CloseDevice);

    FILL_STUB(LockDevice);

    FILL_STUB(UnlockDevice);

    FILL_STUB(Deinitialize);

#undef FILL_STUB

}

/* The general mixing thread function */

int SDLCALL

SDL_RunAudio(void *devicep)

{

    SDL_AudioDevice *device = (SDL_AudioDevice *) devicep;

    Uint8 *stream;

    int stream_len;

    void *udata;

    void (SDLCALL * fill) (void *userdata, Uint8 * stream, int len);

    int silence;

    /* Perform any thread setup */

    device->threadid = SDL_ThreadID();

    current_audio.impl.ThreadInit(device);

    /* Set up the mixing function */

    fill = device->spec.callback;

    udata = device->spec.userdata;

    if (device->convert.needed) {

        if (device->convert.src_format == AUDIO_U8) {

            silence = 0x80;

        } else {

            silence = 0;

        }

        stream_len = device->convert.len;

    } else {

        silence = device->spec.silence;

        stream_len = device->spec.size;

    }

    /* Loop, filling the audio buffers */

    while (device->enabled) {

        /* Fill the current buffer with sound */

        if (device->convert.needed) {

            if (device->convert.buf) {

                stream = device->convert.buf;

            } else {

                continue;

            }

        } else {

            stream = current_audio.impl.GetDeviceBuf(device);

            if (stream == NULL) {

                stream = device->fake_stream;

            }

        }

        if (!device->paused) {

            SDL_mutexP(device->mixer_lock);

            (*fill) (udata, stream, stream_len);

            SDL_mutexV(device->mixer_lock);

        }

        /* Convert the audio if necessary */

        if (device->convert.needed) {

            SDL_ConvertAudio(&device->convert);

            stream = current_audio.impl.GetDeviceBuf(device);

            if (stream == NULL) {

                stream = device->fake_stream;

            }

            SDL_memcpy(stream, device->convert.buf, device->convert.len_cvt);

        }

        /* Ready current buffer for play and change current buffer */

        if (stream != device->fake_stream) {

            current_audio.impl.PlayDevice(device);

        }

        /* Wait for an audio buffer to become available */

        if (stream == device->fake_stream) {

            SDL_Delay((device->spec.samples * 1000) / device->spec.freq);

        } else {

            current_audio.impl.WaitDevice(device);

        }

    }

    /* Wait for the audio to drain.. */

    current_audio.impl.WaitDone(device);

    return (0);

}

static SDL_AudioFormat

SDL_ParseAudioFormat(const char *string)

{

#define CHECK_FMT_STRING(x) if (SDL_strcmp(string, #x) == 0) return AUDIO_##x

    CHECK_FMT_STRING(U8);

    CHECK_FMT_STRING(S8);

    CHECK_FMT_STRING(U16LSB);

    CHECK_FMT_STRING(S16LSB);

    CHECK_FMT_STRING(U16MSB);

    CHECK_FMT_STRING(S16MSB);

    CHECK_FMT_STRING(U16SYS);

    CHECK_FMT_STRING(S16SYS);

    CHECK_FMT_STRING(U16);

    CHECK_FMT_STRING(S16);

    CHECK_FMT_STRING(S32LSB);

    CHECK_FMT_STRING(S32MSB);

    CHECK_FMT_STRING(S32SYS);

    CHECK_FMT_STRING(S32);

    CHECK_FMT_STRING(F32LSB);

    CHECK_FMT_STRING(F32MSB);

    CHECK_FMT_STRING(F32SYS);

    CHECK_FMT_STRING(F32);

#undef CHECK_FMT_STRING

    return 0;

}

int

SDL_GetNumAudioDrivers(void)

{

    return (SDL_arraysize(bootstrap) - 1);

}

const char *

SDL_GetAudioDriver(int index)

{

    if (index >= 0 && index < SDL_GetNumAudioDrivers()) {

        return (bootstrap[index]->name);

    }

    return (NULL);

}

int

SDL_AudioInit(const char *driver_name)

{

    int i = 0;

    int initialized = 0;

    int tried_to_init = 0;

    if (SDL_WasInit(SDL_INIT_AUDIO)) {

        SDL_AudioQuit();        /* shutdown driver if already running. */

    }

    SDL_memset(&current_audio, '\0', sizeof(current_audio));

    SDL_memset(open_devices, '\0', sizeof(open_devices));

    /* Select the proper audio driver */

    if (driver_name == NULL) {

        driver_name = SDL_getenv("SDL_AUDIODRIVER");

    }

    for (i = 0; (!initialized) && (bootstrap[i]); ++i) {

        /* make sure we should even try this driver before doing so... */

        const AudioBootStrap *backend = bootstrap[i];

        if (((driver_name) && (SDL_strcasecmp(backend->name, driver_name))) ||

            ((!driver_name) && (backend->demand_only))) {

            continue;

        }

        tried_to_init = 1;

        SDL_memset(&current_audio, 0, sizeof(current_audio));

        current_audio.name = backend->name;

        current_audio.desc = backend->desc;

        initialized = backend->init(&current_audio.impl);

    }

    if (!initialized) {

        /* specific drivers will set the error message if they fail... */

        if (!tried_to_init) {

            if (driver_name) {

                SDL_SetError("%s not available", driver_name);

            } else {

                SDL_SetError("No available audio device");

            }

        }

        SDL_memset(&current_audio, 0, sizeof(current_audio));

        return (-1);            /* No driver was available, so fail. */

    }

    finalize_audio_entry_points();

    return (0);

}

/*

 * Get the current audio driver name

 */

const char *

SDL_GetCurrentAudioDriver()

{

    return current_audio.name;

}

int

SDL_GetNumAudioDevices(int iscapture)

{

    if (!SDL_WasInit(SDL_INIT_AUDIO)) {

        return -1;

    }

    if ((iscapture) && (!current_audio.impl.HasCaptureSupport)) {

        return 0;

    }

    if ((iscapture) && (current_audio.impl.OnlyHasDefaultInputDevice)) {

        return 1;

    }

    if ((!iscapture) && (current_audio.impl.OnlyHasDefaultOutputDevice)) {

        return 1;

    }

    return current_audio.impl.DetectDevices(iscapture);

}

const char *

SDL_GetAudioDeviceName(int index, int iscapture)

{

    if (!SDL_WasInit(SDL_INIT_AUDIO)) {

        SDL_SetError("Audio subsystem is not initialized");

        return NULL;

    }

    if ((iscapture) && (!current_audio.impl.HasCaptureSupport)) {

        SDL_SetError("No capture support");

        return NULL;

    }