seal 0.1.0

data/mpg123/src/audio.h

@@ -0,0 +1,106 @@
+/*
+	audio: audio output interface
+
+	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
+*/
+
+/* 
+ * Audio 'LIB' defines
+ */
+
+
+#ifndef _MPG123_AUDIO_H_
+#define _MPG123_AUDIO_H_
+
+#include "compat.h"
+#include "mpg123.h"
+#include "module.h"
+
+#define AUDIO_OUT_HEADPHONES       0x01
+#define AUDIO_OUT_INTERNAL_SPEAKER 0x02
+#define AUDIO_OUT_LINE_OUT         0x04
+
+enum {
+	DECODE_TEST,
+	DECODE_AUDIO,
+	DECODE_FILE,
+	DECODE_BUFFER,
+	DECODE_WAV,
+	DECODE_AU,
+	DECODE_CDR,
+	DECODE_AUDIOFILE
+};
+
+/* 3% rate tolerance */
+#define AUDIO_RATE_TOLERANCE	  3
+
+typedef struct audio_output_struct
+{
+	int fn;			/* filenumber */
+	void *userptr;	/* driver specific pointer */
+	
+	/* Callbacks */
+	int (*open)(struct audio_output_struct *);
+	int (*get_formats)(struct audio_output_struct *);
+	int (*write)(struct audio_output_struct *, unsigned char *,int);
+	void (*flush)(struct audio_output_struct *);
+	int (*close)(struct audio_output_struct *);
+	int (*deinit)(struct audio_output_struct *);
+	
+	/* the module this belongs to */
+	mpg123_module_t *module;
+	
+	char *device;	/* device name */
+	int   flags;	/* some bits; namely headphone/speaker/line */
+	long rate;		/* sample rate */
+	long gain;		/* output gain */
+	int channels;	/* number of channels */
+	int format;		/* format flags */
+	int is_open;	/* something opened? */
+#define MPG123_OUT_QUIET 1
+	int auxflags; /* For now just one: quiet mode (for probing). */
+} audio_output_t;
+
+/* Lazy. */
+#define AOQUIET (ao->auxflags & MPG123_OUT_QUIET)
+
+struct audio_format_name {
+	int  val;
+	char *name;
+	char *sname;
+};
+
+#define pitch_rate(rate)	(param.pitch == 0 ? (rate) : (long) ((param.pitch+1.0)*(rate)))
+
+/* ------ Declarations from "audio.c" ------ */
+
+audio_output_t* open_output_module( const char* name );
+void close_output_module( audio_output_t* ao );
+audio_output_t* alloc_audio_output();
+void audio_capabilities(audio_output_t *ao, mpg123_handle *mh);
+int audio_fit_capabilities(audio_output_t *ao,int c,int r);
+const char* audio_encoding_name(const int encoding, const int longer);
+void print_capabilities(audio_output_t *ao, mpg123_handle *mh);
+
+int init_output(audio_output_t **ao);
+void exit_output(audio_output_t *ao, int rude);
+int flush_output(audio_output_t *ao, unsigned char *bytes, size_t count);
+int open_output(audio_output_t *ao);
+void close_output(audio_output_t *ao );
+int reset_output(audio_output_t *ao);
+void output_pause(audio_output_t *ao);  /* Prepare output for inactivity. */
+void output_unpause(audio_output_t *ao); /* Reactivate output (buffer process). */
+
+void audio_enclist(char** list); /* Make a string of encoding names. */
+
+/*
+	Twiddle audio output rate to yield speedup/down (pitch) effect.
+	The actually achieved pitch value is stored in param.pitch.
+	Returns 1 if pitch setting succeeded, 0 otherwise.
+*/
+int set_pitch(mpg123_handle *fr, audio_output_t *ao, double new_pitch);
+
+#endif
+

data/mpg123/src/buffer.c

@@ -0,0 +1,312 @@
+/*
+	buffer.c: output buffer
+
+	copyright 1997-2009 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 Oliver Fromme
+
+	I (ThOr) am reviewing this file at about the same daytime as Oliver's timestamp here:
+	Mon Apr 14 03:53:18 MET DST 1997
+	- dammed night coders;-)
+*/
+
+#include "mpg123app.h"
+
+#ifndef NOXFERMEM
+
+#include "common.h"
+#include <errno.h>
+#include "debug.h"
+
+int outburst = 32768;
+
+static int intflag = FALSE;
+static int usr1flag = FALSE;
+
+static void catch_interrupt (void)
+{
+	intflag = TRUE;
+}
+
+static void catch_usr1 (void)
+{
+	usr1flag = TRUE;
+}
+
+/* Interfaces to writer process */
+
+extern void buffer_sig(int signal, int block);
+
+void real_buffer_ignore_lowmem(void)
+{
+	if (!buffermem)
+		return;
+	if(buffermem->wakeme[XF_READER])
+		xfermem_putcmd(buffermem->fd[XF_WRITER], XF_CMD_WAKEUP);
+}
+
+void real_buffer_end(int rude)
+{
+	if (!buffermem)
+		return;
+	xfermem_putcmd(buffermem->fd[XF_WRITER], rude ? XF_CMD_ABORT : XF_CMD_TERMINATE);
+}
+
+void real_buffer_resync(void)
+{
+	if(buffermem->justwait)
+	{
+		buffermem->wakeme[XF_WRITER] = TRUE;
+		xfermem_putcmd(buffermem->fd[XF_WRITER], XF_CMD_RESYNC);
+		xfermem_getcmd(buffermem->fd[XF_WRITER], TRUE);
+	}
+	else buffer_sig(SIGINT, TRUE);
+}
+
+void real_plain_buffer_resync(void)
+{
+	buffer_sig(SIGINT, FALSE);
+}
+
+void real_buffer_reset(void)
+{
+	buffer_sig(SIGUSR1, TRUE);
+}
+
+void real_buffer_start(void)
+{
+	if(buffermem->justwait)
+	{
+		debug("ending buffer's waiting");
+		buffermem->justwait = FALSE;
+		xfermem_putcmd(buffermem->fd[XF_WRITER], XF_CMD_WAKEUP);
+	}
+}
+
+void real_buffer_stop()
+{
+	buffermem->justwait = TRUE;
+	buffer_sig(SIGINT, TRUE);
+}
+
+extern int buffer_pid;
+
+void buffer_sig(int signal, int block)
+{
+	if (!buffermem) return;
+
+	if (!block)
+	{ /* Just signal, do not wait for anything. */
+		kill(buffer_pid, signal);
+		return;
+	}
+
+	/* kill() and the waiting needs to be taken care of properly for parallel execution.
+	  Nobody reported issues so far, but I want to be sure. */
+	if(xfermem_sigblock(XF_WRITER, buffermem, buffer_pid, signal) != XF_CMD_WAKEUP) 
+		perror("Could not resync/reset buffers");
+	return;
+}
+
+void buffer_loop(audio_output_t *ao, sigset_t *oldsigset)
+{
+	int bytes, outbytes;
+	int my_fd = buffermem->fd[XF_READER];
+	txfermem *xf = buffermem;
+	int done = FALSE;
+	int preload;
+
+	catchsignal (SIGINT, catch_interrupt);
+	catchsignal (SIGUSR1, catch_usr1);
+	sigprocmask (SIG_SETMASK, oldsigset, NULL);
+
+	xfermem_putcmd(my_fd, XF_CMD_WAKEUP);
+
+	debug("audio output: waiting for cap requests");
+	/* wait for audio setup queries */
+	while(1)
+	{
+		int cmd;
+		cmd = xfermem_block(XF_READER, xf);
+		if(cmd == XF_CMD_AUDIOCAP)
+		{
+			ao->rate     = xf->rate;
+			ao->channels = xf->channels;
+			ao->format   = ao->get_formats(ao);
+			debug3("formats for %liHz/%ich: 0x%x", ao->rate, ao->channels, ao->format);
+			xf->format = ao->format;
+			xfermem_putcmd(my_fd, XF_CMD_AUDIOCAP);
+		}
+		else if(cmd == XF_CMD_WAKEUP)
+		{
+			debug("got wakeup... leaving config mode");
+			xfermem_putcmd(buffermem->fd[XF_READER], XF_CMD_WAKEUP);
+			break;
+		}
+		else
+		{
+			error1("unexpected command %i", cmd);
+			return;
+		}
+	}
+
+	/* Fill complete buffer on first run before starting to play.
+	 * Live mp3 streams constantly approach buffer underrun otherwise. [dk]
+	 */
+	preload = (int)(param.preload*xf->size);
+	if(preload > xf->size) preload = xf->size;
+	if(preload < 0) preload = 0;
+
+	for (;;) {
+		if (intflag) {
+			debug("handle intflag... flushing");
+			intflag = FALSE;
+			ao->flush(ao);
+			/* Either prepare for waiting or empty buffer now. */
+			if(!xf->justwait) xf->readindex = xf->freeindex;
+			else
+			{
+				int cmd;
+				debug("Prepare for waiting; draining command queue. (There's a lot of wakeup commands pending, usually.)");
+				do
+				{
+					cmd = xfermem_getcmd(my_fd, FALSE);
+					/* debug1("drain: %i",  cmd); */
+				} while(cmd > 0);
+			}
+			if(xf->wakeme[XF_WRITER]) xfermem_putcmd(my_fd, XF_CMD_WAKEUP);
+		}
+		if (usr1flag) {
+			debug("handling usr1flag");
+			usr1flag = FALSE;
+			/*   close and re-open in order to flush
+			 *   the device's internal buffer before
+			 *   changing the sample rate.   [OF]
+			 */
+			/* writer must block when sending SIGUSR1
+			 * or we will lose all data processed 
+			 * in the meantime! [dk]
+			 */
+			xf->readindex = xf->freeindex;
+			/* We've nailed down the new starting location -
+			 * writer is now safe to go on. [dk]
+			 */
+			if (xf->wakeme[XF_WRITER])
+				xfermem_putcmd(my_fd, XF_CMD_WAKEUP);
+			ao->rate = xf->rate; 
+			ao->channels = xf->channels; 
+			ao->format = xf->format;
+			if (reset_output(ao) < 0) {
+				error1("failed to reset audio: %s", strerror(errno));
+				exit(1);
+			}
+		}
+		if ( (bytes = xfermem_get_usedspace(xf)) < outburst ) {
+			/* if we got a buffer underrun we first
+			 * fill 1/8 of the buffer before continue/start
+			 * playing */
+			if (preload < xf->size>>3)
+				preload = xf->size>>3;
+			if(preload < outburst)
+				preload = outburst;
+		}
+		debug1("bytes: %i", bytes);
+		if(xf->justwait || bytes < preload) {
+			int cmd;
+			if (done && !bytes) { 
+				break;
+			}
+			
+			if(xf->justwait || !done) {
+
+				/* Don't spill into errno check below. */
+				errno = 0;
+				cmd = xfermem_block(XF_READER, xf);
+				debug1("got %i", cmd);
+				switch(cmd) {
+
+					/* More input pending. */
+					case XF_CMD_WAKEUP_INFO:
+						continue;
+					/* Yes, we know buffer is low but
+					 * know we don't care.
+					 */
+					case XF_CMD_WAKEUP:
+						break;	/* Proceed playing. */
+					case XF_CMD_ABORT: /* Immediate end, discard buffer contents. */
+						return; /* Cleanup happens outside of buffer_loop()*/
+					case XF_CMD_TERMINATE: /* Graceful end, playing stuff in buffer and then return. */
+						debug("going to terminate");
+						done = TRUE;
+						break;
+					case XF_CMD_RESYNC:
+						debug("ordered resync");
+						if (param.outmode == DECODE_AUDIO) ao->flush(ao);
+
+						xf->readindex = xf->freeindex;
+						if (xf->wakeme[XF_WRITER]) xfermem_putcmd(my_fd, XF_CMD_WAKEUP);
+						continue;
+						break;
+					case -1:
+						if(intflag || usr1flag) /* Got signal, handle it at top of loop... */
+						{
+							debug("buffer interrupted");
+							continue;
+						}
+						if(errno)
+							error1("Yuck! Error in buffer handling... or somewhere unexpected: %s", strerror(errno));
+						done = TRUE;
+						xf->readindex = xf->freeindex;
+						xfermem_putcmd(xf->fd[XF_READER], XF_CMD_TERMINATE);
+						break;
+					default:
+						fprintf(stderr, "\nEh!? Received unknown command 0x%x in buffer process.\n", cmd);
+				}
+			}
+		}
+		/* Hack! The writer issues XF_CMD_WAKEUP when first adjust 
+		 * audio settings. We do not want to lower the preload mark
+		 * just yet!
+		 */
+		if (xf->justwait || !bytes)
+			continue;
+		preload = outburst; /* set preload to lower mark */
+		if (bytes > xf->size - xf->readindex)
+			bytes = xf->size - xf->readindex;
+		if (bytes > outburst)
+			bytes = outburst;
+
+		debug("write");
+		outbytes = flush_output(ao, (unsigned char*) xf->data + xf->readindex, bytes);
+
+		if(outbytes < bytes)
+		{
+			if(outbytes < 0) outbytes = 0;
+			if(!intflag && !usr1flag) {
+				error1("Ouch ... error while writing audio data: %s", strerror(errno));
+				/*
+				 * done==TRUE tells writer process to stop
+				 * sending data. There might be some latency
+				 * involved when resetting readindex to 
+				 * freeindex so we might need more than one
+				 * cycle to terminate. (The number of cycles
+				 * should be finite unless I managed to mess
+				 * up something. ;-) [dk]
+				 */
+				done = TRUE;	
+				xf->readindex = xf->freeindex;
+				xfermem_putcmd(xf->fd[XF_READER], XF_CMD_TERMINATE);
+			}
+			else debug("buffer interrupted");
+		}
+		bytes = outbytes;
+
+		xf->readindex = (xf->readindex + bytes) % xf->size;
+		if (xf->wakeme[XF_WRITER])
+			xfermem_putcmd(my_fd, XF_CMD_WAKEUP);
+	}
+}
+
+#endif
+
+/* EOF */

data/mpg123/src/buffer.h

@@ -0,0 +1,45 @@
+/*
+	buffer.h: output buffer
+
+	copyright 1999-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 Daniel Kobras / Oliver Fromme
+*/
+
+/*
+ * Application specific interaction between main and buffer
+ * process. This is much less generic than the functions in
+ * xfermem so I chose to put it in buffer.[hc].
+ * 01/28/99 [dk]
+ */
+
+#ifndef _MPG123_BUFFER_H_
+#define _MPG123_BUFFER_H_
+
+#ifndef NOXFERMEM
+void real_buffer_ignore_lowmem(void);
+void real_buffer_end(int rude);
+void real_buffer_resync(void);
+void real_plain_buffer_resync(void);
+void real_buffer_reset(void);
+void real_buffer_start(void);
+void real_buffer_stop(void);
+/* Hm, that's funny preprocessor weirdness. */
+#define buffer_start()         (param.usebuffer ? real_buffer_start(),0         : 0)
+#define buffer_stop()          (param.usebuffer ? real_buffer_stop(),0          : 0)
+#define buffer_reset()         (param.usebuffer ? real_buffer_reset(),0         : 0)
+#define buffer_resync()        (param.usebuffer ? real_buffer_resync(),0        : 0)
+#define plain_buffer_resync()  (param.usebuffer ? real_plain_buffer_resync(),0  : 0)
+#define buffer_end(a)          (param.usebuffer ? real_buffer_end(a),0           : 0)
+#define buffer_ignore_lowmem() (param.usebuffer ? real_buffer_ignore_lowmem(),0 : 0)
+#else
+#define buffer_start()
+#define buffer_stop()
+#define buffer_reset()
+#define buffer_resync()
+#define plain_buffer_resync()
+#define buffer_end()
+#define buffer_ignore_lowmem()
+#endif
+
+#endif