seal 0.1.0

data/mpg123/src/output/sndio.c

@@ -0,0 +1,161 @@
+/*
+ *	sndio: sndio audio output
+ *
+ * Copyright (c) 2008 Christian Weisgerber <naddy@openbsd.org>,
+ *                    Alexandre Ratchov <alex@caoua.org>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include "mpg123app.h"
+
+#include <sndio.h>
+
+#include "debug.h"
+
+static int open_sndio(audio_output_t *ao)
+{
+	struct sio_hdl *hdl;
+	struct sio_par par;
+
+	hdl = sio_open(ao->device /* NULL is fine */, SIO_PLAY, 0);
+	if (hdl == NULL)
+		return -1;
+
+	sio_initpar(&par);
+	par.rate = ao->rate;
+	par.pchan = ao->channels;
+	par.le = SIO_LE_NATIVE;
+	switch(ao->format) {
+	case MPG123_ENC_SIGNED_32:
+		par.sig = 1;
+		par.bits = 32;
+		break;
+	case MPG123_ENC_UNSIGNED_32:
+		par.sig = 0;
+		par.bits = 32;
+		break;
+	case MPG123_ENC_SIGNED_16:
+	case -1: /* query mode */
+		par.sig = 1;
+		par.bits = 16;
+		break;
+	case MPG123_ENC_UNSIGNED_16:
+		par.sig = 0;
+		par.bits = 16;
+		break;
+	case MPG123_ENC_UNSIGNED_8:
+		par.sig = 0;
+		par.bits = 8;
+		break;
+	case MPG123_ENC_SIGNED_8:
+		par.sig = 1;
+		par.bits = 8;
+		break;
+	default:
+		if (!AOQUIET)
+			error1("open_sndio: invalid sample format %d",
+			    ao->format);
+		sio_close(hdl);
+		return -1;
+	}
+
+	if (!sio_setpar(hdl, &par) || !sio_getpar(hdl, &par) || 
+	    !sio_start(hdl)) {
+		sio_close(hdl);
+		return -1;
+	}
+	if ((par.bits != 8 && par.bits != 16 && par.bits != 32) ||
+	    par.le != SIO_LE_NATIVE) {
+		sio_close(hdl);
+		return -1;
+	}
+	ao->rate = par.rate;
+	ao->channels = par.pchan;
+	switch (par.bits) {
+	case 8:
+		ao->format = par.sig ? MPG123_ENC_SIGNED_8 :
+		    MPG123_ENC_UNSIGNED_8;
+		break;
+	case 16:
+		ao->format = par.sig ? MPG123_ENC_SIGNED_16 :
+		    MPG123_ENC_UNSIGNED_16;
+		break;
+	case 32:
+		ao->format = par.sig ? MPG123_ENC_SIGNED_32 :
+		    MPG123_ENC_UNSIGNED_32;
+		break;
+	}
+	ao->userptr = hdl;
+	return 0;
+}
+
+static int get_formats_sndio(audio_output_t *ao)
+{
+	return (MPG123_ENC_SIGNED_32|MPG123_ENC_UNSIGNED_32|
+	    MPG123_ENC_SIGNED_16|MPG123_ENC_UNSIGNED_16|
+	    MPG123_ENC_UNSIGNED_8|MPG123_ENC_SIGNED_8);
+}
+
+static int write_sndio(audio_output_t *ao, unsigned char *buf, int len)
+{
+	struct sio_hdl *hdl = (struct sio_hdl *)ao->userptr;
+	int count;
+
+	count = (int)sio_write(hdl, buf, len);
+	if (count == 0 && sio_eof(hdl))
+		return -1;
+	return count;
+}
+
+static void flush_sndio(audio_output_t *ao)
+{
+	return;
+}
+
+static int close_sndio(audio_output_t *ao)
+{
+	struct sio_hdl *hdl = (struct sio_hdl *)ao->userptr;
+
+	sio_close(hdl);
+	return 0;
+}
+
+static int init_sndio(audio_output_t* ao)
+{
+	if (ao == NULL)
+		return -1;
+	
+	/* Set callbacks */
+	ao->open = open_sndio;
+	ao->flush = flush_sndio;	/* required */
+	ao->write = write_sndio;
+	ao->get_formats = get_formats_sndio;
+	ao->close = close_sndio;
+
+	/* Success */
+	return 0;
+}
+
+/* 
+	Module information data structure
+*/
+mpg123_module_t mpg123_output_module_info = {
+	/* api_version */	MPG123_MODULE_API_VERSION,
+	/* name */		"sndio",						
+	/* description */	"Output audio using sndio library",
+	/* revision */		"$Rev:$",						
+	/* handle */		NULL,
+	
+	/* init_output */	init_sndio,						
+};

data/mpg123/src/output/sun.c

@@ -0,0 +1,281 @@
+/*
+	sun: audio output for Sun systems
+
+	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"
+
+#ifdef HAVE_SYS_IOCTL_H
+#include <sys/ioctl.h>
+#endif
+
+#ifdef HAVE_SUN_AUDIOIO_H
+#include <sun/audioio.h>
+#endif
+
+#ifdef HAVE_SYS_AUDIOIO_H
+#include <sys/audioio.h>
+#endif
+
+#ifdef HAVE_SYS_AUDIO_H
+#include <sys/audio.h>
+#endif
+
+#ifdef HAVE_ASM_AUDIOIO_H
+#include <asm/audioio.h>
+#endif
+
+#include <fcntl.h>
+#include "debug.h"
+
+static void set_format_helper(audio_output_t *ao, audio_info_t *ainfo)
+{
+	
+	switch(ao->format) {
+		case -1:
+		case MPG123_ENC_SIGNED_16:
+		default:
+#ifndef AUDIO_ENCODING_LINEAR	/* not supported */
+#define AUDIO_ENCODING_LINEAR 3
+#endif
+			ainfo->play.encoding = AUDIO_ENCODING_LINEAR;
+			ainfo->play.precision = 16;
+		break;
+		case MPG123_ENC_UNSIGNED_8:
+#if defined(SOLARIS) || defined(SPARCLINUX)
+			ainfo->play.encoding = AUDIO_ENCODING_LINEAR8;
+			ainfo->play.precision = 8;
+		break;
+#endif
+		case MPG123_ENC_SIGNED_8:
+			error("Linear signed 8 bit not supported!");
+		return;
+		case MPG123_ENC_ULAW_8:
+			ainfo->play.encoding = AUDIO_ENCODING_ULAW;
+			ainfo->play.precision = 8;
+		break;
+		case MPG123_ENC_ALAW_8:
+			ainfo->play.encoding = AUDIO_ENCODING_ALAW;
+			ainfo->play.precision = 8;
+		break;
+	}
+  
+}
+
+
+static int reset_parameters_sun(audio_output_t *ao)
+{
+	audio_info_t ainfo;
+
+	AUDIO_INITINFO(&ainfo);
+	if(ao->rate != -1) ainfo.play.sample_rate = ao->rate;
+
+	if(ao->channels >= 0) ainfo.play.channels = ao->channels;
+
+	set_format_helper(ao,&ainfo);
+	if(ioctl(ao->fn, AUDIO_SETINFO, &ainfo) == -1) return -1;
+
+	return 0;
+}
+
+static int rate_best_match(audio_output_t *ao)
+{
+	audio_info_t ainfo;
+	AUDIO_INITINFO(&ainfo);
+	
+	ainfo.play.sample_rate = ao->rate;
+	if(ioctl(ao->fn, AUDIO_SETINFO, &ainfo) < 0) {
+		ao->rate = 0;
+		return 0;
+	}
+	if(ioctl(ao->fn, AUDIO_GETINFO, &ainfo) < 0) {
+		return -1;
+	}
+	
+	ao->rate = ainfo.play.sample_rate;
+	return 0;
+}
+
+static int set_rate(audio_output_t *ao)
+{
+	audio_info_t ainfo;
+	
+	if(ao->rate != -1) {
+		AUDIO_INITINFO(&ainfo);
+		ainfo.play.sample_rate = ao->rate;
+		if(ioctl(ao->fn, AUDIO_SETINFO, &ainfo) == -1) return -1;
+		return 0;
+	}
+	
+	return -1;
+}
+
+static int set_channels(audio_output_t *ao)
+{
+	audio_info_t ainfo;
+	
+	AUDIO_INITINFO(&ainfo);
+	ainfo.play.channels = ao->channels;
+	if(ioctl(ao->fn, AUDIO_SETINFO, &ainfo) == -1)
+		return -1;
+
+	return 0;
+}
+
+static int set_format(audio_output_t *ao)
+{
+	audio_info_t ainfo;
+	
+	AUDIO_INITINFO(&ainfo);
+	set_format_helper(ao,&ainfo);
+	if(ioctl(ao->fn, AUDIO_SETINFO, &ainfo) == -1)
+		return -1;
+	
+	return 0;
+}
+
+static int open_sun(audio_output_t *ao)
+{
+	audio_info_t ainfo;
+	
+	if(!ao->device) {
+		if(getenv("AUDIODEV")) {
+			ao->device = getenv("AUDIODEV");
+		} else {
+			ao->device = "/dev/audio";
+		}
+	}
+	
+	ao->fn = open(ao->device,O_WRONLY);
+	if(ao->fn < 0) return ao->fn;
+	
+#if defined(SUNOS)  &&  defined(AUDIO_GETDEV)
+	{
+		int type;
+		if(ioctl(ao->fn, AUDIO_GETDEV, &type) == -1) return -1;
+		if(type == AUDIO_DEV_UNKNOWN || type == AUDIO_DEV_AMD)
+			return -1;
+	}
+#else
+#if defined(SOLARIS) || defined(SPARCLINUX)
+	{
+		struct audio_device ad;
+		if(ioctl(ao->fn, AUDIO_GETDEV, &ad) == -1)
+			return -1;
+		if(!strstr(ad.name,"dbri") && !strstr(ad.name,"CS4231"))
+			warning1("Unknown sound system %s. But we try it.",ad.name);
+	}
+#endif
+#endif
+	
+	if(reset_parameters_sun(ao) < 0) return -1;
+	
+	AUDIO_INITINFO(&ainfo);
+	
+	if(ao->flags > 0)
+		ainfo.play.port = 0;
+	if(ao->flags & AUDIO_OUT_INTERNAL_SPEAKER)
+		ainfo.play.port |= AUDIO_SPEAKER;
+	if(ao->flags & AUDIO_OUT_HEADPHONES)
+		ainfo.play.port |= AUDIO_HEADPHONE;
+	#ifdef AUDIO_LINE_OUT
+	if(ao->flags & AUDIO_OUT_LINE_OUT)
+		ainfo.play.port |= AUDIO_LINE_OUT;
+	#endif
+	
+	if(ao->gain != -1)
+		ainfo.play.gain = ao->gain;
+	
+	if(ioctl(ao->fn, AUDIO_SETINFO, &ainfo) == -1)
+		return -1;
+	
+	return ao->fn;
+}
+
+
+
+
+static int get_formats_sun(audio_output_t *ao)
+{
+	static int tab[][3] = {
+		{ AUDIO_ENCODING_ULAW , 8,  MPG123_ENC_ULAW_8 } ,
+		{ AUDIO_ENCODING_ALAW , 8,  MPG123_ENC_ALAW_8 } ,
+		{ AUDIO_ENCODING_LINEAR , 16,  MPG123_ENC_SIGNED_16 } ,
+#if 0
+#if defined(SOLARIS) || defined(SPARCLINUX)
+		{ AUDIO_ENCODING_LINEAR8 , 8,  MPG123_ENC_UNSIGNED_8 } ,
+#endif
+#endif
+	};
+
+	audio_info_t ainfo;
+	int i,fmts=0;
+
+	for(i=0;i<sizeof(tab)/sizeof(tab[0]);i++) {
+		AUDIO_INITINFO(&ainfo);
+		ainfo.play.encoding = tab[i][0];
+		ainfo.play.precision = tab[i][1];
+#if 1
+		ainfo.play.sample_rate = ao->rate;
+		ainfo.play.channels = ao->channels;
+#endif
+		if(ioctl(ao->fn, AUDIO_SETINFO, &ainfo) >= 0) {
+			fmts |= tab[i][2];
+		}
+	}
+	return fmts;
+}
+
+static int write_sun(audio_output_t *ao,unsigned char *buf,int len)
+{
+	return write(ao->fn,buf,len);
+}
+
+static int close_sun(audio_output_t *ao)
+{
+	close (ao->fn);
+	return 0;
+}
+
+static void flush_sun(audio_output_t *ao)
+{
+	/*ioctl (ao->fn, I_FLUSH, FLUSHRW);*/
+}
+
+
+static int init_sun(audio_output_t* ao)
+{
+	if (ao==NULL) return -1;
+
+	/* Set callbacks */
+	ao->open = open_sun;
+	ao->flush = flush_sun;
+	ao->write = write_sun;
+	ao->get_formats = get_formats_sun;
+	ao->close = close_sun;
+
+	/* Success */
+	return 0;
+}
+
+
+
+
+
+/* 
+	Module information data structure
+*/
+mpg123_module_t mpg123_output_module_info = {
+	/* api_version */	MPG123_MODULE_API_VERSION,
+	/* name */			"sun",						
+	/* description */	"Audio output for Sun Audio.",
+	/* revision */		"$Rev: 1872 $",						
+	/* handle */		NULL,
+	
+	/* init_output */	init_sun,						
+};
+
+

data/mpg123/src/output/win32.c

@@ -0,0 +1,229 @@
+/*
+	win32: audio output for Windows 32bit
+
+	copyright ?-2007 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 Tony Million
+	rewrite of basic functionality for callback-less and properly ringbuffered operation by ravenexp
+*/
+
+#include "mpg123app.h"
+#include <windows.h>
+#include "debug.h"
+
+/*
+	Buffer size and number of buffers in the playback ring
+	NOTE: This particular num/size combination performs best under heavy
+	loads for my system, however this may not be true for any hardware/OS out there.
+	Generally, BUFFER_SIZE < 8k || NUM_BUFFERS > 16 || NUM_BUFFERS < 4 are not recommended.
+*/
+#define BUFFER_SIZE 0x10000
+#define NUM_BUFFERS 8  /* total 512k roughly 2.5 sec of CD quality sound */
+
+/* Buffer ring queue state */
+struct queue_state
+{
+	WAVEHDR buffer_headers[NUM_BUFFERS];
+	/* The next buffer to be filled and put in playback */
+	int next_buffer;
+	/* Buffer playback completion event */
+	HANDLE play_done_event;
+	HWAVEOUT waveout;
+};
+
+static int open_win32(struct audio_output_struct *ao)
+{
+	struct queue_state* state;
+	int i;
+	MMRESULT res;
+	WAVEFORMATEX out_fmt;
+	UINT dev_id;
+
+	if(!ao) return -1;
+	if(ao->rate == -1) return 0;
+
+	/* Allocate queue state struct for this device */
+	state = calloc(1, sizeof(struct queue_state));
+	if(!state) return -1;
+
+	ao->userptr = state;
+	/* Allocate playback buffers */
+	for(i = 0; i < NUM_BUFFERS; i++)
+	if(!(state->buffer_headers[i].lpData = malloc(BUFFER_SIZE)))
+	ereturn(-1, "Out of memory for playback buffers.");
+
+	state->play_done_event = CreateEvent(0,FALSE,FALSE,0);
+	if(state->play_done_event == INVALID_HANDLE_VALUE) return -1;
+
+	/* FIXME: real device enumeration by capabilities? */
+	dev_id = WAVE_MAPPER;	/* probably does the same thing */
+	ao->device = "WaveMapper";
+	/* FIXME: support for smth besides MPG123_ENC_SIGNED_16? */
+	out_fmt.wFormatTag = WAVE_FORMAT_PCM;
+	out_fmt.wBitsPerSample = 16;
+	out_fmt.nChannels = ao->channels;
+	out_fmt.nSamplesPerSec = ao->rate;
+	out_fmt.nBlockAlign = out_fmt.nChannels*out_fmt.wBitsPerSample/8;
+	out_fmt.nAvgBytesPerSec = out_fmt.nBlockAlign*out_fmt.nSamplesPerSec;
+	out_fmt.cbSize = 0;
+
+	res = waveOutOpen(&state->waveout, dev_id, &out_fmt,
+	                  (DWORD_PTR)state->play_done_event, 0, CALLBACK_EVENT);
+
+	switch(res)
+	{
+		case MMSYSERR_NOERROR:
+			break;
+		case MMSYSERR_ALLOCATED:
+			ereturn(-1, "Audio output device is already allocated.");
+		case MMSYSERR_NODRIVER:
+			ereturn(-1, "No device driver is present.");
+		case MMSYSERR_NOMEM:
+			ereturn(-1, "Unable to allocate or lock memory.");
+		case WAVERR_BADFORMAT:
+			ereturn(-1, "Unsupported waveform-audio format.");
+		default:
+			ereturn(-1, "Unable to open wave output device.");
+	}
+
+	/* Reset event from the "device open" message */
+	ResetEvent(state->play_done_event);
+	return 0;
+}
+
+static int get_formats_win32(struct audio_output_struct *ao)
+{
+	/* FIXME: support for smth besides MPG123_ENC_SIGNED_16? */
+	return MPG123_ENC_SIGNED_16;
+}
+
+/* Stores audio data to the fixed size buffers and pushes them into the playback queue.
+   I have one grief with that: The last piece of a track may not reach the output,
+   only full buffers sent... But we don't get smooth audio otherwise. */
+static int write_win32(struct audio_output_struct *ao, unsigned char *buf, int len)
+{
+	struct queue_state* state;
+	MMRESULT res;
+	WAVEHDR* hdr;
+
+	int rest_len; /* Input data bytes left for next recursion. */
+	int bufill;   /* Bytes we stuff into buffer now. */
+
+	if(!ao || !ao->userptr) return -1;
+	if(!buf || len <= 0) return 0;
+
+	state = (struct queue_state*)ao->userptr;
+	hdr = &state->buffer_headers[state->next_buffer];
+
+	/* Check buffer header and wait if it's being played.
+	   Skip waiting if the buffer is not full yet */
+	while(hdr->dwBufferLength == BUFFER_SIZE && !(hdr->dwFlags & WHDR_DONE))
+	{
+		/* debug1("waiting for buffer %i...", state->next_buffer); */
+		WaitForSingleObject(state->play_done_event, INFINITE);
+	}
+
+	/* If it was a full buffer being played, clean up. */
+	if(hdr->dwFlags & WHDR_DONE)
+	{
+		waveOutUnprepareHeader(state->waveout, hdr, sizeof(WAVEHDR));
+		hdr->dwFlags = 0;
+		hdr->dwBufferLength = 0;
+	}
+
+	/* Now see how much we want to stuff in and then stuff it in. */
+	bufill = BUFFER_SIZE - hdr->dwBufferLength;
+	if(len < bufill) bufill = len;
+
+	rest_len = len - bufill;
+	memcpy(hdr->lpData + hdr->dwBufferLength, buf, bufill);
+	hdr->dwBufferLength += bufill;
+	if(hdr->dwBufferLength == BUFFER_SIZE)
+	{ /* Send the buffer out when it's full. */
+		res = waveOutPrepareHeader(state->waveout, hdr, sizeof(WAVEHDR));
+		if(res != MMSYSERR_NOERROR) ereturn(-1, "Can't write to audio output device (prepare).");
+
+		res = waveOutWrite(state->waveout, hdr, sizeof(WAVEHDR));
+		if(res != MMSYSERR_NOERROR) ereturn(-1, "Can't write to audio output device.");
+
+		/* Cycle to the next buffer in the ring queue */
+		state->next_buffer = (state->next_buffer + 1) % NUM_BUFFERS;
+	}
+	/* I'd like to propagate error codes or something... but there are no catchable surprises left.
+	   Anyhow: Here is the recursion that makes ravenexp happy;-) */
+	if(rest_len && write_win32(ao, buf + bufill, rest_len) < 0) /* Write the rest. */
+	return -1;
+	else    
+	return len;
+}
+
+static void flush_win32(struct audio_output_struct *ao)
+{
+	int i, z;
+	struct queue_state* state;
+
+	if(!ao || !ao->userptr) return;
+	state = (struct queue_state*)ao->userptr;
+
+	/* FIXME: The very last output buffer is not played. This could be a problem on the feeding side. */
+	i = 0;
+	z = state->next_buffer - 1;
+	for(i = 0; i < NUM_BUFFERS; i++)
+	{
+		if(!state->buffer_headers[i].dwFlags & WHDR_DONE)
+			WaitForSingleObject(state->play_done_event, INFINITE);
+
+		waveOutUnprepareHeader(state->waveout, &state->buffer_headers[i], sizeof(WAVEHDR));
+		state->buffer_headers[i].dwFlags = 0;
+		state->buffer_headers[i].dwBufferLength = 0;
+		z = (z + 1) % NUM_BUFFERS;
+	}
+}
+
+static int close_win32(struct audio_output_struct *ao)
+{
+	int i;
+	struct queue_state* state;
+
+	if(!ao || !ao->userptr) return -1;
+	state = (struct queue_state*)ao->userptr;
+
+	flush_win32(ao);
+	waveOutClose(state->waveout);
+	CloseHandle(state->play_done_event);
+
+	for(i = 0; i < NUM_BUFFERS; i++) free(state->buffer_headers[i].lpData);
+
+	free(ao->userptr);
+	ao->userptr = 0;
+	return 0;
+}
+
+static int init_win32(audio_output_t* ao)
+{
+	if(!ao) return -1;
+
+	/* Set callbacks */
+	ao->open = open_win32;
+	ao->flush = flush_win32;
+	ao->write = write_win32;
+	ao->get_formats = get_formats_win32;
+	ao->close = close_win32;
+
+	/* Success */
+	return 0;
+}
+
+/* 
+	Module information data structure
+*/
+mpg123_module_t mpg123_output_module_info = {
+	/* api_version */	MPG123_MODULE_API_VERSION,
+	/* name */			"win32",						
+	/* description */	"Audio output for Windows (winmm).",
+	/* revision */		"$Rev:$",						
+	/* handle */		NULL,
+	
+	/* init_output */	init_win32,						
+};