seal 0.1.0

data/mpg123/src/output/pulse.c

@@ -0,0 +1,164 @@
+/*
+	pulse: audio output using PulseAudio server
+
+	copyright 2006-9 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 <stdlib.h>
+#include <stdio.h>
+#include <math.h>
+
+#include <pulse/simple.h>
+#include <pulse/error.h>
+
+#include "config.h"
+#include "mpg123app.h"
+#include "audio.h"
+#include "module.h"
+#include "debug.h"
+
+static int open_pulse(audio_output_t *ao)
+{
+	int err;
+	pa_simple* pas = NULL;
+	pa_sample_spec ss;
+	/* Check if already open ? */
+	if (ao->userptr) {
+		error("Pulse audio output is already open.");
+		return -1;
+	}
+
+	/* Open an audio I/O stream. */
+	/* When they are < 0, I shall set some default. */
+	if(ao->rate < 0 || ao->format < 0 || ao->channels < 0)
+	{
+		ao->rate     = 44100;
+		ao->channels = 2;
+		ao->format   = MPG123_ENC_SIGNED_16;
+	}
+
+	/* Fill out pulse audio's data structure */
+	ss.channels = ao->channels;
+	ss.rate = ao->rate;
+
+	switch(ao->format) {
+		case MPG123_ENC_SIGNED_16:
+#ifdef WORDS_BIGENDIAN
+			ss.format=PA_SAMPLE_S16BE;
+#else
+			ss.format=PA_SAMPLE_S16LE;
+#endif
+		break;
+		case MPG123_ENC_ALAW_8:
+			ss.format=PA_SAMPLE_ALAW;
+		break;
+		case MPG123_ENC_ULAW_8:
+			ss.format=PA_SAMPLE_ULAW;
+		break;
+		case MPG123_ENC_UNSIGNED_8:
+			ss.format=PA_SAMPLE_U8;
+		break;
+		default:
+			error1("Unsupported audio format: 0x%x", ao->format);
+			return -1;
+		break;
+	}
+
+
+	/* Perform the open */
+	pas = pa_simple_new(
+			NULL,				/* Use the default server */
+			"mpg123",			/* Our application's name */
+			PA_STREAM_PLAYBACK,
+			ao->device,			/* Use the default device if NULL */
+			"MPEG Audio",		/* Description of our stream */
+			&ss,				/* Our sample format */
+			NULL,				/* Use default channel map */
+			NULL,				/* Use default buffering attributes */
+			&err				/* Error result code */
+	);
+
+	if( pas == NULL ) {
+		error1("Failed to open pulse audio output: %s", pa_strerror(err));
+		return -1;
+	}
+
+	/* Store the pointer */
+	ao->userptr = (void*)pas;
+	return 0;
+}
+
+
+static int get_formats_pulse(audio_output_t *ao)
+{
+	/* Only implemented Signed 16-bit audio for now */
+	return MPG123_ENC_SIGNED_16;
+}
+
+
+static int write_pulse(audio_output_t *ao, unsigned char *buf, int len)
+{
+	pa_simple *pas = (pa_simple*)ao->userptr;
+	int ret, err;
+	/* Doesn't return number of bytes but just success or not. */
+	ret = pa_simple_write( pas, buf, len, &err );
+	if(ret<0){ error1("Failed to write audio: %s", pa_strerror(err)); return -1; }
+
+	return len; /* If successful, everything has been written. */
+}
+
+static int close_pulse(audio_output_t *ao)
+{
+	pa_simple *pas = (pa_simple*)ao->userptr;
+
+	if (pas) {
+		pa_simple_free( pas );
+		ao->userptr = NULL;
+	}
+	
+	return 0;
+}
+
+static void flush_pulse(audio_output_t *ao)
+{
+	pa_simple *pas = (pa_simple*)ao->userptr;
+	
+	if (pas) {
+		int err;
+		pa_simple_flush( pas, &err );	
+		if (err) error1("Failed to flush audio: %s", pa_strerror(err));
+	}
+}
+
+
+static int init_pulse(audio_output_t* ao)
+{
+	if (ao==NULL) return -1;
+
+	/* Set callbacks */
+	ao->open = open_pulse;
+	ao->flush = flush_pulse;
+	ao->write = write_pulse;
+	ao->get_formats = get_formats_pulse;
+	ao->close = close_pulse;
+
+	/* Success */
+	return 0;
+}
+
+
+/* 
+	Module information data structure
+*/
+mpg123_module_t mpg123_output_module_info = {
+	/* api_version */	MPG123_MODULE_API_VERSION,
+	/* name */			"pulse",						
+	/* description */	"Output audio using PulseAudio Server",
+	/* revision */		"$Rev:$",						
+	/* handle */		NULL,
+	
+	/* init_output */	init_pulse,						
+};
+

data/mpg123/src/output/sdl.c

@@ -0,0 +1,206 @@
+/*
+	sdl: audio output via SDL cross-platform API
+
+	copyright 2006-9 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 <SDL.h>
+
+#include "audio.h"
+#include "mpg123app.h"
+#ifdef WIN32
+#include <windows.h>
+#endif
+
+/* Including the sfifo code locally, to avoid module linkage issues. */
+#define SFIFO_STATIC
+#include "sfifo.c"
+
+#include "debug.h"
+
+
+#define SAMPLE_SIZE			(2)
+#define FRAMES_PER_BUFFER	(256)
+#define FIFO_DURATION		(0.5f)
+
+
+
+
+/* The audio function callback takes the following parameters:
+       stream:  A pointer to the audio buffer to be filled
+       len:     The length (in bytes) of the audio buffer
+*/
+static void audio_callback_sdl(void *udata, Uint8 *stream, int len)
+{
+	audio_output_t *ao = (audio_output_t*)udata;
+	sfifo_t *fifo = (sfifo_t*)ao->userptr;
+	int bytes_read;
+
+	/* Only play if we have data left */
+	if ( sfifo_used( fifo ) < len ) {
+		warning("Didn't have any audio data for SDL (buffer underflow)");
+		SDL_PauseAudio(1);
+		return;
+	}
+
+	/* Read audio from FIFO to SDL's buffer */
+	bytes_read = sfifo_read( fifo, stream, len );
+	
+	if (len!=bytes_read)
+		warning2("Error reading from the FIFO (wanted=%u, bytes_read=%u).\n", len, bytes_read);
+
+} 
+
+static int open_sdl(audio_output_t *ao)
+{
+	sfifo_t *fifo = (sfifo_t*)ao->userptr;
+	
+	/* Open an audio I/O stream. */
+	if (ao->rate > 0 && ao->channels >0 ) {
+		size_t ringbuffer_len;
+		SDL_AudioSpec wanted;
+	
+		/* L16 uncompressed audio data, using 16-bit signed representation in twos 
+		   complement notation - system endian-ness. */
+		wanted.format = AUDIO_S16SYS;
+		wanted.samples = 1024;  /* Good low-latency value for callback */ 
+		wanted.callback = audio_callback_sdl; 
+		wanted.userdata = ao; 
+		wanted.channels = ao->channels; 
+		wanted.freq = ao->rate; 
+	
+		/* Open the audio device, forcing the desired format */
+		if ( SDL_OpenAudio(&wanted, NULL) ) {
+			error1("Couldn't open SDL audio: %s\n", SDL_GetError());
+			return -1;
+		}
+		
+		/* Initialise FIFO */
+		ringbuffer_len = ao->rate * FIFO_DURATION * SAMPLE_SIZE *ao->channels;
+		debug2( "Allocating %d byte ring-buffer (%f seconds)", (int)ringbuffer_len, (float)FIFO_DURATION);
+		if (sfifo_init( fifo, ringbuffer_len )) error1( "Failed to initialise FIFO of size %d bytes", (int)ringbuffer_len );
+	}
+	
+	return(0);
+}
+
+
+static int get_formats_sdl(audio_output_t *ao)
+{
+	/* Only implemented Signed 16-bit audio for now */
+	return MPG123_ENC_SIGNED_16;
+}
+
+
+static int write_sdl(audio_output_t *ao, unsigned char *buf, int len)
+{
+	sfifo_t *fifo = (sfifo_t*)ao->userptr;
+
+	/* Sleep for half the length of the FIFO */
+	while (sfifo_space( fifo ) < len )
+#ifdef WIN32
+		Sleep( (FIFO_DURATION/2) * 1000);
+#else
+		usleep( (FIFO_DURATION/2) * 1000000 );
+#endif
+	
+	/* Bung decoded audio into the FIFO 
+		 SDL Audio locking probably isn't actually needed
+		 as SFIFO claims to be thread safe...
+	*/
+	SDL_LockAudio();
+	sfifo_write( fifo, buf, len);
+	SDL_UnlockAudio();
+	
+	
+	/* Unpause once the buffer is 50% full */
+	if (sfifo_used(fifo) > (sfifo_size(fifo)*0.5) ) SDL_PauseAudio(0);
+
+	return len;
+}
+
+static int close_sdl(audio_output_t *ao)
+{
+	sfifo_t *fifo = (sfifo_t*)ao->userptr;
+
+	SDL_CloseAudio();
+	
+	/* Free up the memory used by the FIFO */
+	sfifo_close( fifo );
+	
+	return 0;
+}
+
+static void flush_sdl(audio_output_t *ao)
+{
+	sfifo_t *fifo = (sfifo_t*)ao->userptr;
+
+	SDL_PauseAudio(1);
+	
+	sfifo_flush( fifo );	
+}
+
+
+static int deinit_sdl(audio_output_t* ao)
+{
+	/* Free up memory */
+	if (ao->userptr) {
+		free( ao->userptr );
+		ao->userptr = NULL;
+	}
+
+	/* Shut down SDL */
+	SDL_Quit();
+
+	/* Success */
+	return 0;
+}
+
+
+static int init_sdl(audio_output_t* ao)
+{
+	if (ao==NULL) return -1;
+	
+	/* Set callbacks */
+	ao->open = open_sdl;
+	ao->flush = flush_sdl;
+	ao->write = write_sdl;
+	ao->get_formats = get_formats_sdl;
+	ao->close = close_sdl;
+	ao->deinit = deinit_sdl;
+	
+	/* Allocate memory */
+	ao->userptr = malloc( sizeof(sfifo_t) );
+	if (ao->userptr==NULL) {
+		error( "Failed to allocated memory for FIFO structure" );
+		return -1;
+	}
+	memset( ao->userptr, 0, sizeof(sfifo_t) );
+
+	/* Initialise SDL */
+	if (SDL_Init( SDL_INIT_AUDIO ) ) {
+		error1("Failed to initialise SDL: %s\n", SDL_GetError());
+		return -1;
+	}
+
+	/* Success */
+	return 0;
+}
+
+
+/* 
+	Module information data structure
+*/
+mpg123_module_t mpg123_output_module_info = {
+	/* api_version */	MPG123_MODULE_API_VERSION,
+	/* name */			"sdl",
+	/* description */	"Output audio using SDL (Simple DirectMedia Layer).",
+	/* revision */		"$Rev:$",
+	/* handle */		NULL,
+	
+	/* init_output */	init_sdl,
+};

data/mpg123/src/output/sgi.c

@@ -0,0 +1,213 @@
+/*
+	sgi: audio output on SGI boxen
+
+	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 (as it seems) by Thomas Woerner
+*/
+
+#include <fcntl.h>
+
+/* #include <audio.h> */
+#include <dmedia/audio.h>
+
+#include "mpg123app.h"
+#include "debug.h"
+
+
+/* Analog output constant */
+static const char analog_output_res_name[] = ".AnalogOut";
+
+
+static int set_rate(audio_output_t *ao, ALconfig config)
+{
+	int dev = alGetDevice(config);
+	ALpv params[1];
+	
+	/* Make sure the device is OK */
+	if (dev < 0)
+	{
+		error1("set_rate: %s",alGetErrorString(oserror()));
+		return 1;      
+	}
+	
+	params[0].param = AL_OUTPUT_RATE;
+	params[0].value.ll = alDoubleToFixed(ao->rate);
+	
+	if (alSetParams(dev, params,1) < 0)
+		error1("set_rate: %s",alGetErrorString(oserror()));
+	
+	return 0;
+}
+
+
+static int set_channels(audio_output_t *ao, ALconfig config)
+{
+	int ret;
+	
+	if(ao->channels == 2)
+		ret = alSetChannels(config, AL_STEREO);
+	else
+		ret = alSetChannels(config, AL_MONO);
+	
+	if (ret < 0)
+		error1("set_channels : %s",alGetErrorString(oserror()));
+	
+	return 0;
+}
+
+static int set_format(audio_output_t *ao, ALconfig config)
+{
+	if (alSetSampFmt(config,AL_SAMPFMT_TWOSCOMP) < 0)
+		error1("set_format : %s",alGetErrorString(oserror()));
+	
+	if (alSetWidth(config,AL_SAMPLE_16) < 0)
+		error1("set_format : %s",alGetErrorString(oserror()));
+	
+	return 0;
+}
+
+
+static int open_sgi(audio_output_t *ao)
+{
+	int dev = AL_DEFAULT_OUTPUT;
+	ALconfig config = alNewConfig();
+	ALport port = NULL;
+	
+	/* Test for correct completion */
+	if (config == 0) {
+		error1("open_sgi: %s",alGetErrorString(oserror()));
+		return -1;
+	}
+	
+	/* Set port parameters */
+	if(ao->channels == 2)
+		alSetChannels(config, AL_STEREO);
+	else
+		alSetChannels(config, AL_MONO);
+	
+	alSetWidth(config, AL_SAMPLE_16);
+	alSetSampFmt(config,AL_SAMPFMT_TWOSCOMP);
+	alSetQueueSize(config, 131069);
+	
+	/* Setup output device to specified module. If there is no module
+	specified in ao structure, use the default four output */
+	if ((ao->device) != NULL) {
+		char *dev_name;
+		
+		dev_name=malloc((strlen(ao->device) + strlen(analog_output_res_name) + 1) *
+		  sizeof(char));
+		
+		strcpy(dev_name,ao->device);
+		strcat(dev_name,analog_output_res_name);
+		
+		/* Find the asked device resource */
+		dev=alGetResourceByName(AL_SYSTEM,dev_name,AL_DEVICE_TYPE);
+		
+		/* Free allocated space */
+		free(dev_name);
+		
+		if (!dev) {
+			error2("Invalid audio resource: %s (%s)",dev_name, alGetErrorString(oserror()));
+			return -1;
+		}
+	}
+	
+	/* Set the device */
+	if (alSetDevice(config,dev) < 0)
+	{
+		error1("open_sgi: %s",alGetErrorString(oserror()));
+		return -1;
+	}
+	
+	/* Open the audio port */
+	port = alOpenPort("mpg123-VSC", "w", config);
+	if(port == NULL) {
+		error1("Unable to open audio channel: %s", alGetErrorString(oserror()));
+		return -1;
+	}
+	
+	ao->userptr = (void*)port;
+	
+	
+	set_format(ao, config);
+	set_channels(ao, config);
+	set_rate(ao, config);
+	
+	
+	alFreeConfig(config);
+	
+	return 1;
+}
+
+
+static int get_formats_sgi(audio_output_t *ao)
+{
+	return MPG123_ENC_SIGNED_16;
+}
+
+
+static int write_sgi(audio_output_t *ao,unsigned char *buf,int len)
+{
+	ALport port = (ALport)ao->userptr;
+	
+	if(ao->format == MPG123_ENC_SIGNED_8)
+		alWriteFrames(port, buf, len>>1);
+	else
+		alWriteFrames(port, buf, len>>2);
+	
+	return len;
+}
+
+
+static int close_sgi(audio_output_t *ao)
+{
+	ALport port = (ALport)ao->userptr;
+	
+	if (port) {
+		while(alGetFilled(port) > 0) sginap(1);  
+		alClosePort(port);
+		ao->userptr=NULL;
+	}
+	
+	return 0;
+}
+
+static void flush_sgi(audio_output_t *ao)
+{
+}
+
+
+static int init_sgi(audio_output_t* ao)
+{
+	if (ao==NULL) return -1;
+
+	/* Set callbacks */
+	ao->open = open_sgi;
+	ao->flush = flush_sgi;
+	ao->write = write_sgi;
+	ao->get_formats = get_formats_sgi;
+	ao->close = close_sgi;
+
+	/* Success */
+	return 0;
+}
+
+
+
+
+
+/* 
+	Module information data structure
+*/
+mpg123_module_t mpg123_output_module_info = {
+	/* api_version */	MPG123_MODULE_API_VERSION,
+	/* name */			"sgi",						
+	/* description */	"Audio output for SGI.",
+	/* revision */		"$Rev:$",						
+	/* handle */		NULL,
+	
+	/* init_output */	init_sgi,						
+};
+
+