/*

    SDL - Simple DirectMedia Layer

    Copyright (C) 1997-2010 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.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 QSAAUDIO_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 COREAUDIOIPHONE_bootstrap;

extern AudioBootStrap SNDMGR_bootstrap;

extern AudioBootStrap DISKAUD_bootstrap;

extern AudioBootStrap DUMMYAUD_bootstrap;

extern AudioBootStrap DCAUD_bootstrap;

extern AudioBootStrap MMEAUDIO_bootstrap;

extern AudioBootStrap DART_bootstrap;

extern AudioBootStrap NDSAUD_bootstrap;

extern AudioBootStrap FUSIONSOUND_bootstrap;

/* Available audio drivers */

static const AudioBootStrap *const bootstrap[] = {

#if SDL_AUDIO_DRIVER_PULSEAUDIO

    &PULSEAUDIO_bootstrap,

#endif

#if SDL_AUDIO_DRIVER_ALSA

    &ALSA_bootstrap,

#endif

#if SDL_AUDIO_DRIVER_OSS

    &DSP_bootstrap,

    &DMA_bootstrap,

#endif

#if SDL_AUDIO_DRIVER_QSA

    &QSAAUDIO_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_COREAUDIOIPHONE

    &COREAUDIOIPHONE_bootstrap,

#endif

#if SDL_AUDIO_DRIVER_DISK

    &DISKAUD_bootstrap,

#endif

#if SDL_AUDIO_DRIVER_DUMMY

    &DUMMYAUD_bootstrap,

#endif

#if SDL_AUDIO_DRIVER_MMEAUDIO

    &MMEAUDIO_bootstrap,

#endif

#if SDL_AUDIO_DRIVER_NDS

    &NDSAUD_bootstrap,

#endif

#if SDL_AUDIO_DRIVER_FUSIONSOUND

    &FUSIONSOUND_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

}

/* Streaming functions (for when the input and output buffer sizes are different) */

/* Write [length] bytes from buf into the streamer */

static void

SDL_StreamWrite(SDL_AudioStreamer * stream, Uint8 * buf, int length)

{

    int i;

    for (i = 0; i < length; ++i) {

        stream->buffer[stream->write_pos] = buf[i];

        ++stream->write_pos;

    }

}

/* Read [length] bytes out of the streamer into buf */

static void

SDL_StreamRead(SDL_AudioStreamer * stream, Uint8 * buf, int length)

{

    int i;

    for (i = 0; i < length; ++i) {

        buf[i] = stream->buffer[stream->read_pos];

        ++stream->read_pos;

    }

}

static int

SDL_StreamLength(SDL_AudioStreamer * stream)

{

    return (stream->write_pos - stream->read_pos) % stream->max_len;

}

/* Initialize the stream by allocating the buffer and setting the read/write heads to the beginning */

#if 0

static int

SDL_StreamInit(SDL_AudioStreamer * stream, int max_len, Uint8 silence)

{

    /* First try to allocate the buffer */

    stream->buffer = (Uint8 *) SDL_malloc(max_len);

    if (stream->buffer == NULL) {

        return -1;

    }

    stream->max_len = max_len;

    stream->read_pos = 0;

    stream->write_pos = 0;

    /* Zero out the buffer */

    SDL_memset(stream->buffer, silence, max_len);

    return 0;

}

#endif

/* Deinitialize the stream simply by freeing the buffer */

static void

SDL_StreamDeinit(SDL_AudioStreamer * stream)

{

    if (stream->buffer != NULL) {

        SDL_free(stream->buffer);

    }

}

/* 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;

    Uint32 delay;

    /* For streaming when the buffer sizes don't match up */

    Uint8 *istream;

    int istream_len;

    /* 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;

    /* By default do not stream */

    device->use_streamer = 0;

    if (device->convert.needed) {

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

            silence = 0x80;

        } else {

            silence = 0;

        }

#if 0                           /* !!! FIXME: I took len_div out of the structure. Use rate_incr instead? */

        /* If the result of the conversion alters the length, i.e. resampling is being used, use the streamer */

        if (device->convert.len_mult != 1 || device->convert.len_div != 1) {

            /* The streamer's maximum length should be twice whichever is larger: spec.size or len_cvt */

            stream_max_len = 2 * device->spec.size;

            if (device->convert.len_mult > device->convert.len_div) {

                stream_max_len *= device->convert.len_mult;

                stream_max_len /= device->convert.len_div;

            }

            if (SDL_StreamInit(&device->streamer, stream_max_len, silence) <

                0)

                return -1;

            device->use_streamer = 1;

            /* istream_len should be the length of what we grab from the callback and feed to conversion,

               so that we get close to spec_size. I.e. we want device.spec_size = istream_len * u / d

             */

            istream_len =

                device->spec.size * device->convert.len_div /

                device->convert.len_mult;

        }

#endif

        /* stream_len = device->convert.len; */

        stream_len = device->spec.size;

    } else {

        silence = device->spec.silence;

        stream_len = device->spec.size;

    }

    /* Calculate the delay while paused */

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

    /* Determine if the streamer is necessary here */

    if (device->use_streamer == 1) {

        /* This code is almost the same as the old code. The difference is, instead of reading

           directly from the callback into "stream", then converting and sending the audio off,

           we go: callback -> "istream" -> (conversion) -> streamer -> stream -> device.

           However, reading and writing with streamer are done separately:

           - We only call the callback and write to the streamer when the streamer does not

           contain enough samples to output to the device.

           - We only read from the streamer and tell the device to play when the streamer

           does have enough samples to output.

           This allows us to perform resampling in the conversion step, where the output of the

           resampling process can be any number. We will have to see what a good size for the

           stream's maximum length is, but I suspect 2*max(len_cvt, stream_len) is a good figure.

         */

        while (device->enabled) {

            if (device->paused) {

                SDL_Delay(delay);

                continue;

            }

            /* Only read in audio if the streamer doesn't have enough already (if it does not have enough samples to output) */

            if (SDL_StreamLength(&device->streamer) < stream_len) {

                /* Set up istream */

                if (device->convert.needed) {

                    if (device->convert.buf) {

                        istream = device->convert.buf;

                    } else {

                        continue;

                    }

                } else {

/* FIXME: Ryan, this is probably wrong.  I imagine we don't want to get

 * a device buffer both here and below in the stream output.

 */

                    istream = current_audio.impl.GetDeviceBuf(device);

                    if (istream == NULL) {

                        istream = device->fake_stream;

                    }

                }

                /* Read from the callback into the _input_ stream */

                SDL_mutexP(device->mixer_lock);

                (*fill) (udata, istream, istream_len);

                SDL_mutexV(device->mixer_lock);

                /* Convert the audio if necessary and write to the streamer */

                if (device->convert.needed) {

                    SDL_ConvertAudio(&device->convert);

                    if (istream == NULL) {

                        istream = device->fake_stream;

                    }

                    /*SDL_memcpy(istream, device->convert.buf, device->convert.len_cvt); */

                    SDL_StreamWrite(&device->streamer, device->convert.buf,

                                    device->convert.len_cvt);

                } else {

                    SDL_StreamWrite(&device->streamer, istream, istream_len);

                }

            }

            /* Only output audio if the streamer has enough to output */

            if (SDL_StreamLength(&device->streamer) >= stream_len) {

                /* Set up the output stream */

                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;

                    }

                }

                /* Now read from the streamer */

                SDL_StreamRead(&device->streamer, stream, stream_len);

                /* 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 */

                    current_audio.impl.WaitDevice(device);

                } else {

                    SDL_Delay(delay);

                }

            }

        }

    } else {

        /* Otherwise, do not use the streamer. This is the old code. */

        /* Loop, filling the audio buffers */

        while (device->enabled) {

            if (device->paused) {

                SDL_Delay(delay);

                continue;

            }