/*

    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"

#if defined(__APPLE__) && defined(__MACH__)

#  include <Carbon/Carbon.h>

#elif TARGET_API_MAC_CARBON && (UNIVERSAL_INTERFACES_VERSION > 0x0335)

#  include <Carbon.h>

#else

#  include <Sound.h> /* SoundManager interface */

#  include <Gestalt.h>

#  include <DriverServices.h>

#endif

#if !defined(NewSndCallBackUPP) && (UNIVERSAL_INTERFACES_VERSION < 0x0335)

#if !defined(NewSndCallBackProc) /* avoid circular redefinition... */

#define NewSndCallBackUPP NewSndCallBackProc

#endif

#if !defined(NewSndCallBackUPP)

#define NewSndCallBackUPP NewSndCallBackProc

#endif

#endif

#include "SDL_audio.h"

#include "../SDL_audio_c.h"

#include "../SDL_sysaudio.h"

#include "SDL_romaudio.h"

/* Audio driver functions */

static void Mac_CloseAudio(_THIS);

static int Mac_OpenAudio(_THIS, SDL_AudioSpec *spec);

static void Mac_LockAudio(_THIS);

static void Mac_UnlockAudio(_THIS);

/* Audio driver bootstrap functions */

static int Audio_Available(void)

{

    return(1);

}

static void Audio_DeleteDevice(SDL_AudioDevice *device)

{

    SDL_free(device->hidden);

    SDL_free(device);

}

static SDL_AudioDevice *Audio_CreateDevice(int devindex)

{

    SDL_AudioDevice *this;

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

    this = (SDL_AudioDevice *)SDL_malloc(sizeof(SDL_AudioDevice));

    if ( this ) {

        SDL_memset(this, 0, (sizeof *this));

        this->hidden = (struct SDL_PrivateAudioData *)

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

    }

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

        SDL_OutOfMemory();

        if ( this ) {

            SDL_free(this);

        }

        return(0);

    }

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

    /* Set the function pointers */

    this->OpenAudio   = Mac_OpenAudio;

    this->CloseAudio  = Mac_CloseAudio;

    this->LockAudio   = Mac_LockAudio;

    this->UnlockAudio = Mac_UnlockAudio;

    this->free        = Audio_DeleteDevice;

#ifdef __MACOSX__	/* Mac OS X uses threaded audio, so normal thread code is okay */

    this->LockAudio   = NULL;

    this->UnlockAudio = NULL;

#endif

    return this;

}

AudioBootStrap SNDMGR_bootstrap = {

	"sndmgr", "MacOS SoundManager 3.0",

	Audio_Available, Audio_CreateDevice

};

#if defined(TARGET_API_MAC_CARBON) || defined(USE_RYANS_SOUNDCODE)

/* This works correctly on Mac OS X */

#pragma options align=power

static volatile SInt32 audio_is_locked = 0;

static volatile SInt32 need_to_mix = 0;

static UInt8  *buffer[2];

static volatile UInt32 running = 0;

static CmpSoundHeader header;

static volatile Uint32 fill_me = 0;

static void mix_buffer(SDL_AudioDevice *audio, UInt8 *buffer)

{

   if ( ! audio->paused ) {

#ifdef __MACOSX__

        SDL_mutexP(audio->mixer_lock);

#endif

        if ( audio->convert.needed ) {

            audio->spec.callback(audio->spec.userdata,

                    (Uint8 *)audio->convert.buf,audio->convert.len);

            SDL_ConvertAudio(&audio->convert);

            if ( audio->convert.len_cvt != audio->spec.size ) {

                /* Uh oh... probably crashes here */;

            }

            SDL_memcpy(buffer, audio->convert.buf, audio->convert.len_cvt);

        } else {

            audio->spec.callback(audio->spec.userdata, buffer, audio->spec.size);

        }

#ifdef __MACOSX__

        SDL_mutexV(audio->mixer_lock);

#endif

    }

    DecrementAtomic((SInt32 *) &need_to_mix);

}

static void Mac_LockAudio(_THIS)

{

    IncrementAtomic((SInt32 *) &audio_is_locked);

}

static void Mac_UnlockAudio(_THIS)

{

    SInt32 oldval;

    oldval = DecrementAtomic((SInt32 *) &audio_is_locked);

    if ( oldval != 1 )  /* != 1 means audio is still locked. */

        return;

    /* Did we miss the chance to mix in an interrupt? Do it now. */

    if ( BitAndAtomic (0xFFFFFFFF, (UInt32 *) &need_to_mix) ) {

        /*

         * Note that this could be a problem if you missed an interrupt

         *  while the audio was locked, and get preempted by a second

         *  interrupt here, but that means you locked for way too long anyhow.

         */

        mix_buffer (this, buffer[fill_me]);

    }

}

static void callBackProc (SndChannel *chan, SndCommand *cmd_passed ) {

   UInt32 play_me;

   SndCommand cmd; 

   SDL_AudioDevice *audio = (SDL_AudioDevice *)chan->userInfo;

   IncrementAtomic((SInt32 *) &need_to_mix);

   fill_me = cmd_passed->param2;  /* buffer that has just finished playing, so fill it */      

   play_me = ! fill_me;           /* filled buffer to play _now_ */

   if ( ! audio->enabled ) {

      return;

   }

   /* queue previously mixed buffer for playback. */

   header.samplePtr = (Ptr)buffer[play_me];

   cmd.cmd = bufferCmd;

   cmd.param1 = 0; 

   cmd.param2 = (long)&header;

   SndDoCommand (chan, &cmd, 0);

   memset (buffer[fill_me], 0, audio->spec.size);

   /*

    * if audio device isn't locked, mix the next buffer to be queued in

    *  the memory block that just finished playing.

    */

   if ( ! BitAndAtomic(0xFFFFFFFF, (UInt32 *) &audio_is_locked) ) {

      mix_buffer (audio, buffer[fill_me]);

   } 

   /* set this callback to run again when current buffer drains. */

   if ( running ) {

      cmd.cmd = callBackCmd;

      cmd.param1 = 0;

      cmd.param2 = play_me;

      SndDoCommand (chan, &cmd, 0);

   }

}

static int Mac_OpenAudio(_THIS, SDL_AudioSpec *spec) {

   SndCallBackUPP callback;

   int sample_bits;

   int i;

   long initOptions;

   /* Very few conversions are required, but... */

    switch (spec->format) {

        case AUDIO_S8:

        spec->format = AUDIO_U8;

        break;

        case AUDIO_U16LSB:

        spec->format = AUDIO_S16LSB;

        break;

        case AUDIO_U16MSB:

        spec->format = AUDIO_S16MSB;

        break;

    }

    SDL_CalculateAudioSpec(spec);

    /* initialize bufferCmd header */

    memset (&header, 0, sizeof(header));

    callback = (SndCallBackUPP) NewSndCallBackUPP (callBackProc);

    sample_bits = spec->size / spec->samples / spec->channels * 8;

#ifdef DEBUG_AUDIO

    fprintf(stderr,

	"Audio format 0x%x, channels = %d, sample_bits = %d, frequency = %d\n",

	spec->format, spec->channels, sample_bits, spec->freq);

#endif /* DEBUG_AUDIO */

    header.numChannels = spec->channels;

    header.sampleSize  = sample_bits;

    header.sampleRate  = spec->freq << 16;

    header.numFrames   = spec->samples;

    header.encode      = cmpSH;

    /* Note that we install the 16bitLittleEndian Converter if needed. */

    if ( spec->format == 0x8010 ) {

        header.compressionID = fixedCompression;

        header.format = k16BitLittleEndianFormat;

    }

    /* allocate 2 buffers */

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

       buffer[i] = (UInt8*)malloc (sizeof(UInt8) * spec->size);

      if (buffer[i] == NULL) {

         SDL_OutOfMemory();

         return (-1);

      }

     memset (buffer[i], 0, spec->size);

   }

   /* Create the sound manager channel */

    channel = (SndChannelPtr)SDL_malloc(sizeof(*channel));

    if ( channel == NULL ) {

        SDL_OutOfMemory();

        return(-1);

    }

    if ( spec->channels >= 2 ) {

        initOptions = initStereo;

    } else {

        initOptions = initMono;

    }

    channel->userInfo = (long)this;

    channel->qLength = 128;

    if ( SndNewChannel(&channel, sampledSynth, initOptions, callback) != noErr ) {

        SDL_SetError("Unable to create audio channel");

        SDL_free(channel);

        channel = NULL;

        return(-1);

    }

   /* start playback */

   {

      SndCommand cmd;

      cmd.cmd = callBackCmd;

      cmd.param2 = 0;

      running = 1;

      SndDoCommand (channel, &cmd, 0);

   }

   return 1;

}

static void Mac_CloseAudio(_THIS) {

   int i;

   running = 0;

   if (channel) {

      SndDisposeChannel (channel, true);

      channel = NULL;

   }

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

        if ( buffer[i] ) {

            SDL_free(buffer[i]);

            buffer[i] = NULL;

        }

    }

}

#else /* !TARGET_API_MAC_CARBON && !USE_RYANS_SOUNDCODE */

static void Mac_LockAudio(_THIS)

{

    /* no-op. */

}

static void Mac_UnlockAudio(_THIS)

{

    /* no-op. */

}

/* This function is called by Sound Manager when it has exhausted one of

   the buffers, so we'll zero it to silence and fill it with audio if

   we're not paused.

*/

static pascal

void sndDoubleBackProc (SndChannelPtr chan, SndDoubleBufferPtr newbuf)

{

    SDL_AudioDevice *audio = (SDL_AudioDevice *)newbuf->dbUserInfo[0];

    /* If audio is quitting, don't do anything */

    if ( ! audio->enabled ) {

        return;

    }

    memset (newbuf->dbSoundData, 0, audio->spec.size);

    newbuf->dbNumFrames = audio->spec.samples;

    if ( ! audio->paused ) {

        if ( audio->convert.needed ) {

            audio->spec.callback(audio->spec.userdata,

                (Uint8 *)audio->convert.buf,audio->convert.len);

            SDL_ConvertAudio(&audio->convert);

#if 0

            if ( audio->convert.len_cvt != audio->spec.size ) {

                /* Uh oh... probably crashes here */;

            }

#endif

            SDL_memcpy(newbuf->dbSoundData, audio->convert.buf,

                            audio->convert.len_cvt);

        } else {

            audio->spec.callback(audio->spec.userdata,

                (Uint8 *)newbuf->dbSoundData, audio->spec.size);

        }

    }

    newbuf->dbFlags    |= dbBufferReady;

}

static int DoubleBufferAudio_Available(void)

{

    int available;

    NumVersion sndversion;

    long response;

    available = 0;

    sndversion = SndSoundManagerVersion();

    if ( sndversion.majorRev >= 3 ) {

        if ( Gestalt(gestaltSoundAttr, &response) == noErr ) {

            if ( (response & (1 << gestaltSndPlayDoubleBuffer)) ) {

                available = 1;

            }

        }

    } else {

        if ( Gestalt(gestaltSoundAttr, &response) == noErr ) {

            if ( (response & (1 << gestaltHasASC)) ) {

                available = 1;

            }

        }

    }

    return(available);

}

static void Mac_CloseAudio(_THIS)

{

    int i;

    if ( channel != NULL ) {

        /* Clean up the audio channel */

        SndDisposeChannel(channel, true);

        channel = NULL;

    }

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

        if ( audio_buf[i] ) {

            SDL_free(audio_buf[i]);

            audio_buf[i] = NULL;

        }

    }

}

static int Mac_OpenAudio(_THIS, SDL_AudioSpec *spec)

{

    SndDoubleBufferHeader2 audio_dbh;

    int i;

    long initOptions;

    int sample_bits;

    SndDoubleBackUPP doubleBackProc;

    /* Check to make sure double-buffered audio is available */

    if ( ! DoubleBufferAudio_Available() ) {

        SDL_SetError("Sound manager doesn't support double-buffering");

        return(-1);

    }

    /* Very few conversions are required, but... */

    switch (spec->format) {

        case AUDIO_S8:

        spec->format = AUDIO_U8;

        break;

        case AUDIO_U16LSB:

        spec->format = AUDIO_S16LSB;

        break;

        case AUDIO_U16MSB:

        spec->format = AUDIO_S16MSB;

        break;

    }

    SDL_CalculateAudioSpec(spec);

    /* initialize the double-back header */

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

    doubleBackProc = NewSndDoubleBackProc (sndDoubleBackProc);

    sample_bits = spec->size / spec->samples / spec->channels * 8;

    audio_dbh.dbhNumChannels = spec->channels;

    audio_dbh.dbhSampleSize    = sample_bits;

    audio_dbh.dbhCompressionID = 0;

    audio_dbh.dbhPacketSize    = 0;

    audio_dbh.dbhSampleRate    = spec->freq << 16;

    audio_dbh.dbhDoubleBack    = doubleBackProc;

    audio_dbh.dbhFormat    = 0;

    /* Note that we install the 16bitLittleEndian Converter if needed. */

    if ( spec->format == 0x8010 ) {

        audio_dbh.dbhCompressionID = fixedCompression;

        audio_dbh.dbhFormat = k16BitLittleEndianFormat;

    }

    /* allocate the 2 double-back buffers */

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

        audio_buf[i] = SDL_calloc(1, sizeof(SndDoubleBuffer)+spec->size);

        if ( audio_buf[i] == NULL ) {

            SDL_OutOfMemory();

            return(-1);

        }

        audio_buf[i]->dbNumFrames = spec->samples;

        audio_buf[i]->dbFlags = dbBufferReady;

        audio_buf[i]->dbUserInfo[0] = (long)this;

        audio_dbh.dbhBufferPtr[i] = audio_buf[i];

    }

    /* Create the sound manager channel */

    channel = (SndChannelPtr)SDL_malloc(sizeof(*channel));

    if ( channel == NULL ) {

        SDL_OutOfMemory();

        return(-1);

    }

    if ( spec->channels >= 2 ) {

        initOptions = initStereo;

    } else {

        initOptions = initMono;

    }

    channel->userInfo = 0;

    channel->qLength = 128;

    if ( SndNewChannel(&channel, sampledSynth, initOptions, 0L) != noErr ) {

        SDL_SetError("Unable to create audio channel");

        SDL_free(channel);

        channel = NULL;

        return(-1);

    }

    /* Start playback */

    if ( SndPlayDoubleBuffer(channel, (SndDoubleBufferHeaderPtr)&audio_dbh)

                                != noErr ) {

        SDL_SetError("Unable to play double buffered audio");

        return(-1);

    }

    return 1;

}

#endif /* TARGET_API_MAC_CARBON || USE_RYANS_SOUNDCODE */