X-Git-Url: http://git.tuebingen.mpg.de/?p=paraslash.git;a=blobdiff_plain;f=osx_write.c;h=429c713945dc799011efeaeb68a9670408067430;hp=bc11e61aea24a22596c88a3e4e14f5d7b9ad746c;hb=3150a0caa27a34d44556fb77f4a5aebc3d978580;hpb=11e68b8de3eb8bf8b657333d5b8359260559e93b

diff --git a/osx_write.c b/osx_write.c
index bc11e61a..429c7139 100644
--- a/osx_write.c
+++ b/osx_write.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2006-2009 Andre Noll <maan@systemlinux.org>
+ * Copyright (C) 2006-2011 Andre Noll <maan@systemlinux.org>
  *
  * Licensed under the GPL v2. For licencing details see COPYING.
  */
@@ -13,8 +13,7 @@
 
 #include <regex.h>
 #include <sys/types.h>
-#include <dirent.h>
-#include <CoreAudio/CoreAudio.h>
+#include <stdbool.h>
 
 #include "para.h"
 #include "fd.h"
@@ -22,161 +21,123 @@
 #include "list.h"
 #include "sched.h"
 #include "ggo.h"
+#include "buffer_tree.h"
 #include "write.h"
+#include "write_common.h"
 #include "osx_write.cmdline.h"
+#include "ipc.h"
 #include "error.h"
 
-
-#include <CoreAudio/CoreAudio.h>
+#include <CoreServices/CoreServices.h>
 #include <AudioUnit/AudioUnit.h>
-#include <AudioToolbox/DefaultAudioOutput.h>
-
-/** describes one input buffer for the osx writer */
-struct osx_buffer {
-	/** pointer to the beginning of the buffer */
-	float *buffer;
-	/** the size of this buffer */
-	long size;
-	/** current position in the buffer */
-	float *ptr;
-	/** number of floats not yet consuned */
-	long remaining;
-	/** pointer to the next audio buffer */
-	struct osx_buffer *next;
-};
+#include <AudioToolbox/AudioToolbox.h>
 
-/** data specific to the osx writer */
+/** Data specific to the osx writer. */
 struct private_osx_write_data {
-	/** the main control structure for audio data manipulation */
+	/** The main CoreAudio handle. */
 	AudioUnit audio_unit;
-	/** non-zero if playback has started */
-	char play;
-	/** callback reads audio data from this buffer */
-	struct osx_buffer *from;
-	/** the post_select writes audio data here */
-	struct osx_buffer *to;
-	/** sample rate of the current audio stream */
-	unsigned samplerate;
-	/** number of channels of the current audio stream */
+	/** True if we wrote some audio data. */
+	bool playing;
+	/** Sample rate of the current audio stream. */
+	unsigned sample_rate;
+	/** Sample format of the current audio stream */
+	unsigned sample_format;
+	/** Number of channels of the current audio stream. */
 	unsigned channels;
+	/** Serializes access to buffer tree nodes. */
+	int mutex;
+	/** The btr node of the callback. */
+	struct btr_node *callback_btrn;
 };
 
-static void destroy_buffers(struct private_osx_write_data *powd)
-{
-	struct osx_buffer *ptr;
-	struct osx_buffer *ptr2;
-	ptr = powd->to->next;
-	powd->to->next = NULL;
-	while (ptr) {
-		ptr2 = ptr->next;
-		free(ptr->buffer);
-		free(ptr);
-		ptr = ptr2;
-	}
-}
-
-static void init_buffers(struct writer_node *wn)
+/* This function writes the address and the number of bytes to one end of the socket.
+ * The post_select() function then fills the buffer and notifies the callback also
+ * through the socket.
+ */
+static OSStatus osx_callback(void *cb_arg, __a_unused AudioUnitRenderActionFlags *af,
+		__a_unused const AudioTimeStamp *ts, __a_unused  UInt32 bus_number,
+		__a_unused UInt32 num_frames, AudioBufferList *abl)
 {
-	struct private_osx_write_data *powd = wn->private_data;
-	struct osx_write_args_info *conf = wn->conf;
-	struct osx_buffer **ptrptr;
 	int i;
+	struct writer_node *wn = cb_arg;
+	struct private_osx_write_data *powd = wn->private_data;
+	size_t samples_have, samples_want = 0;
 
-	ptrptr = &powd->to;
-	for (i = 0; i < conf->numbuffers_arg; i++) {
-		*ptrptr = para_malloc(sizeof(struct osx_buffer));
-		(*ptrptr)->size = 0;
-		(*ptrptr)->remaining = 0;
-		(*ptrptr)->buffer = NULL;
-		ptrptr = &(*ptrptr)->next;
-	}
-	*ptrptr = powd->from = powd->to;
-}
-
-static void fill_buffer(struct osx_buffer *b, short *source, long size)
-{
-	float *dest;
-
-	if (b->remaining) /* Non empty buffer, must still be playing */
-		return;
-	if (b->size != size) {
-		b->buffer = para_realloc(b->buffer, size * sizeof(float));
-		b->size = size;
+	mutex_lock(powd->mutex);
+	/*
+	 * We fill with zeros if no data was yet written and we do not have
+	 * enough to fill all buffers.
+	 */
+	if (!powd->playing) {
+		size_t want = 0, have =
+			btr_get_input_queue_size(powd->callback_btrn);
+		for (i = 0; i < abl->mNumberBuffers; i++)
+			want += abl->mBuffers[i].mDataByteSize;
+		if (have < want) {
+			PARA_DEBUG_LOG("deferring playback (have = %zu < %zu = want)\n",
+				have, want);
+			for (i = 0; i < abl->mNumberBuffers; i++)
+				memset(abl->mBuffers[i].mData, 0,
+					abl->mBuffers[i].mDataByteSize);
+			goto out;
+		}
+		powd->playing = true;
 	}
-	dest = b->buffer;
-	while (size--)
-		*dest++ = (*source++) / 32768.0;
-	b->ptr = b->buffer;
-	b->remaining = b->size;
-}
-
-static OSStatus osx_callback(void * inClientData,
-	__a_unused AudioUnitRenderActionFlags *inActionFlags,
-	__a_unused const AudioTimeStamp *inTimeStamp,
-	__a_unused  UInt32 inBusNumber,
-	__a_unused UInt32 inNumFrames,
-	AudioBufferList *outOutputData)
-{
-	long m, n;
-	float *dest;
-	int i;
-	struct private_osx_write_data *powd = inClientData;
 
-//	PARA_INFO_LOG("%p\n", powd);
-	for (i = 0; i < outOutputData->mNumberBuffers; ++i) {
+	for (i = 0; i < abl->mNumberBuffers; i++) {
 		/* what we have to fill */
-		m = outOutputData->mBuffers[i].mDataByteSize / sizeof(float);
-		dest = outOutputData->mBuffers[i].mData;
-		while (m > 0) {
-			if ((n = powd->from->remaining) <= 0) {
-				PARA_INFO_LOG("buffer underrun\n");
-				return 0;
-			}
-//			PARA_INFO_LOG("buf %p: n = %ld, m= %ld\n", powd->from->buffer, n, m);
-			/*
-			 * we dump what we can. In fact, just the necessary
-			 * should be sufficient
-			 */
-			if (n > m)
-				n = m;
-			memcpy(dest, powd->from->ptr, n * sizeof(float));
-			dest += n;
-			/* remember all done work */
-			m -= n;
-			powd->from->ptr += n;
-			if ((powd->from->remaining -= n) <= 0)
-				powd->from = powd->from->next;
+		void *dest = abl->mBuffers[i].mData;
+		size_t sz = abl->mBuffers[i].mDataByteSize, samples, bytes;
+
+		samples_want = sz / wn->min_iqs;
+		while (samples_want > 0) {
+			char *buf;
+			btr_merge(powd->callback_btrn, wn->min_iqs);
+			samples_have = btr_next_buffer(powd->callback_btrn, &buf) / wn->min_iqs;
+			//PARA_INFO_LOG("i: %d want %zu samples to addr %p, have: %zu\n", i, samples_want,
+			//	dest, samples_have);
+			samples = PARA_MIN(samples_have, samples_want);
+			if (samples == 0)
+				break;
+			bytes = samples * wn->min_iqs;
+			memcpy(dest, buf, bytes);
+			btr_consume(powd->callback_btrn, bytes);
+			samples_want -= samples;
+			dest += bytes;
 		}
+		if (samples_want == 0)
+			continue;
+		if (btr_node_status(wn->btrn, wn->min_iqs, BTR_NT_LEAF) >= 0)
+			PARA_INFO_LOG("zero-padding (%zu samples)\n",
+				samples_want);
+		memset(dest, 0, samples_want * wn->min_iqs);
+		break;
 	}
-	return 0;
+out:
+	mutex_unlock(powd->mutex);
+	return noErr;
 }
 
-#ifdef WORDS_BIGENDIAN /* ppc */
-#define ENDIAN_FLAGS kLinearPCMFormatFlagIsBigEndian
-#else
-#define ENDIAN_FLAGS 0
-#endif
-
-static int osx_write_open(struct writer_node *wn)
+static int core_audio_init(struct writer_node *wn)
 {
-	struct private_osx_write_data *powd = para_calloc(
-		sizeof(struct private_osx_write_data));
-	ComponentDescription desc;
+	struct private_osx_write_data *powd = para_calloc(sizeof(*powd));
 	Component comp;
-	AURenderCallbackStruct inputCallback = {osx_callback, powd};
-	AudioStreamBasicDescription format;
 	int ret;
-	struct writer_node_group *wng = wn->wng;
-	struct osx_write_args_info *conf = wn->conf;
+	int32_t val;
+	AURenderCallbackStruct input_callback;
+	ComponentDescription desc = {
+		.componentType = kAudioUnitType_Output,
+		.componentSubType = kAudioUnitSubType_DefaultOutput,
+		.componentManufacturer = kAudioUnitManufacturer_Apple,
+	};
+	AudioStreamBasicDescription format = {
+		.mFormatID = kAudioFormatLinearPCM,
+		.mFramesPerPacket = 1,
+	};
+	struct btr_node *btrn = wn->btrn;
+	struct btr_node_description bnd;
 
-	wn->private_data = powd;
-	/* where did that default audio output go? */
-	desc.componentType = kAudioUnitType_Output;
-	desc.componentSubType = kAudioUnitSubType_DefaultOutput;
-	/* NOTE: and if default output isn't Apple? */
-	desc.componentManufacturer = kAudioUnitManufacturer_Apple;
-	desc.componentFlags = 0;
-	desc.componentFlagsMask = 0;
+	PARA_INFO_LOG("wn: %p\n", wn);
 	ret = -E_DEFAULT_COMP;
 	comp = FindNextComponent(NULL, &desc);
 	if (!comp)
@@ -187,149 +148,196 @@ static int osx_write_open(struct writer_node *wn)
 	ret = -E_UNIT_INIT;
 	if (AudioUnitInitialize(powd->audio_unit))
 		goto e1;
-	powd->play = 0;
-	/* Hmmm, let's choose PCM format */
-	/* We tell the Output Unit what format we're going to supply data to it.
-	 * This is necessary if you're providing data through an input callback
-	 * AND you want the DefaultOutputUnit to do any format conversions
-	 * necessary from your format to the device's format.
+	get_btr_sample_rate(btrn, &val);
+	powd->sample_rate = val;
+	get_btr_channels(btrn, &val);
+	powd->channels = val;
+	get_btr_sample_format(btrn, &val);
+	powd->sample_format = val;
+	/*
+	 * Choose PCM format. We tell the Output Unit what format we're going
+	 * to supply data to it. This is necessary if you're providing data
+	 * through an input callback AND you want the DefaultOutputUnit to do
+	 * any format conversions necessary from your format to the device's
+	 * format.
 	 */
-	if (!conf->samplerate_given && wng->samplerate)
-		powd->samplerate = *wng->samplerate;
-	else
-		powd->samplerate = conf->samplerate_arg;
-	format.mSampleRate = powd->samplerate;
-	/* The specific encoding type of audio stream*/
-	format.mFormatID = kAudioFormatLinearPCM;
-	/* flags specific to each format */
-	format.mFormatFlags = kLinearPCMFormatFlagIsFloat
-		| kLinearPCMFormatFlagIsPacked
-		| ENDIAN_FLAGS;
-	if (!conf->channels_given && wng->channels)
-		powd->channels = *wng->channels;
-	else
-		powd->channels = conf->channels_arg;
+
+	format.mSampleRate = powd->sample_rate;
 	format.mChannelsPerFrame = powd->channels;
-	format.mFramesPerPacket = 1;
-	format.mBytesPerPacket = format.mChannelsPerFrame * sizeof(float);
-	format.mBytesPerFrame = format.mFramesPerPacket * format.mBytesPerPacket;
-	/* one of the most constant constants of the whole computer history */
-	format.mBitsPerChannel = sizeof(float) * 8;
+
+	switch (powd->sample_format) {
+	case SF_S8:
+	case SF_U8:
+		wn->min_iqs = powd->channels;
+		format.mBitsPerChannel = 8;
+		format.mBytesPerPacket = powd->channels;
+		format.mFormatFlags |= kLinearPCMFormatFlagIsPacked;
+		break;
+	default:
+		wn->min_iqs = powd->channels * 2;
+		format.mBytesPerPacket = powd->channels * 2;
+		format.mBitsPerChannel = 16;
+		format.mFormatFlags |= kLinearPCMFormatFlagIsSignedInteger;
+	}
+	format.mBytesPerFrame = format.mBytesPerPacket;
+
+	if (powd->sample_format == SF_S16_BE || powd->sample_format == SF_U16_BE)
+		format.mFormatFlags |= kLinearPCMFormatFlagIsBigEndian;
+
+	input_callback = (AURenderCallbackStruct){osx_callback, wn};
 	ret = -E_STREAM_FORMAT;
 	if (AudioUnitSetProperty(powd->audio_unit, kAudioUnitProperty_StreamFormat,
-			kAudioUnitScope_Input, 0, &format,
-			sizeof(AudioStreamBasicDescription)))
+			kAudioUnitScope_Input, 0, &format, sizeof(format)))
 		goto e2;
-	init_buffers(wn);
 	ret = -E_ADD_CALLBACK;
 	if (AudioUnitSetProperty(powd->audio_unit, kAudioUnitProperty_SetRenderCallback,
-			kAudioUnitScope_Input, 0, &inputCallback,
-			sizeof(inputCallback)) < 0)
-		goto e3;
+			kAudioUnitScope_Input, 0, &input_callback,
+			sizeof(input_callback)) < 0)
+		goto e2;
+
+	ret = mutex_new();
+	if (ret < 0)
+		goto e2;
+	powd->mutex = ret;
+	/* set up callback btr node */
+	bnd.name = "cb_node";
+	bnd.parent = btrn;
+	bnd.child = NULL;
+	bnd.handler = NULL;
+	bnd.context = powd;
+	powd->callback_btrn = btr_new_node(&bnd);
+	wn->private_data = powd;
 	return 1;
-e3:
-	destroy_buffers(powd);
 e2:
 	AudioUnitUninitialize(powd->audio_unit);
 e1:
 	CloseComponent(powd->audio_unit);
 e0:
+	free(powd);
+	wn->private_data = NULL;
 	return ret;
 }
 
-__malloc static void *osx_write_parse_config(const char *options)
+__malloc static void *osx_write_parse_config_or_die(const char *options)
 {
-	struct osx_write_args_info *conf
-		= para_calloc(sizeof(struct osx_write_args_info));
-	PARA_INFO_LOG("options: %s\n", options);
-	int ret = osx_cmdline_parser_string(options, conf, "osx_write");
-	if (ret)
-		goto err_out;
+	struct osx_write_args_info *conf = para_calloc(sizeof(*conf));
+
+	/* exits on errors */
+	osx_cmdline_parser_string(options, conf, "osx_write");
 	return conf;
-err_out:
-	free(conf);
-	return NULL;
+}
 
+static void osx_free_config(void *conf)
+{
+	osx_cmdline_parser_free(conf);
 }
 
 static void osx_write_close(struct writer_node *wn)
 {
 	struct private_osx_write_data *powd = wn->private_data;
 
+	if (!powd)
+		return;
 	PARA_INFO_LOG("closing writer node %p\n", wn);
-	AudioOutputUnitStop(powd->audio_unit);
-	AudioUnitUninitialize(powd->audio_unit);
-	CloseComponent(powd->audio_unit);
-	destroy_buffers(powd);
+	mutex_destroy(powd->mutex);
 	free(powd);
+	wn->private_data = NULL;
 }
 
-static int need_new_buffer(struct writer_node *wn)
+/* must be called with the mutex held */
+static inline bool need_drain_delay(struct private_osx_write_data *powd)
 {
-	struct writer_node_group *wng = wn->wng;
-	struct private_osx_write_data *powd = wn->private_data;
-
-	if (*wng->loaded < sizeof(short))
-		return 0;
-	if (powd->to->remaining) /* Non empty buffer, must still be playing */
-		return 0;
-	return 1;
+	if (!powd->playing)
+		return false;
+	return btr_get_input_queue_size(powd->callback_btrn) != 0;
 }
 
-static int osx_write_post_select(__a_unused struct sched *s,
-		struct writer_node *wn)
+static void osx_write_pre_select(struct sched *s, struct task *t)
 {
+	struct writer_node *wn = container_of(t, struct writer_node, task);
 	struct private_osx_write_data *powd = wn->private_data;
-	struct writer_node_group *wng = wn->wng;
-	short *data = (short*)*wng->bufp;
-
-	if (!need_new_buffer(wn))
-		return 1;
-	fill_buffer(powd->to, data, *wng->loaded / sizeof(short));
-	powd->to = powd->to->next;
-	wn->written = *wng->loaded;
-	if (!powd->play) {
-		if (AudioOutputUnitStart(powd->audio_unit))
-			return -E_UNIT_START;
-		powd->play = 1;
+	int ret;
+	bool drain_delay_nec = false;
+
+	if (!powd) {
+		ret = btr_node_status(wn->btrn, wn->min_iqs, BTR_NT_LEAF);
+		if (ret != 0)
+			sched_min_delay(s);
+		return;
 	}
-	return 1;
+
+	mutex_lock(powd->mutex);
+	ret = btr_node_status(wn->btrn, wn->min_iqs, BTR_NT_LEAF);
+	if (ret < 0)
+		drain_delay_nec = need_drain_delay(powd);
+	mutex_unlock(powd->mutex);
+
+	if (drain_delay_nec)
+		return sched_request_timeout_ms(50, s);
+	if (ret != 0)
+		return sched_min_delay(s);
+	sched_request_timeout_ms(50, s);
 }
 
-static int osx_write_pre_select(struct sched *s, __a_unused struct writer_node *wn)
+static void osx_write_post_select(__a_unused struct sched *s, struct task *t)
 {
+	struct writer_node *wn = container_of(t, struct writer_node, task);
 	struct private_osx_write_data *powd = wn->private_data;
-	struct writer_node_group *wng = wn->wng;
-	size_t numbytes = powd->to->remaining * sizeof(short);
-	struct timeval tmp = {.tv_sec = 1, .tv_usec = 0}, delay = tmp;
-	unsigned long divisor;
-
-	if (!numbytes && *wng->loaded >= sizeof(short))
-		goto min_delay; /* there's a buffer to fill */
-	if (!numbytes)
-		return 1;
-	divisor = powd->samplerate * powd->channels * 2 / numbytes;
-	if (divisor)
-		tv_divide(divisor, &tmp, &delay);
-	if (tv_diff(&s->timeout, &delay, NULL) > 0)
-		s->timeout = delay;
-//	PARA_DEBUG_LOG("delay: %lu:%lu\n", (long unsigned) s->timeout.tv_sec,
-//		(long unsigned) s->timeout.tv_usec);
-	return 1;
-min_delay:
-	PARA_DEBUG_LOG("%s\n", "minimal delay");
-	s->timeout.tv_sec = 0;
-	s->timeout.tv_usec = 1;
-	return 1;
+	struct btr_node *btrn = wn->btrn;
+	int ret;
+
+	if (!powd) {
+		ret = btr_node_status(btrn, wn->min_iqs, BTR_NT_LEAF);
+		if (ret == 0)
+			return;
+		if (ret < 0)
+			goto remove_btrn;
+		ret = core_audio_init(wn);
+		if (ret < 0)
+			goto remove_btrn;
+		powd = wn->private_data;
+		AudioOutputUnitStart(powd->audio_unit);
+	}
+	mutex_lock(powd->mutex);
+	btr_pushdown(btrn);
+	ret = btr_node_status(btrn, wn->min_iqs, BTR_NT_LEAF);
+	if (ret < 0 && need_drain_delay(powd))
+		ret = 0;
+	mutex_unlock(powd->mutex);
+
+	if (ret >= 0)
+		goto out;
+	AudioOutputUnitStop(powd->audio_unit);
+	AudioUnitUninitialize(powd->audio_unit);
+	CloseComponent(powd->audio_unit);
+	btr_remove_node(powd->callback_btrn);
+	btr_free_node(powd->callback_btrn);
+remove_btrn:
+	btr_remove_node(btrn);
+	PARA_NOTICE_LOG("%s\n", para_strerror(-ret));
+out:
+	t->error = ret;
 }
 
-/** the init function of the osx writer */
+/**
+ * The init function of the osx writer.
+ *
+ * \param w Filled in by the function.
+ */
 void osx_write_init(struct writer *w)
 {
-	w->open = osx_write_open;
+	struct osx_write_args_info dummy;
+
+	osx_cmdline_parser_init(&dummy);
 	w->close = osx_write_close;
 	w->pre_select = osx_write_pre_select;
 	w->post_select = osx_write_post_select;
-	w->parse_config = osx_write_parse_config;
+	w->parse_config_or_die = osx_write_parse_config_or_die;
+	w->free_config = osx_free_config;
 	w->shutdown = NULL; /* nothing to do */
+	w->help = (struct ggo_help) {
+		.short_help = osx_write_args_info_help,
+		.detailed_help = osx_write_args_info_detailed_help
+	};
+	osx_cmdline_parser_free(&dummy);
 }