seal 0.1.0

data/mpg123/src/output/alsa.c

@@ -0,0 +1,297 @@
+/*
+	alsa: sound output with Advanced Linux Sound Architecture 1.x API
+
+	copyright 2006-8 by the mpg123 project - free software under the terms of the LGPL 2.1
+	see COPYING and AUTHORS files in distribution or http://mpg123.org
+
+	initially written by Clemens Ladisch <clemens@ladisch.de>
+*/
+
+#include "mpg123app.h"
+#include "audio.h"
+#include "module.h"
+#include <errno.h>
+
+/* make ALSA 0.9.x compatible to the 1.0.x API */
+#define ALSA_PCM_NEW_HW_PARAMS_API
+#define ALSA_PCM_NEW_SW_PARAMS_API
+
+#include <alsa/asoundlib.h>
+
+#include "debug.h"
+
+/* My laptop has probs playing low-sampled files with only 0.5s buffer... this should be a user setting -- ThOr */
+#define BUFFER_LENGTH 0.5	/* in seconds */
+
+static const struct {
+	snd_pcm_format_t alsa;
+	int mpg123;
+} format_map[] = {
+	{ SND_PCM_FORMAT_S16,    MPG123_ENC_SIGNED_16   },
+	{ SND_PCM_FORMAT_U16,    MPG123_ENC_UNSIGNED_16 },
+	{ SND_PCM_FORMAT_U8,     MPG123_ENC_UNSIGNED_8  },
+	{ SND_PCM_FORMAT_S8,     MPG123_ENC_SIGNED_8    },
+	{ SND_PCM_FORMAT_A_LAW,  MPG123_ENC_ALAW_8      },
+	{ SND_PCM_FORMAT_MU_LAW, MPG123_ENC_ULAW_8      },
+	{ SND_PCM_FORMAT_S32,    MPG123_ENC_SIGNED_32   },
+	{ SND_PCM_FORMAT_U32,    MPG123_ENC_UNSIGNED_32 },
+#ifdef WORDS_BIGENDIAN
+	{ SND_PCM_FORMAT_S24_3BE, MPG123_ENC_SIGNED_24   },
+	{ SND_PCM_FORMAT_U24_3BE, MPG123_ENC_UNSIGNED_24 },
+#else
+	{ SND_PCM_FORMAT_S24_3LE, MPG123_ENC_SIGNED_24   },
+	{ SND_PCM_FORMAT_U24_3LE, MPG123_ENC_UNSIGNED_24 },
+#endif
+	{ SND_PCM_FORMAT_FLOAT,  MPG123_ENC_FLOAT_32    },
+	{ SND_PCM_FORMAT_FLOAT64, MPG123_ENC_FLOAT_64   }
+};
+#define NUM_FORMATS (sizeof format_map / sizeof format_map[0])
+
+
+static int rates_match(long int desired, unsigned int actual)
+{
+	return actual * 100 > desired * (100 - AUDIO_RATE_TOLERANCE) &&
+	       actual * 100 < desired * (100 + AUDIO_RATE_TOLERANCE);
+}
+
+static int initialize_device(audio_output_t *ao)
+{
+	snd_pcm_hw_params_t *hw=NULL;
+	snd_pcm_sw_params_t *sw=NULL;
+	snd_pcm_uframes_t buffer_size;
+	snd_pcm_uframes_t period_size;
+	snd_pcm_format_t format;
+	snd_pcm_t *pcm=(snd_pcm_t*)ao->userptr;
+	unsigned int rate;
+	int i;
+
+	snd_pcm_hw_params_alloca(&hw); /* Ignore GCC warning here... alsa-lib>=1.0.16 doesn't trigger that anymore, too. */
+	if (snd_pcm_hw_params_any(pcm, hw) < 0) {
+		if(!AOQUIET) error("initialize_device(): no configuration available");
+		return -1;
+	}
+	if (snd_pcm_hw_params_set_access(pcm, hw, SND_PCM_ACCESS_RW_INTERLEAVED) < 0) {
+		if(!AOQUIET) error("initialize_device(): device does not support interleaved access");
+		return -1;
+	}
+	format = SND_PCM_FORMAT_UNKNOWN;
+	for (i = 0; i < NUM_FORMATS; ++i) {
+		if (ao->format == format_map[i].mpg123) {
+			format = format_map[i].alsa;
+			break;
+		}
+	}
+	if (format == SND_PCM_FORMAT_UNKNOWN) {
+		if(!AOQUIET) error1("initialize_device(): invalid sample format %d", ao->format);
+		errno = EINVAL;
+		return -1;
+	}
+	if (snd_pcm_hw_params_set_format(pcm, hw, format) < 0) {
+		if(!AOQUIET) error1("initialize_device(): cannot set format %s", snd_pcm_format_name(format));
+		return -1;
+	}
+	if (snd_pcm_hw_params_set_channels(pcm, hw, ao->channels) < 0) {
+		if(!AOQUIET) error1("initialize_device(): cannot set %d channels", ao->channels);
+		return -1;
+	}
+	rate = ao->rate;
+	if (snd_pcm_hw_params_set_rate_near(pcm, hw, &rate, NULL) < 0) {
+		if(!AOQUIET) error1("initialize_device(): cannot set rate %u", rate);
+		return -1;
+	}
+	if (!rates_match(ao->rate, rate)) {
+		if(!AOQUIET) error2("initialize_device(): rate %ld not available, using %u", ao->rate, rate);
+		/* return -1; */
+	}
+	buffer_size = rate * BUFFER_LENGTH;
+	if (snd_pcm_hw_params_set_buffer_size_near(pcm, hw, &buffer_size) < 0) {
+		if(!AOQUIET) error("initialize_device(): cannot set buffer size");
+		return -1;
+	}
+	period_size = buffer_size / 4;
+	if (snd_pcm_hw_params_set_period_size_near(pcm, hw, &period_size, NULL) < 0) {
+		if(!AOQUIET) error("initialize_device(): cannot set period size");
+		return -1;
+	}
+	if (snd_pcm_hw_params(pcm, hw) < 0) {
+		if(!AOQUIET) error("initialize_device(): cannot set hw params");
+		return -1;
+	}
+
+	snd_pcm_sw_params_alloca(&sw);
+	if (snd_pcm_sw_params_current(pcm, sw) < 0) {
+		if(!AOQUIET) error("initialize_device(): cannot get sw params");
+		return -1;
+	}
+	/* start playing after the first write */
+	if (snd_pcm_sw_params_set_start_threshold(pcm, sw, 1) < 0) {
+		if(!AOQUIET) error("initialize_device(): cannot set start threshold");
+		return -1;
+	}
+	/* wake up on every interrupt */
+	if (snd_pcm_sw_params_set_avail_min(pcm, sw, 1) < 0) {
+		if(!AOQUIET) error("initialize_device(): cannot set min available");
+		return -1;
+	}
+#if SND_LIB_VERSION < ((1<<16)|16)
+	/* Always write as many frames as possible (deprecated since alsa-lib 1.0.16) */
+	if (snd_pcm_sw_params_set_xfer_align(pcm, sw, 1) < 0) {
+		if(!AOQUIET) error("initialize_device(): cannot set transfer alignment");
+		return -1;
+	}
+#endif
+	if (snd_pcm_sw_params(pcm, sw) < 0) {
+		if(!AOQUIET) error("initialize_device(): cannot set sw params");
+		return -1;
+	}
+	return 0;
+}
+
+static void error_ignorer(const char *file, int line, const char *function, int err, const char *fmt,...)
+{
+	/* I can make ALSA silent. */
+}
+
+static int open_alsa(audio_output_t *ao)
+{
+	const char *pcm_name;
+	snd_pcm_t *pcm=NULL;
+	debug1("open_alsa with %p", ao->userptr);
+
+	if(AOQUIET) snd_lib_error_set_handler(error_ignorer);
+
+	pcm_name = ao->device ? ao->device : "default";
+	if (snd_pcm_open(&pcm, pcm_name, SND_PCM_STREAM_PLAYBACK, 0) < 0) {
+		if(!AOQUIET) error1("cannot open device %s", pcm_name);
+		return -1;
+	}
+	ao->userptr = pcm;
+	if (ao->format != -1) {
+		/* we're going to play: initalize sample format */
+		return initialize_device(ao);
+	} else {
+		/* query mode; sample format will be set for each query */
+		return 0;
+	}
+}
+
+
+static int get_formats_alsa(audio_output_t *ao)
+{
+	snd_pcm_t *pcm=(snd_pcm_t*)ao->userptr;
+	snd_pcm_hw_params_t *hw;
+	unsigned int rate;
+	int supported_formats, i;
+
+	snd_pcm_hw_params_alloca(&hw);
+	if (snd_pcm_hw_params_any(pcm, hw) < 0) {
+		if(!AOQUIET) error("get_formats_alsa(): no configuration available");
+		return -1;
+	}
+	if (snd_pcm_hw_params_set_access(pcm, hw, SND_PCM_ACCESS_RW_INTERLEAVED) < 0)
+		return -1;
+	if (snd_pcm_hw_params_set_channels(pcm, hw, ao->channels) < 0)
+		return 0;
+	rate = ao->rate;
+	if (snd_pcm_hw_params_set_rate_near(pcm, hw, &rate, NULL) < 0)
+		return -1;
+	if (!rates_match(ao->rate, rate))
+		return 0;
+	supported_formats = 0;
+	for (i = 0; i < NUM_FORMATS; ++i) {
+		if (snd_pcm_hw_params_test_format(pcm, hw, format_map[i].alsa) == 0)
+			supported_formats |= format_map[i].mpg123;
+	}
+	return supported_formats;
+}
+
+static int write_alsa(audio_output_t *ao, unsigned char *buf, int bytes)
+{
+	snd_pcm_t *pcm=(snd_pcm_t*)ao->userptr;
+	snd_pcm_uframes_t frames;
+	snd_pcm_sframes_t written;
+
+	frames = snd_pcm_bytes_to_frames(pcm, bytes);
+	written = snd_pcm_writei(pcm, buf, frames);
+	if (written == -EINTR) /* interrupted system call */
+		written = 0;
+	else if (written == -EPIPE) { /* underrun */
+		if (snd_pcm_prepare(pcm) >= 0)
+			written = snd_pcm_writei(pcm, buf, frames);
+	}
+	if (written >= 0)
+		return snd_pcm_frames_to_bytes(pcm, written);
+	else
+	{
+		if(snd_pcm_state(pcm) == SND_PCM_STATE_SUSPENDED)
+		{
+			/* Iamnothappyabouthisnothappyreallynot. */
+			snd_pcm_resume(pcm);
+			if(snd_pcm_state(pcm) == SND_PCM_STATE_SUSPENDED)
+			{
+				error("device still suspended after resume hackery... giving up");
+				return -1;
+			}
+		}
+		return 0;
+	}
+}
+
+static void flush_alsa(audio_output_t *ao)
+{
+	snd_pcm_t *pcm=(snd_pcm_t*)ao->userptr;
+
+	/* is this the optimal solution? - we should figure out what we really whant from this function */
+
+debug("alsa drop");
+	snd_pcm_drop(pcm);
+debug("alsa prepare");
+	snd_pcm_prepare(pcm);
+debug("alsa flush done");
+}
+
+static int close_alsa(audio_output_t *ao)
+{
+	snd_pcm_t *pcm=(snd_pcm_t*)ao->userptr;
+	debug1("close_alsa with %p", ao->userptr);
+	if(pcm != NULL) /* be really generous for being called without any device opening */
+	{
+		if (snd_pcm_state(pcm) == SND_PCM_STATE_RUNNING)
+			snd_pcm_drain(pcm);
+		ao->userptr = NULL; /* Should alsa do this or the module wrapper? */
+		return snd_pcm_close(pcm);
+	}
+	else return 0;
+}
+
+
+static int init_alsa(audio_output_t* ao)
+{
+	if (ao==NULL) return -1;
+
+	/* Set callbacks */
+	ao->open = open_alsa;
+	ao->flush = flush_alsa;
+	ao->write = write_alsa;
+	ao->get_formats = get_formats_alsa;
+	ao->close = close_alsa;
+
+	/* Success */
+	return 0;
+}
+
+
+
+/* 
+	Module information data structure
+*/
+mpg123_module_t mpg123_output_module_info = {
+	/* api_version */	MPG123_MODULE_API_VERSION,
+	/* name */			"alsa",						
+	/* description */	"Output audio using Advanced Linux Sound Architecture (ALSA).",
+	/* revision */		"$Rev:$",						
+	/* handle */		NULL,
+	
+	/* init_output */	init_alsa,						
+};
+

data/mpg123/src/output/arts.c

@@ -0,0 +1,117 @@
+/*
+	arts: audio output via aRts Sound Daemon
+
+	copyright 2007-8 by the mpg123 project - free software under the terms of the LGPL 2.1
+	see COPYING and AUTHORS files in distribution or http://mpg123.org
+
+	initially written by Stefan Lenselink (Stefan@lenselink.org)
+*/
+
+
+#include "mpg123app.h"
+#include <artsc.h>
+#include "debug.h"
+
+typedef struct
+{
+	arts_stream_t arse; /* That's short for ARts StrEam;-) */
+} mpg123_arts_t;
+
+static int open_arts(audio_output_t *ao)
+{
+	short bits = 0;
+	if(!ao) return -1;
+
+	if(ao->format < 0)
+	{
+		ao->format = MPG123_ENC_SIGNED_16;
+		ao->rate   = 44100;
+		ao->channels = 2;
+	}
+	/* Trial and error revealed these two formats to work with aRts. */
+	if(ao->format == MPG123_ENC_SIGNED_16) bits = 16;
+	else if(ao->format == MPG123_ENC_UNSIGNED_8) bits = 8;
+	else return -1;
+
+	/* Initialize the aRts lib*/
+	arts_init();
+	/* Open a stream to the aRts server */
+	((mpg123_arts_t*)ao->userptr)->arse = arts_play_stream( ao->rate, bits, ao->channels, "mpg123" );
+	/* Yeah, black box and all... it's still a pointer that is NULL on error. */
+	return (void*)((mpg123_arts_t*)ao->userptr)->arse == NULL ? -1 : 0;
+}
+
+static int get_formats_arts(audio_output_t *ao)
+{
+	/* aRts runs not everything, but any rate. */
+	return MPG123_ENC_SIGNED_16|MPG123_ENC_UNSIGNED_8;
+}
+
+static int write_arts(audio_output_t *ao,unsigned char *buf,int len)
+{
+	/* PIPE the PCM forward to the aRts Sound Daemon */
+	return arts_write( ((mpg123_arts_t*)ao->userptr)->arse , buf, len);
+}
+
+static int close_arts(audio_output_t *ao)
+{
+	/* Close the connection! */
+	arts_close_stream( ((mpg123_arts_t*)ao->userptr)->arse );
+	/* Free the memory allocated*/
+	arts_free();
+	return 0;
+}
+
+static void flush_arts(audio_output_t *ao)
+{
+  /* aRts doesn't have a flush statement! */
+}
+
+static int deinit_arts(audio_output_t* ao)
+{
+	if(ao->userptr)
+	{
+		free(ao->userptr);
+		ao->userptr = NULL;
+	}
+	arts_free();
+	return 0;
+}
+
+static int init_arts(audio_output_t* ao)
+{
+	if (ao==NULL) return -1;
+
+	ao->userptr = malloc(sizeof(mpg123_arts_t));
+	if(ao->userptr == NULL)
+	{
+		error("Out of memory!");
+		return -1;
+	}
+	/* clear it to have a consistent state */
+	memset(ao->userptr, 0, sizeof(mpg123_arts_t));
+	/* Set callbacks */
+	ao->open = open_arts;
+	ao->flush = flush_arts;
+	ao->write = write_arts;
+	ao->get_formats = get_formats_arts;
+	ao->close = close_arts;
+	ao->deinit = deinit_arts;
+	/* Success */
+	return 0;
+}
+
+/*
+	Module information data structure
+*/
+mpg123_module_t mpg123_output_module_info = {
+	/* api_version */	MPG123_MODULE_API_VERSION,
+	/* name */			"arts",
+	/* description */	"Output audio using aRts Sound Daemon",
+	/* revision */		"$Rev: $",
+	/* handle */		NULL,
+	
+	/* init_output */	init_arts,
+};
+
+

data/mpg123/src/output/coreaudio.c

@@ -0,0 +1,370 @@
+/*
+	coreaudio: audio output on MacOS X
+
+	copyright ?-2006 by the mpg123 project - free software under the terms of the GPL 2
+	see COPYING and AUTHORS files in distribution or http://mpg123.org
+	initially written by Guillaume Outters
+	modified by Nicholas J Humfrey to use SFIFO code
+	modified by Taihei Monma to use AudioUnit and AudioConverter APIs
+*/
+
+
+#include "mpg123app.h"
+
+#include <CoreServices/CoreServices.h>
+#include <AudioUnit/AudioUnit.h>
+#include <AudioToolbox/AudioToolbox.h>
+#include <errno.h>
+
+/* Including the sfifo code locally, to avoid module linkage issues. */
+#define SFIFO_STATIC
+#include "sfifo.c"
+
+#include "debug.h"
+
+#define FIFO_DURATION		(0.5f)		/* Duration of the ring buffer in seconds */
+
+
+typedef struct mpg123_coreaudio
+{
+	AudioConverterRef converter;
+	AudioUnit outputUnit;
+	int open;
+	char play;
+	int channels;
+	int bps;
+	int last_buffer;
+	int play_done;
+	int decode_done;
+	
+	/* Convertion buffer */
+	unsigned char * buffer;
+	size_t buffer_size;
+	
+	/* Ring buffer */
+	sfifo_t fifo;
+
+} mpg123_coreaudio_t;
+
+
+
+static OSStatus playProc(AudioConverterRef inAudioConverter,
+						 UInt32 *ioNumberDataPackets,
+                         AudioBufferList *outOutputData,
+                         AudioStreamPacketDescription **outDataPacketDescription,
+                         void* inClientData)
+{
+	mpg123_coreaudio_t *ca = (mpg123_coreaudio_t *)inClientData;
+	long n;
+	
+	
+	if(ca->last_buffer) {
+		ca->play_done = 1;
+		return noErr;
+	}
+	
+	for(n = 0; n < outOutputData->mNumberBuffers; n++)
+	{
+		unsigned int wanted = *ioNumberDataPackets * ca->channels * ca->bps;
+		unsigned char *dest;
+		unsigned int read;
+		if(ca->buffer_size < wanted) {
+			debug1("Allocating %d byte sample conversion buffer", wanted);
+			ca->buffer = realloc( ca->buffer, wanted);
+			ca->buffer_size = wanted;
+		}
+		dest = ca->buffer;
+		
+		/* Only play if we have data left */
+		if ( sfifo_used( &ca->fifo ) < wanted ) {
+			if(!ca->decode_done) {
+				warning("Didn't have any audio data in callback (buffer underflow)");
+				return -1;
+			}
+			wanted = sfifo_used( &ca->fifo );
+			ca->last_buffer = 1;
+		}
+		
+		/* Read audio from FIFO to SDL's buffer */
+		read = sfifo_read( &ca->fifo, dest, wanted );
+		
+		if (wanted!=read)
+			warning2("Error reading from the ring buffer (wanted=%u, read=%u).\n", wanted, read);
+		
+		outOutputData->mBuffers[n].mDataByteSize = read;
+		outOutputData->mBuffers[n].mData = dest;
+	}
+	
+	return noErr; 
+}
+
+static OSStatus convertProc(void *inRefCon, AudioUnitRenderActionFlags *inActionFlags,
+                            const AudioTimeStamp *inTimeStamp, UInt32 inBusNumber,
+                            UInt32 inNumFrames, AudioBufferList *ioData)
+{
+	AudioStreamPacketDescription* outPacketDescription = NULL;
+	mpg123_coreaudio_t* ca = (mpg123_coreaudio_t*)inRefCon;
+	OSStatus err= noErr;
+	
+	err = AudioConverterFillComplexBuffer(ca->converter, playProc, inRefCon, &inNumFrames, ioData, outPacketDescription);
+	
+	return err;
+}
+
+static int open_coreaudio(audio_output_t *ao)
+{
+	mpg123_coreaudio_t* ca = (mpg123_coreaudio_t*)ao->userptr;
+	UInt32 size;
+	ComponentDescription desc;
+	Component comp;
+	AudioStreamBasicDescription inFormat;
+	AudioStreamBasicDescription outFormat;
+	AURenderCallbackStruct  renderCallback;
+	Boolean outWritable;
+	
+	/* Initialize our environment */
+	ca->play = 0;
+	ca->buffer = NULL;
+	ca->buffer_size = 0;
+	ca->last_buffer = 0;
+	ca->play_done = 0;
+	ca->decode_done = 0;
+
+	
+	/* Get the default audio output unit */
+	desc.componentType = kAudioUnitType_Output; 
+	desc.componentSubType = kAudioUnitSubType_DefaultOutput;
+	desc.componentManufacturer = kAudioUnitManufacturer_Apple;
+	desc.componentFlags = 0;
+	desc.componentFlagsMask = 0;
+	comp = FindNextComponent(NULL, &desc);
+	if(comp == NULL) {
+		error("FindNextComponent failed");
+		return(-1);
+	}
+	
+	if(OpenAComponent(comp, &(ca->outputUnit)))  {
+		error("OpenAComponent failed");
+		return (-1);
+	}
+	
+	if(AudioUnitInitialize(ca->outputUnit)) {
+		error("AudioUnitInitialize failed");
+		return (-1);
+	}
+	
+	/* Specify the output PCM format */
+	AudioUnitGetPropertyInfo(ca->outputUnit, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Output, 0, &size, &outWritable);
+	if(AudioUnitGetProperty(ca->outputUnit, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Output, 0, &outFormat, &size)) {
+		error("AudioUnitGetProperty(kAudioUnitProperty_StreamFormat) failed");
+		return (-1);
+	}
+	
+	if(AudioUnitSetProperty(ca->outputUnit, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Input, 0, &outFormat, size)) {
+		error("AudioUnitSetProperty(kAudioUnitProperty_StreamFormat) failed");
+		return (-1);
+	}
+	
+	/* Specify the input PCM format */
+	ca->channels = ao->channels;
+	inFormat.mSampleRate = ao->rate;
+	inFormat.mChannelsPerFrame = ao->channels;
+	inFormat.mFormatID = kAudioFormatLinearPCM;
+#ifdef _BIG_ENDIAN
+	inFormat.mFormatFlags = kLinearPCMFormatFlagIsPacked | kLinearPCMFormatFlagIsBigEndian;
+#else
+	inFormat.mFormatFlags = kLinearPCMFormatFlagIsPacked;
+#endif
+	
+	switch(ao->format)
+	{
+		case MPG123_ENC_SIGNED_16:
+			inFormat.mFormatFlags |= kLinearPCMFormatFlagIsSignedInteger;
+			ca->bps = 2;
+			break;
+		case MPG123_ENC_SIGNED_8:
+			inFormat.mFormatFlags |= kLinearPCMFormatFlagIsSignedInteger;
+			ca->bps = 1;
+			break;
+		case MPG123_ENC_UNSIGNED_8:
+			ca->bps = 1;
+			break;
+		case MPG123_ENC_SIGNED_32:
+			inFormat.mFormatFlags |= kLinearPCMFormatFlagIsSignedInteger;
+			ca->bps = 4;
+			break;
+		case MPG123_ENC_FLOAT_32:
+			inFormat.mFormatFlags |= kLinearPCMFormatFlagIsFloat;
+			ca->bps = 4;
+			break;
+	}
+	
+	inFormat.mBitsPerChannel = ca->bps << 3;
+	inFormat.mBytesPerPacket = ca->bps*inFormat.mChannelsPerFrame;
+	inFormat.mFramesPerPacket = 1;
+	inFormat.mBytesPerFrame = ca->bps*inFormat.mChannelsPerFrame;
+	
+	/* Add our callback - but don't start it yet */
+	memset(&renderCallback, 0, sizeof(AURenderCallbackStruct));
+	renderCallback.inputProc = convertProc;
+	renderCallback.inputProcRefCon = ao->userptr;
+	if(AudioUnitSetProperty(ca->outputUnit, kAudioUnitProperty_SetRenderCallback, kAudioUnitScope_Input, 0, &renderCallback, sizeof(AURenderCallbackStruct))) {
+		error("AudioUnitSetProperty(kAudioUnitProperty_SetRenderCallback) failed");
+		return(-1);
+	}
+	
+	
+	/* Open an audio I/O stream and create converter */
+	if (ao->rate > 0 && ao->channels >0 ) {
+		int ringbuffer_len;
+
+		if(AudioConverterNew(&inFormat, &outFormat, &(ca->converter))) {
+			error("AudioConverterNew failed");
+			return(-1);
+		}
+		if(ao->channels == 1) {
+			SInt32 channelMap[2] = { 0, 0 };
+			if(AudioConverterSetProperty(ca->converter, kAudioConverterChannelMap, sizeof(channelMap), channelMap)) {
+				error("AudioConverterSetProperty(kAudioConverterChannelMap) failed");
+				return(-1);
+			}
+		}
+		
+		/* Initialise FIFO */
+		ringbuffer_len = ao->rate * FIFO_DURATION * ca->bps * ao->channels;
+		debug2( "Allocating %d byte ring-buffer (%f seconds)", ringbuffer_len, (float)FIFO_DURATION);
+		sfifo_init( &ca->fifo, ringbuffer_len );
+	}
+	
+	return(0);
+}
+
+static int get_formats_coreaudio(audio_output_t *ao)
+{
+	return MPG123_ENC_SIGNED_16|MPG123_ENC_SIGNED_8|MPG123_ENC_UNSIGNED_8|MPG123_ENC_SIGNED_32|MPG123_ENC_FLOAT_32;
+}
+
+static int write_coreaudio(audio_output_t *ao, unsigned char *buf, int len)
+{
+	mpg123_coreaudio_t* ca = (mpg123_coreaudio_t*)ao->userptr;
+	int written;
+
+	/* If there is no room, then sleep for half the length of the FIFO */
+	while (sfifo_space( &ca->fifo ) < len ) {
+		usleep( (FIFO_DURATION/2) * 1000000 );
+	}
+	
+	/* Store converted audio in ring buffer */
+	written = sfifo_write( &ca->fifo, (char*)buf, len);
+	if (written != len) {
+		warning( "Failed to write audio to ring buffer" );
+		return -1;
+	}
+	
+	/* Start playback now that we have something to play */
+	if(!ca->play)
+	{
+		if(AudioOutputUnitStart(ca->outputUnit)) {
+			error("AudioOutputUnitStart failed");
+			return(-1);
+		}
+		ca->play = 1;
+	}
+	
+	return len;
+}
+
+static int close_coreaudio(audio_output_t *ao)
+{
+	mpg123_coreaudio_t* ca = (mpg123_coreaudio_t*)ao->userptr;
+
+	if (ca) {
+		ca->decode_done = 1;
+		while(!ca->play_done && ca->play) usleep(10000);
+		
+		/* No matter the error code, we want to close it (by brute force if necessary) */
+		AudioConverterDispose(ca->converter);
+		AudioOutputUnitStop(ca->outputUnit);
+		AudioUnitUninitialize(ca->outputUnit);
+		CloseComponent(ca->outputUnit);
+	
+	    /* Free the ring buffer */
+		sfifo_close( &ca->fifo );
+		
+		/* Free the conversion buffer */
+		if (ca->buffer) {
+			free( ca->buffer );
+			ca->buffer = NULL;
+		}
+		
+	}
+	
+	return 0;
+}
+
+static void flush_coreaudio(audio_output_t *ao)
+{
+	mpg123_coreaudio_t* ca = (mpg123_coreaudio_t*)ao->userptr;
+
+	/* Stop playback */
+	if(AudioOutputUnitStop(ca->outputUnit)) {
+		error("AudioOutputUnitStop failed");
+	}
+	ca->play=0;
+	
+	/* Empty out the ring buffer */
+	sfifo_flush( &ca->fifo );	
+}
+
+static int deinit_coreaudio(audio_output_t* ao)
+{
+	/* Free up memory */
+	if (ao->userptr) {
+		free( ao->userptr );
+		ao->userptr = NULL;
+	}
+
+	/* Success */
+	return 0;
+}
+
+static int init_coreaudio(audio_output_t* ao)
+{
+	if (ao==NULL) return -1;
+
+	/* Set callbacks */
+	ao->open = open_coreaudio;
+	ao->flush = flush_coreaudio;
+	ao->write = write_coreaudio;
+	ao->get_formats = get_formats_coreaudio;
+	ao->close = close_coreaudio;
+	ao->deinit = deinit_coreaudio;
+
+	/* Allocate memory for data structure */
+	ao->userptr = malloc( sizeof( mpg123_coreaudio_t ) );
+	if (ao->userptr==NULL) {
+		error("failed to malloc memory for 'mpg123_coreaudio_t'");
+		return -1;
+	}
+	memset( ao->userptr, 0, sizeof(mpg123_coreaudio_t) );
+
+	/* Success */
+	return 0;
+}
+
+
+
+/* 
+	Module information data structure
+*/
+mpg123_module_t mpg123_output_module_info = {
+	/* api_version */	MPG123_MODULE_API_VERSION,
+	/* name */			"coreaudio",						
+	/* description */	"Output audio using Mac OS X's CoreAudio.",
+	/* revision */		"$Rev:$",
+	/* handle */		NULL,
+	
+	/* init_output */	init_coreaudio,						
+};
+
+