seal 0.1.0

data/mpg123/src/output/dummy.c

@@ -0,0 +1,78 @@
+/*
+	dummy: dummy audio output
+
+	copyright ?-2006 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
+*/
+
+#include "mpg123app.h"
+#include "debug.h"
+
+static int open_dummy(audio_output_t *ao)
+{
+	debug("open_dummy()");
+	return 0;
+}
+
+static int get_formats_dummy(audio_output_t *ao)
+{
+	debug("get_formats_dummy()");
+	return MPG123_ENC_SIGNED_16;
+}
+
+static int write_dummy(audio_output_t *ao,unsigned char *buf,int len)
+{
+	debug("write_dummy()");
+	return len;
+}
+
+static void flush_dummy(audio_output_t *ao)
+{
+	debug("flush_dummy()");
+}
+
+static int close_dummy(audio_output_t *ao)
+{
+	debug("close_dummy()");
+	return 0;
+}
+
+static int deinit_dummy(audio_output_t *ao)
+{
+	debug("deinit_dummy()");
+	return 0;
+}
+
+
+static int init_dummy(audio_output_t* ao)
+{
+	if (ao==NULL) return -1;
+	debug("init_dummy()");
+	
+	/* Set callbacks */
+	ao->open = open_dummy;
+	ao->flush = flush_dummy;
+	ao->write = write_dummy;
+	ao->get_formats = get_formats_dummy;
+	ao->close = close_dummy;
+	ao->deinit = deinit_dummy;
+
+	/* Success */
+	return 0;
+}
+
+
+
+/* 
+	Module information data structure
+*/
+mpg123_module_t mpg123_output_module_info = {
+	/* api_version */	MPG123_MODULE_API_VERSION,
+	/* name */			"dummy",						
+	/* description */	"Dummy audio output - does not output audio.",
+	/* revision */		"$Rev:$",						
+	/* handle */		NULL,
+	
+	/* init_output */	init_dummy,						
+};
+

data/mpg123/src/output/esd.c

@@ -0,0 +1,167 @@
+/*
+	esd: audio output for ESounD (highly untested nowadays (?))
+
+	copyright ?-2006 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 Eric B. Mitchell ("esd port" should be this file...)
+*/
+
+/* First the common header, including config.h
+   ...this is important for stuff like _FILE_OFFSET_BITS */
+#include "mpg123app.h"
+
+#include <esd.h>
+#include <errno.h>
+#include <assert.h>
+
+#ifdef SOLARIS
+#include <stropts.h>
+#include <sys/conf.h>
+#endif
+#ifdef NETBSD
+#include <sys/ioctl.h>
+#include <sys/audioio.h>
+#endif
+#include "debug.h"
+
+static unsigned esd_rate = 0, esd_format = 0, esd_channels = 0;
+
+
+static int open_esound(audio_output_t *ao)
+{
+	esd_format_t format = ESD_STREAM | ESD_PLAY;
+
+	if (!esd_rate)
+	{
+		int esd;
+		esd_server_info_t *info;
+		esd_format_t fmt;
+		
+		if ((esd = esd_open_sound(NULL)) >= 0)
+		{
+			info = esd_get_server_info(esd);
+			esd_rate = info->rate;
+			fmt = info->format;
+			esd_free_server_info(info);
+			esd_close(esd);
+		}
+		else
+		{
+			esd_rate = esd_audio_rate;
+			fmt = esd_audio_format;
+		}
+		esd_format = MPG123_ENC_UNSIGNED_8;
+		
+		if ((fmt & ESD_MASK_BITS) == ESD_BITS16)
+			esd_format |= MPG123_ENC_SIGNED_16;
+		esd_channels = fmt & ESD_MASK_CHAN;
+	}
+	
+	if (ao->format == -1)
+		ao->format = esd_format;
+	else if (!(ao->format & esd_format))
+	{
+		error1("Unsupported audio format: %d\n", ao->format);
+		errno = EINVAL;
+		return -1;
+	}
+	
+	
+	if (ao->format & MPG123_ENC_SIGNED_16)
+		format |= ESD_BITS16;
+	else if (ao->format & MPG123_ENC_UNSIGNED_8)
+		format |= ESD_BITS8;
+	else assert(0);
+	
+	if (ao->channels == -1) ao->channels = 2;
+	else if (ao->channels <= 0 || ao->channels > esd_channels)
+	{
+		error1("Unsupported no of channels: %d\n", ao->channels);
+		errno = EINVAL;
+		return -1;
+	}
+	if (ao->channels == 1)
+		format |= ESD_MONO;
+	else if (ao->channels == 2)
+		format |= ESD_STEREO;
+	else assert(0);
+	
+	if (ao->rate == -1) ao->rate = esd_rate;
+	else if (ao->rate > esd_rate)
+	return -1;
+	
+	ao->fn = esd_play_stream_fallback(format, ao->rate, ao->device, "mpg123");
+	return (ao->fn);
+}
+
+static int get_formats_esound (audio_output_t *ao)
+{
+	if (0 < ao->channels && ao->channels <= esd_channels 
+	    && 0 < ao->rate && ao->rate <= esd_rate)
+	{
+		return esd_format;
+	} else {
+		return -1;
+	}
+}
+
+static int write_esound(audio_output_t *ao,unsigned char *buf,int len)
+{
+	return write(ao->fn,buf,len);
+}
+
+static int close_esound(audio_output_t *ao)
+{
+	close (ao->fn);
+	return 0;
+}
+
+#ifdef SOLARIS
+static void flush_esound (audio_output_t *ao)
+{
+        ioctl (ao->fn, I_FLUSH, FLUSHRW);
+}
+#else
+#ifdef NETBSD
+static void flush_esound (audio_output_t *ao)
+{
+        ioctl (ao->fn, AUDIO_FLUSH, 0);
+}
+#else
+/* Dunno what to do on Linux and Cygwin, but the func must be at least defined! */
+static void flush_esound (audio_output_t *ao)
+{
+}
+#endif
+#endif
+
+
+static int init_esound(audio_output_t* ao)
+{
+	if (ao==NULL) return -1;
+
+	/* Set callbacks */
+	ao->open = open_esound;
+	ao->flush = flush_esound;
+	ao->write = write_esound;
+	ao->get_formats = get_formats_esound;
+	ao->close = close_esound;
+
+	/* Success */
+	return 0;
+}
+
+
+
+/* 
+	Module information data structure
+*/
+mpg123_module_t mpg123_output_module_info = {
+	/* api_version */	MPG123_MODULE_API_VERSION,
+	/* name */			"esd",						
+	/* description */	"Output audio using ESounD (The Enlightened Sound Daemon).",
+	/* revision */		"$Rev: 1698 $",						
+	/* handle */		NULL,
+	
+	/* init_output */	init_esound,						
+};

data/mpg123/src/output/hp.c

@@ -0,0 +1,184 @@
+/*
+	hp: audio output for HP-UX
+
+	copyright ?-2006 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 Michael Hipp
+*/
+
+#include "mpg123app.h"
+#include <fcntl.h>
+#include <sys/audio.h>
+#include "debug.h"
+
+
+static int set_rate(audio_output_t *ao)
+{
+	if(ao->rate >= 0) {
+		return ioctl(ao->fn,AUDIO_SET_SAMPLE_RATE,ao->rate);
+	} else {
+		return 0;
+	}
+}
+
+static int set_channels(audio_output_t *ao)
+{
+	if(ao->channels<0) return 0;
+	return ioctl(ao->fn,AUDIO_SET_CHANNELS,ao->channels);
+}
+
+static int set_format(audio_output_t *ao)
+{
+	int fmt;
+	
+	switch(ao->format) {
+		case -1:
+		case MPG123_ENC_SIGNED_16:
+		default: 
+			fmt = MPG123_ENC_LINEAR16BIT;
+		break;
+		case MPG123_ENC_UNSIGNED_8:
+			error("unsigned 8 bit linear not supported");
+			return -1;
+		case MPG123_ENC_SIGNED_8:
+			error("signed 8 bit linear not supported");
+			return -1;
+		case MPG123_ENC_ALAW_8:
+			fmt = MPG123_ENC_ALAW;
+		break;
+		case MPG123_ENC_ULAW_8:
+			fmt = MPG123_ENC_ULAW;
+		break;
+	}
+	return ioctl(ao->fn,AUDIO_SET_DATA_FORMAT,fmt);
+}
+
+static int get_formats(audio_output_t *ao)
+{
+	return MPG123_ENC_SIGNED_16;
+}
+
+static int reset_parameters(audio_output_t *ao)
+{
+	int ret;
+		ret = set_format(ai);
+	if(ret >= 0)
+		ret = set_channels_hp(ai);
+	if(ret >= 0)
+		ret = set_rate_hp(ai);
+	return ret;
+}
+
+
+static int open_hp(audio_output_t *ao)
+{
+	struct audio_describe ades;
+	struct audio_gain again;
+	int i,audio;
+	
+	ao->fn = open("/dev/audio",O_RDWR);
+	
+	if(ao->fn < 0)
+		return -1;
+	
+	
+	ioctl(ao->fn,AUDIO_DESCRIBE,&ades);
+	
+	if(ao->gain != -1)
+	{
+		if(ao->gain > ades.max_transmit_gain)
+		{
+			error("your gainvalue was to high -> set to maximum.");
+			ao->gain = ades.max_transmit_gain;
+		}
+		if(ao->gain < ades.min_transmit_gain)
+		{
+			error("your gainvalue was to low -> set to minimum.");
+			ao->gain = ades.min_transmit_gain;
+		}
+		again.channel_mask = AUDIO_CHANNEL_0 | AUDIO_CHANNEL_1;
+		ioctl(ao->fn,AUDIO_GET_GAINS,&again);
+		again.cgain[0].transmit_gain = ao->gain;
+		again.cgain[1].transmit_gain = ao->gain;
+		again.channel_mask = AUDIO_CHANNEL_0 | AUDIO_CHANNEL_1;
+		ioctl(ao->fn,AUDIO_SET_GAINS,&again);
+	}
+	
+	if(ao->flags != -1)
+	{
+		if(ao->flags & AUDIO_OUT_INTERNAL_SPEAKER)
+			ioctl(ao->fn,AUDIO_SET_OUTPUT,AUDIO_OUT_SPEAKER);
+		else if(ao->flags & AUDIO_OUT_HEADPHONES)
+			ioctl(ao->fn,AUDIO_SET_OUTPUT,AUDIO_OUT_HEADPHONE);
+		else if(ao->flags & AUDIO_OUT_LINE_OUT)
+			ioctl(ao->fn,AUDIO_SET_OUTPUT,AUDIO_OUT_LINE);
+	}
+	
+	if(ao->rate == -1)
+		ao->rate = 44100;
+	
+	for(i=0;i<ades.nrates;i++)
+	{
+		if(ao->rate == ades.sample_rate[i])
+			break;
+	}
+	if(i == ades.nrates)
+	{
+		error1("Can't set sample-rate to %ld.\n",ao->rate);
+		i = 0;
+	}
+	
+	if(reset_parameters(ai) < 0)
+		return -1;
+	
+	return ao->fn;
+}
+
+
+
+static int write_hp(audio_output_t *ao,unsigned char *buf,int len)
+{
+	return write(ao->fn,buf,len);
+}
+
+static int close_hp(audio_output_t *ao)
+{
+	close (ao->fn);
+	return 0;
+}
+
+static void flush_hp(audio_output_t *ao)
+{
+}
+
+
+
+static int init_hp(audio_output_t* ao)
+{
+	if (ao==NULL) return -1;
+
+	/* Set callbacks */
+	ao->open = open_hp;
+	ao->flush = flush_hp;
+	ao->write = write_hp;
+	ao->get_formats = get_formats_hp;
+	ao->close = close_hp;
+
+	/* Success */
+	return 0;
+}
+
+
+
+/* 
+	Module information data structure
+*/
+mpg123_module_t mpg123_output_module_info = {
+	/* api_version */	MPG123_MODULE_API_VERSION,
+	/* name */			"hp",						
+	/* description */	"Output audio HP-UX",
+	/* revision */		"$Rev:$",						
+	/* handle */		NULL,
+	
+	/* init_output */	init_hp,						
+};

data/mpg123/src/output/jack.c

@@ -0,0 +1,450 @@
+/*
+	jack: audio output via JACK Audio Connection Kit
+
+	copyright 2006 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 Nicholas J. Humfrey
+*/
+
+#include <math.h>
+
+#include <jack/jack.h>
+#include <jack/ringbuffer.h>
+#include <sys/errno.h>
+
+#include "mpg123app.h"
+#include "debug.h"
+
+#define MAX_CHANNELS	(2)
+
+typedef struct {
+	int channels;
+	jack_port_t *ports[MAX_CHANNELS];
+	jack_ringbuffer_t * rb[MAX_CHANNELS];
+	size_t rb_size;
+	jack_client_t *client;
+	jack_default_audio_sample_t *tmp_buffer;
+} jack_handle_t, *jack_handle_ptr;
+
+
+static jack_handle_t* alloc_jack_handle()
+{
+	jack_handle_t *handle=NULL;
+
+	handle = malloc(sizeof(jack_handle_t));
+	if (!handle) {
+		error("Failed to allocate memory for our handle.");
+		return NULL;
+	}
+
+	/* Initialise the handle, and store for later*/
+	handle->rb[0] = NULL;
+	handle->rb[1] = NULL;
+	handle->ports[0] = NULL;
+	handle->ports[1] = NULL;
+	handle->client = NULL;
+	handle->tmp_buffer = NULL;
+	handle->rb_size = 0;
+
+
+	return handle;
+}
+
+
+static void free_jack_handle( jack_handle_t* handle )
+{
+	int i;
+
+	warning("FIXME: One needs to wait or write some silence here to prevent the last bits of audio to vanish out of the ringbuffer.");
+
+	for(i=0; i<MAX_CHANNELS; i++) {
+		/* Close the port for channel*/
+		if ( handle->ports[i] )
+			jack_port_unregister( handle->client, handle->ports[i] );
+
+		/* Free up the ring buffer for channel*/
+		if ( handle->rb[i] )
+			jack_ringbuffer_free( handle->rb[i] );
+	}
+
+	if (handle->client)
+		jack_client_close(handle->client);
+		
+	if (handle->tmp_buffer)
+		free(handle->tmp_buffer);
+
+	free(handle);
+}
+
+
+static int process_callback( jack_nframes_t nframes, void *arg )
+{
+	jack_handle_t* handle = (jack_handle_t*)arg;
+    size_t to_read = sizeof (jack_default_audio_sample_t) * nframes;
+	unsigned int c;
+	
+
+    /* copy data to ringbuffer; one per channel*/
+    for (c=0; c < handle->channels; c++)
+    {	
+		char *buf = (char*)jack_port_get_buffer(handle->ports[c], nframes);
+		size_t len = jack_ringbuffer_read(handle->rb[c], buf, to_read);
+		
+		/* If we don't have enough audio, fill it up with silence*/
+		/* (this is to deal with pausing etc.)*/
+		if (to_read > len)
+			bzero( buf+len, to_read - len );
+		
+		/*if (len < to_read)*/
+		/*	error1("failed to read from ring buffer %d",c);*/
+    }
+
+	/* Success*/
+	return 0;
+}
+
+static void shutdown_callback( void *arg )
+{
+/*	jack_handle_t* handle = (jack_handle_t*)arg; */
+
+	debug("shutdown_callback()");
+
+}
+
+/* connect to jack ports named in the NULL-terminated wishlist */
+static int real_connect_jack_ports( jack_handle_t* handle, const char** wishlist)
+{
+	const char **wish = wishlist;
+	int ch, err;
+
+	if(wish != NULL && *wish == NULL) return 1; /* success, nothing connected as wanted */
+
+	for(ch=0; ch<handle->channels; ++ch)
+	{
+		const char* in = jack_port_name( handle->ports[ch] );
+
+		if ((err = jack_connect(handle->client, in, *wish)) != 0 && err != EEXIST) {
+			error1("connect_jack_ports(): failed to jack_connect() ports: %d",err);
+			return 0;
+		}
+		/* Increment wish only if there is another one. Otherwise simply connect to the same port multiple times. */
+		if(*(wish+1) != NULL) ++wish;
+	}
+
+	return 1;
+}
+
+/* crude way of automatically connecting up jack ports */
+/* 0 on error */
+static int autoconnect_jack_ports( jack_handle_t* handle)
+{
+	const char **all_ports;
+	unsigned int ch=0;
+	int err,i;
+
+	/* Get a list of all the jack ports*/
+	all_ports = jack_get_ports (handle->client, NULL, NULL, JackPortIsInput);
+	if (!all_ports) {
+		error("connect_jack_ports(): jack_get_ports() returned NULL.");
+		return 0;
+	}
+	
+	/* Step through each port name*/
+	for (i = 0; all_ports[i]; ++i) {
+
+		const char* in = jack_port_name( handle->ports[ch] );
+		const char* out = all_ports[i];
+
+		if ((err = jack_connect(handle->client, in, out)) != 0 && err != EEXIST) {
+			error1("connect_jack_ports(): failed to jack_connect() ports: %d",err);
+			return 0;
+		}
+	
+		/* Found enough ports ?*/
+		if (++ch >= handle->channels) break;
+	}
+	
+	free( all_ports );
+	return 1;
+}
+
+
+static int connect_jack_ports( jack_handle_t* handle, const char *dev ) 
+{
+	if (dev==NULL || strcmp(dev, "auto")==0) {
+		return autoconnect_jack_ports( handle );
+	}
+	else
+	{
+		const char* wishlist[] = { NULL, NULL, NULL }; /* Two channels and end marker. */
+		char *devcopy;
+		int ret;
+		size_t len = strlen(dev);
+		devcopy = malloc(len+1);
+		if(devcopy == NULL){ error("OOM"); return 0; }
+
+		/* We just look out for a possible second port, comma separated
+		   This is really crude cruft, but it's enough. Can be replaced by something sensible later. */
+		memcpy(devcopy, dev, len+1);
+		if( len > 0 && strcmp(dev, "none")!=0 )
+		{
+			size_t i=0;
+			wishlist[0] = devcopy;
+			while(devcopy[i] != 0 && devcopy[i] != ',') ++i;
+
+			if(devcopy[i] == ',')
+			{
+				devcopy[i] = 0;
+				wishlist[1] = devcopy+i+1;
+			}
+		}
+		if(wishlist[0] == NULL) warning("Not connecting up jack ports as requested.");
+
+		ret = real_connect_jack_ports(handle, wishlist);
+		free(devcopy);
+		return ret;
+	}
+	return 1;
+}
+
+
+static int close_jack(audio_output_t *ao)
+{
+	jack_handle_t *handle = (jack_handle_t*)ao->userptr;
+	
+	debug("close_jack().");
+
+	/* Close and shutdown*/
+	if (handle) {
+		free_jack_handle( handle );
+		ao->userptr = NULL;
+    }
+    
+	return 0;
+}
+
+
+static int open_jack(audio_output_t *ao)
+{
+	char client_name[255];
+	jack_handle_t *handle=NULL;
+	jack_options_t jopt = JackNullOption;
+	jack_status_t jstat = 0;
+	unsigned int i;
+
+	debug("jack open");
+	if(!ao) return -1;
+
+	/* Return if already open*/
+	if (ao->userptr) {
+		error("audio device is already open.");
+		return -1;
+	}
+
+	/* Create some storage for ourselves*/
+	if((handle = alloc_jack_handle()) == NULL) return -1;
+
+	ao->userptr = (void*)handle;
+
+	/* Register with Jack*/
+	snprintf(client_name, 255, "mpg123-%d", getpid());
+	if ((handle->client = jack_client_open(client_name, jopt, &jstat)) == 0) {
+		error1("Failed to open jack client: 0x%x", jstat);
+		close_jack(ao);
+		return -1;
+	}
+	
+	/* Display the unique client name allocated to us */
+	fprintf(stderr,"Registered as JACK client %s.\n",
+		jack_get_client_name( handle->client ) );
+
+	/* The initial open lets me choose the settings. */
+	if (ao->format==-1)
+	{
+		ao->format = MPG123_ENC_16;
+		ao->rate   = jack_get_sample_rate(handle->client);
+		ao->channels = 2;
+	}
+
+	/* Check the sample rate is correct*/
+	if (jack_get_sample_rate( handle->client ) != (jack_nframes_t)ao->rate) {
+		error("JACK Sample Rate is different to sample rate of file.");
+		close_jack(ao);
+		return -1;
+	}
+
+	/* Register ports with Jack*/
+	handle->channels = ao->channels;
+	if (handle->channels == 1) {
+		if (!(handle->ports[0] = jack_port_register(handle->client, "mono", JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0)))
+		{
+			error("Cannot register JACK output port 'mono'.");
+			close_jack(ao);
+			return -1;
+		}
+	} else if (handle->channels == 2) {
+		if (!(handle->ports[0] = jack_port_register(handle->client, "left", JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0)))
+		{
+			error("Cannot register JACK output port 'left'.");
+			close_jack(ao);
+			return -1;
+		}
+		if (!(handle->ports[1] = jack_port_register(handle->client, "right", JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0)))
+		{
+			error("Cannot register JACK output port 'right'.");
+			close_jack(ao);
+			return -1;
+		}
+	} else {
+		error1("invalid number of output channels (%d).", handle->channels);
+		close_jack(ao);
+		return -1;
+	}
+
+	/* Create the ring buffers (one seconds audio)*/
+    handle->rb_size = jack_get_sample_rate(handle->client) * sizeof(jack_default_audio_sample_t);
+    for(i=0;i<handle->channels;i++){
+        handle->rb[i]=jack_ringbuffer_create(handle->rb_size);
+    }
+
+	/* Set the callbacks*/
+	jack_set_process_callback(handle->client, process_callback, (void*)handle);
+	jack_on_shutdown(handle->client, shutdown_callback, (void*)handle);
+	
+	/* Activate client*/
+	if (jack_activate(handle->client)) {
+		error("Can't activate client.");
+	}
+
+	/* Connect up the portsm, return */
+	if(!connect_jack_ports( handle, ao->device ))
+	{
+		/* deregistering of ports will not work but should just fail, then, and let the rest clean up */
+		close_jack(ao);
+		return -1;
+	}
+
+	debug("Jack open successful.\n");
+	return 0;
+}
+
+
+/* Jack prefers floats, I actually assume it does _only_ float/double (as it is nowadays)! */
+static int get_formats_jack(audio_output_t *ao)
+{
+	if(jack_get_sample_rate( ((jack_handle_t*)(ao->userptr))->client ) != (jack_nframes_t)ao->rate) return 0;
+	else return MPG123_ENC_FLOAT_32|MPG123_ENC_FLOAT_64|MPG123_ENC_SIGNED_16;
+}
+
+
+static int write_jack(audio_output_t *ao, unsigned char *buf, int len)
+{
+	int c,n = 0;
+	jack_handle_t *handle = (jack_handle_t*)ao->userptr;
+	jack_nframes_t samples; 
+	size_t tmp_size;
+	/* Only float or double is used.
+	   Note: I still need the tmp buffer because of de-interleaving the channels. */
+	samples = len /
+		(ao->format == MPG123_ENC_FLOAT_64 ? 8 : (ao->format == MPG123_ENC_SIGNED_16 ? 2 : 4))
+		/ handle->channels;
+	tmp_size = samples * sizeof( jack_default_audio_sample_t );
+	
+	
+	/* Sanity check that ring buffer is at least twice the size of the audio we just got*/
+	if (handle->rb_size/2 < len) {
+		error("ring buffer is less than twice the size of audio given.");
+		return -1;
+	}
+	
+	
+	/* Wait until there is space in the ring buffer*/
+	while (jack_ringbuffer_write_space( handle->rb[0] ) < tmp_size) {
+		/* Sleep for a quarter of the ring buffer size (1/4 second)*/
+		usleep(250000);
+	}
+	
+	
+	/* Ensure the temporary buffer is big enough*/
+	handle->tmp_buffer = (jack_default_audio_sample_t*)realloc( handle->tmp_buffer, tmp_size);
+	if (!handle->tmp_buffer) {
+		error("failed to realloc temporary buffer.");
+		return -1;
+	}
+	
+	
+	for(c=0; c<handle->channels; c++) {
+		size_t len = 0;
+		
+		/* Hm, is that optimal? Anyhow, deinterleaving float or double ... or short. With/without conversion. */
+		if(ao->format == MPG123_ENC_SIGNED_16)
+		{
+			short* src = (short*)buf;
+			for(n=0; n<samples; n++)
+			handle->tmp_buffer[n] = src[(n*handle->channels)+c] / 32768.0f;
+		}
+		else if(ao->format == MPG123_ENC_FLOAT_32)
+		{
+			float* src = (float*)buf;
+			for(n=0; n<samples; n++)
+			handle->tmp_buffer[n] = src[(n*handle->channels)+c];
+		}
+		else /* MPG123_ENC_FLOAT_64 */
+		{
+			double* src = (double*)buf;
+			for(n=0; n<samples; n++)
+			handle->tmp_buffer[n] = src[(n*handle->channels)+c];
+		}
+		/* Copy temporary buffer into ring buffer*/
+		len = jack_ringbuffer_write(handle->rb[c], (char*)handle->tmp_buffer, tmp_size);
+		if (len < tmp_size)
+        {
+			error("failed to write to ring ruffer.");
+			return -1;
+		}
+	}
+	
+	
+	return len;
+}
+
+static void flush_jack(audio_output_t *ao)
+{
+	jack_handle_t *handle = (jack_handle_t*)ao->userptr;
+	int c;
+
+	warning("This way, we drop audio on pausing... there must be a better way.");
+	/* Reset the ring buffers*/
+	for(c=0; c<handle->channels; c++) {
+		jack_ringbuffer_reset(handle->rb[c]);
+	}
+}
+
+static int init_jack(audio_output_t* ao)
+{
+	if (ao==NULL) return -1;
+	
+	/* Set callbacks */
+	ao->open = open_jack;
+	ao->flush = flush_jack;
+	ao->write = write_jack;
+	ao->get_formats = get_formats_jack;
+	ao->close = close_jack;
+
+	/* Success */
+	return 0;
+}
+
+
+/* 
+	Module information data structure
+*/
+mpg123_module_t mpg123_output_module_info = {
+	/* api_version */	MPG123_MODULE_API_VERSION,
+	/* name */			"jack",
+	/* description */	"Output audio using JACK (JACK Audio Connection Kit).",
+	/* revision */		"$Rev:$",
+	/* handle */		NULL,
+
+	/* init_output */	init_jack,						
+};