X-Git-Url: http://git.tuebingen.mpg.de/?p=paraslash.git;a=blobdiff_plain;f=osx_write.c;h=429c713945dc799011efeaeb68a9670408067430;hp=65a5adc79db3164ded3ef5a79070eb0ee71a43b4;hb=3150a0caa27a34d44556fb77f4a5aebc3d978580;hpb=009e80ae25df7a247a263b5b8e2259c9bdfe20ce diff --git a/osx_write.c b/osx_write.c index 65a5adc7..429c7139 100644 --- a/osx_write.c +++ b/osx_write.c @@ -1,5 +1,5 @@ /* - * Copyright (C) 2006-2010 Andre Noll + * Copyright (C) 2006-2011 Andre Noll * * Licensed under the GPL v2. For licencing details see COPYING. */ @@ -13,7 +13,6 @@ #include #include -#include #include #include "para.h" @@ -26,162 +25,119 @@ #include "write.h" #include "write_common.h" #include "osx_write.cmdline.h" +#include "ipc.h" #include "error.h" #include #include #include -/** 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; -}; - -/** 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 */ + /** True if we wrote some audio data. */ + bool playing; + /** Sample rate of the current audio stream. */ unsigned sample_rate; - /** number of channels of the current audio stream */ + /** 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; - - assert(b->remaining == 0 || size > 0); - 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) { - n = powd->from->remaining; - if (n <= 0) { - n = powd->from->next->remaining; - if (n <= 0) { - PARA_INFO_LOG("buffer underrun\n"); - return 0; - } - powd->from = powd->from->next; - } -// 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 btr_node *btrn = wn->btrn; 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) @@ -192,11 +148,12 @@ static int osx_write_open(struct writer_node *wn) ret = -E_UNIT_INIT; if (AudioUnitInitialize(powd->audio_unit)) goto e1; - powd->play = 0; 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 @@ -204,55 +161,70 @@ static int osx_write_open(struct writer_node *wn) * any format conversions necessary from your format to the device's * format. */ + format.mSampleRate = powd->sample_rate; - /* The specific encoding type of audio stream */ - format.mFormatID = kAudioFormatLinearPCM; - /* flags specific to each format */ - format.mFormatFlags = kLinearPCMFormatFlagIsFloat - | kLinearPCMFormatFlagIsPacked - | ENDIAN_FLAGS; 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; - wn->min_iqs = powd->channels * 2; + 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; - return conf; -err_out: - free(conf); - return NULL; + struct osx_write_args_info *conf = para_calloc(sizeof(*conf)); + /* exits on errors */ + osx_cmdline_parser_string(options, conf, "osx_write"); + return conf; } static void osx_free_config(void *conf) @@ -264,75 +236,103 @@ 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 void osx_write_post_select(__a_unused struct sched *s, struct task *t) +/* must be called with the mutex held */ +static inline bool need_drain_delay(struct private_osx_write_data *powd) +{ + if (!powd->playing) + return false; + return btr_get_input_queue_size(powd->callback_btrn) != 0; +} + +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 btr_node *btrn = wn->btrn; - char *data; - size_t bytes; - int ret = 0; + int ret; + bool drain_delay_nec = false; - while (powd->to->remaining <= 0) { + if (!powd) { ret = btr_node_status(wn->btrn, wn->min_iqs, BTR_NT_LEAF); - if (ret <= 0) - break; - btr_merge(btrn, 8192); - bytes = btr_next_buffer(btrn, &data); - //PARA_CRIT_LOG("have: %zu\n", bytes); - fill_buffer(powd->to, (short *)data, bytes / sizeof(short)); - btr_consume(btrn, bytes); - if (!powd->play) { - ret = -E_UNIT_START; - if (AudioOutputUnitStart(powd->audio_unit)) - break; - powd->play = 1; - } - powd->to = powd->to->next; + if (ret != 0) + sched_min_delay(s); + return; } + + mutex_lock(powd->mutex); + ret = btr_node_status(wn->btrn, wn->min_iqs, BTR_NT_LEAF); if (ret < 0) - btr_remove_node(btrn); - t->error = ret; + 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 void osx_write_pre_select(struct sched *s, struct task *t) +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 timeval tmp = {.tv_sec = 1, .tv_usec = 0}, delay = tmp; - unsigned long divisor; - size_t numbytes = powd->to->remaining * sizeof(short); - int ret = btr_node_status(wn->btrn, wn->min_iqs, BTR_NT_LEAF); + struct btr_node *btrn = wn->btrn; + int ret; - if (ret < 0) - sched_min_delay(s); - if (ret <= 0 || numbytes < wn->min_iqs) - return; - divisor = powd->sample_rate * wn->min_iqs / numbytes; - if (divisor) - tv_divide(divisor, &tmp, &delay); - sched_request_timeout(&delay, s); + 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) { struct osx_write_args_info dummy; osx_cmdline_parser_init(&dummy); - w->open = osx_write_open; 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) {