/*

SDL - Simple DirectMedia Layer

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

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

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

/* This should work on PowerPC and Intel Mac OS X, and Carbonized Mac OS 9. */

# include <Carbon/Carbon.h>

#elif TARGET_API_MAC_CARBON && (UNIVERSAL_INTERFACES_VERSION > 0x0335)

# include <Carbon.h>

#else

#endif

#define NewSndCallBackUPP NewSndCallBackProc

#endif

#if !defined(NewSndCallBackUPP)

#define NewSndCallBackUPP NewSndCallBackProc

#endif

#endif

#include "../SDL_audio_c.h"

#include "../SDL_sysaudio.h"

#include "SDL_romaudio.h"

}

#pragma options align=power

static volatile SInt32 audio_is_locked = 0;

static volatile SInt32 need_to_mix = 0;

static volatile UInt32 running = 0;

static CmpSoundHeader header;

static volatile Uint32 fill_me = 0;

static void

mix_buffer(SDL_AudioDevice * audio, UInt8 * buffer)

SDL_mutexP(audio->mixer_lock);

#endif

(Uint8 *) audio->convert.buf,

audio->convert.len);

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

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

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

audio->spec.size);

SDL_mutexV(audio->mixer_lock);

#endif

}

}

}

{

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

/*

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

*/

}

}

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);

}

}

SDL_AudioSpec *spec = &this->spec;

SndChannelPtr channel = NULL;

SndCallBackUPP callback;

int sample_bits;

int i;

long initOptions;

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

/* !!! FIXME: iterate through format matrix... */

spec->format = AUDIO_U8;

break;

spec->format = AUDIO_S16LSB;

break;

spec->format = AUDIO_S16MSB;

break;

case AUDIO_F32LSB:

spec->format = AUDIO_F32MSB;

break;

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);

header.sampleSize = sample_bits;

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

header.numFrames = spec->samples;

header.encode = cmpSH;

header.compressionID = fixedCompression;

header.format = k16BitLittleEndianFormat;

} else if (spec->format == AUDIO_S32MSB) {

header.compressionID = fixedCompression;

header.format = k32BitFormat;

} else if (spec->format == AUDIO_S32LSB) {

header.compressionID = fixedCompression;

header.format = k32BitLittleEndianFormat;

} else if (spec->format == AUDIO_F32MSB) {

header.compressionID = fixedCompression;

header.format = kFloat32Format;

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

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

if (buffer[i] == NULL) {

}

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

}

/* Create the sound manager channel */

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

if (channel == NULL) {

initOptions = initStereo;

} else {

initOptions = initMono;

}

/* start playback */

{

SndCommand cmd;

cmd.cmd = callBackCmd;

cmd.param2 = 0;

running = 1;

SndDoCommand(channel, &cmd, 0);

}

return 1;

}

{

int i;

running = 0;

if (this->hidden->channel) {

SndDisposeChannel(this->hidden->channel, true);

this->hidden->channel = NULL;

}

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

if (buffer[i]) {

buffer[i] = NULL;

}

}

SDL_free(this->hidden);

this->hidden = NULL;

}

static int

SNDMGR_Init(SDL_AudioDriverImpl *impl)

{

/* Set the function pointers */

impl->OpenDevice = SNDMGR_OpenDevice;

impl->CloseDevice = SNDMGR_CloseDevice;

impl->ProvidesOwnCallbackThread = 1;

impl->OnlyHasDefaultOutputDevice = 1;

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

impl->LockDevice = SNDMGR_LockDevice;

impl->UnlockDevice = SNDMGR_UnlockDevice;

#endif

return 1;

}

AudioBootStrap SNDMGR_bootstrap = {

"sndmgr", SDL_MACOS_NAME " SoundManager",

SNDMGR_Available, SNDMGR_Init, 0

};