/*

    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_timer.h"

#include "SDL_audio.h"

#include "../SDL_audiomem.h"

#include "../SDL_audio_c.h"

#include "SDL_artsaudio.h"

#ifdef SDL_AUDIO_DRIVER_ARTS_DYNAMIC

#include "SDL_name.h"

#include "SDL_loadso.h"

#else

#define SDL_NAME(X)	X

#endif

/* The tag name used by artsc audio */

#define ARTS_DRIVER_NAME         "arts"

/* Audio driver functions */

static int ARTS_OpenDevice(_THIS, const char *devname, int iscapture);

static void ARTS_WaitDevice(_THIS);

static void ARTS_PlayDevice(_THIS);

static Uint8 *ARTS_GetDeviceBuf(_THIS);

static void ARTS_CloseDevice(_THIS);

static void ARTS_WaitDone(_THIS);

#ifdef SDL_AUDIO_DRIVER_ARTS_DYNAMIC

static const char *arts_library = SDL_AUDIO_DRIVER_ARTS_DYNAMIC;

static void *arts_handle = NULL;

static int arts_loaded = 0;

/* !!! FIXME: I hate this SDL_NAME clutter...it makes everything so messy! */

static int (*SDL_NAME(arts_init)) (void);

static void (*SDL_NAME(arts_free)) (void);

static arts_stream_t(*SDL_NAME(arts_play_stream)) (int rate, int bits,

                                                   int channels,

                                                   const char *name);

static int (*SDL_NAME(arts_stream_set)) (arts_stream_t s,

                                         arts_parameter_t param, int value);

static int (*SDL_NAME(arts_stream_get)) (arts_stream_t s,

                                         arts_parameter_t param);

static int (*SDL_NAME(arts_write)) (arts_stream_t s, const void *buffer,

                                    int count);

static void (*SDL_NAME(arts_close_stream)) (arts_stream_t s);

static void (*SDL_NAME(arts_close_stream)) (arts_stream_t s);

static const char *(*SDL_NAME(arts_error_text)) (int errorcode);

#define SDL_ARTS_SYM(x) { #x, (void **) (char *) &SDL_NAME(x) }

static struct

{

    const char *name;

    void **func;

} arts_functions[] = {

    SDL_ARTS_SYM(arts_init),

    SDL_ARTS_SYM(arts_free),

    SDL_ARTS_SYM(arts_play_stream),

    SDL_ARTS_SYM(arts_stream_set),

    SDL_ARTS_SYM(arts_stream_get),

    SDL_ARTS_SYM(arts_write),

    SDL_ARTS_SYM(arts_close_stream),

    SDL_ARTS_SYM(arts_error_text),

};

#undef SDL_ARTS_SYM

static void

UnloadARTSLibrary()

{

    if (arts_loaded) {

        SDL_UnloadObject(arts_handle);

        arts_handle = NULL;

        arts_loaded = 0;

    }

}

static int

LoadARTSLibrary(void)

{

    int i, retval = -1;

    if (!arts_loaded) {

        arts_handle = SDL_LoadObject(arts_library);

        if (arts_handle) {

            arts_loaded = 1;

            retval = 0;

            for (i = 0; i < SDL_arraysize(arts_functions); ++i) {

                *arts_functions[i].func =

                    SDL_LoadFunction(arts_handle, arts_functions[i].name);

                if (!*arts_functions[i].func) {

                    retval = -1;

                    UnloadARTSLibrary();

                    break;

                }

            }

        }

    }

    return retval;

}

#else

static void

UnloadARTSLibrary()

{

    return;

}

static int

LoadARTSLibrary(void)

{

    return 0;

}

#endif /* SDL_AUDIO_DRIVER_ARTS_DYNAMIC */

/* Audio driver bootstrap functions */

static int

ARTS_Available(void)

{

    int available = 0;

    if (LoadARTSLibrary() == 0) {

        if (SDL_NAME(arts_init) () == 0) {

#define ARTS_CRASH_HACK         /* Play a stream so aRts doesn't crash */

#ifdef ARTS_CRASH_HACK

            arts_stream_t stream;

            stream = SDL_NAME(arts_play_stream) (44100, 16, 2, "SDL");

            SDL_NAME(arts_write) (stream, "", 0);

            SDL_NAME(arts_close_stream) (stream);

#endif

            available = 1;

            SDL_NAME(arts_free) ();

        }

        UnloadARTSLibrary();

    }

    return available;

}

static int

ARTS_Init(SDL_AudioDriverImpl *impl)

{

    /* Set the function pointers */

    impl->OpenDevice = ARTS_OpenDevice;

    impl->PlayDevice = ARTS_PlayDevice;

    impl->WaitDevice = ARTS_WaitDevice;

    impl->GetDeviceBuf = ARTS_GetDeviceBuf;

    impl->CloseDevice = ARTS_CloseDevice;

    impl->WaitDone = ARTS_WaitDone;

    impl->OnlyHasDefaultOutputDevice = 1;

    return 1;

}

AudioBootStrap ARTS_bootstrap = {

    ARTS_DRIVER_NAME, "Analog RealTime Synthesizer",

    ARTS_Available, ARTS_Init, 0

};

/* This function waits until it is possible to write a full sound buffer */

static void

ARTS_WaitDevice(_THIS)

{

    Sint32 ticks;

    /* Check to see if the thread-parent process is still alive */

    {

        static int cnt = 0;

        /* Note that this only works with thread implementations

           that use a different process id for each thread.

         */

        /* Check every 10 loops */

        if (this->hidden->parent && (((++cnt) % 10) == 0)) {

            if (kill(this->hidden->parent, 0) < 0) {

                this->enabled = 0;

            }

        }

    }

    /* Use timer for general audio synchronization */

    ticks = ((Sint32) (this->hidden->next_frame-SDL_GetTicks())) - FUDGE_TICKS;

    if (ticks > 0) {

        SDL_Delay(ticks);

    }

}

static void

ARTS_PlayDevice(_THIS)

{

    /* Write the audio data */

    int written = SDL_NAME(arts_write) (

                        this->hidden->stream,

                        this->hidden->mixbuf,

                        this->hidden->mixlen);

    /* If timer synchronization is enabled, set the next write frame */

    if (this->hidden->frame_ticks) {

        this->hidden->next_frame += this->hidden->frame_ticks;

    }

    /* If we couldn't write, assume fatal error for now */

    if (written < 0) {

        this->enabled = 0;

    }

#ifdef DEBUG_AUDIO

    fprintf(stderr, "Wrote %d bytes of audio data\n", written);

#endif

}

static void

ARTS_WaitDone(_THIS)

{

    /* !!! FIXME: camp here until buffer drains... SDL_Delay(???); */

}

static Uint8 *

ARTS_GetDeviceBuf(_THIS)

{

    return (this->hidden->mixbuf);

}

static void

ARTS_CloseDevice(_THIS)

{

    if (this->hidden != NULL) {

        if (this->hidden->mixbuf != NULL) {

            SDL_FreeAudioMem(this->hidden->mixbuf);

            this->hidden->mixbuf = NULL;

        }

        if (this->hidden->stream) {

            SDL_NAME(arts_close_stream) (this->hidden->stream);

            this->hidden->stream = 0;

        }

        SDL_NAME(arts_free) ();

        SDL_free(this->hidden);

        this->hidden = NULL;

    }

    UnloadARTSLibrary();

}

static int

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

{

    int rc = 0;

    int bits, frag_spec;

    SDL_AudioFormat test_format, format;

    /* Initialize all variables that we clean on shutdown */

    this->hidden = (struct SDL_PrivateAudioData *)

                        SDL_malloc((sizeof *this->hidden));

    if (this->hidden == NULL) {

        SDL_OutOfMemory();

        return 0;

    }

    SDL_memset(this->hidden, 0, (sizeof *this->hidden));

    if (LoadARTSLibrary() < 0) {

        ARTS_CloseDevice(this);

        SDL_SetError("ARTS: failed to load library: %s", SDL_GetError());

        return 0;

    }

    /* Try for a closest match on audio format */

    format = 0;

    bits = 0;

    for (test_format = SDL_FirstAudioFormat(this->spec.format);

         !format && test_format;) {

#ifdef DEBUG_AUDIO

        fprintf(stderr, "Trying format 0x%4.4x\n", test_format);

#endif

        switch (test_format) {

        case AUDIO_U8:

            bits = 8;

            format = 1;

            break;

        case AUDIO_S16LSB:

            bits = 16;

            format = 1;

            break;

        default:

            format = 0;

            break;

        }

        if (!format) {

            test_format = SDL_NextAudioFormat();

        }

    }

    if (format == 0) {

        ARTS_CloseDevice(this);

        SDL_SetError("Couldn't find any hardware audio formats");

        return 0;

    }

    this->spec.format = test_format;

    if ((rc = SDL_NAME(arts_init) ()) != 0) {

        ARTS_CloseDevice(this);

        SDL_SetError( "Unable to initialize ARTS: %s",

                      SDL_NAME(arts_error_text)(rc) );

        return 0;

    }

    this->hidden->stream = SDL_NAME(arts_play_stream) (

                                            this->spec.freq,

                                            bits, this->spec.channels,

                                            "SDL");

    /* Calculate the final parameters for this audio specification */

    SDL_CalculateAudioSpec(&this->spec);

    /* Determine the power of two of the fragment size */

    for (frag_spec = 0; (0x01 << frag_spec) < this->spec.size; ++frag_spec);

    if ((0x01 << frag_spec) != this->spec.size) {

        ARTS_CloseDevice(this);

        SDL_SetError("Fragment size must be a power of two");

        return 0;

    }

    frag_spec |= 0x00020000;    /* two fragments, for low latency */

#ifdef ARTS_P_PACKET_SETTINGS

    SDL_NAME(arts_stream_set) (this->hidden->stream,

                                ARTS_P_PACKET_SETTINGS, frag_spec);

#else

    SDL_NAME(arts_stream_set) (this->hidden->stream, ARTS_P_PACKET_SIZE,

                               frag_spec & 0xffff);

    SDL_NAME(arts_stream_set) (this->hidden->stream, ARTS_P_PACKET_COUNT,

                               frag_spec >> 16);

#endif

    this->spec.size = SDL_NAME(arts_stream_get) (this->hidden->stream,

                                                 ARTS_P_PACKET_SIZE);

    /* Allocate mixing buffer */

    this->hidden->mixlen = this->spec.size;

    this->hidden->mixbuf = (Uint8 *) SDL_AllocAudioMem(this->hidden->mixlen);

    if (this->hidden->mixbuf == NULL) {

        ARTS_CloseDevice(this);

        SDL_OutOfMemory();

        return 0;

    }

    SDL_memset(this->hidden->mixbuf, this->spec.silence, this->spec.size);

    /* Get the parent process id (we're the parent of the audio thread) */

    this->hidden->parent = getpid();

    /* We're ready to rock and roll. :-) */

    return 1;

}

/* vi: set ts=4 sw=4 expandtab: */