From patchwork Sun Jun 7 22:27:41 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Thilo Borgmann X-Patchwork-Id: 20192 Return-Path: X-Original-To: patchwork@ffaux-bg.ffmpeg.org Delivered-To: patchwork@ffaux-bg.ffmpeg.org Received: from ffbox0-bg.mplayerhq.hu (ffbox0-bg.ffmpeg.org [79.124.17.100]) by ffaux.localdomain (Postfix) with ESMTP id 5A748449DC4 for ; Mon, 8 Jun 2020 01:27:48 +0300 (EEST) Received: from [127.0.1.1] (localhost [127.0.0.1]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTP id 43A5C68B119; Mon, 8 Jun 2020 01:27:48 +0300 (EEST) X-Original-To: ffmpeg-devel@ffmpeg.org Delivered-To: ffmpeg-devel@ffmpeg.org Received: from shout01.mail.de (shout01.mail.de [62.201.172.24]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTPS id 0C487687F22 for ; Mon, 8 Jun 2020 01:27:42 +0300 (EEST) Received: from postfix01.mail.de (postfix01.bt.mail.de [10.0.121.125]) by shout01.mail.de (Postfix) with ESMTP id ADCD7100355 for ; Mon, 8 Jun 2020 00:27:41 +0200 (CEST) Received: from smtp02.mail.de (smtp02.bt.mail.de [10.0.121.212]) by postfix01.mail.de (Postfix) with ESMTP id 953138010A for ; Mon, 8 Jun 2020 00:27:41 +0200 (CEST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=mail.de; s=mailde201610; t=1591568861; bh=FfAFRaUUxGiQdpqIg7sQtH5/iF3BeqFsN4UcOuXlKUM=; h=From:Subject:To:Date:From; b=geEkCsSgSX0cXouM2C8d8899aInhJQxMrWnKOLl1kLIk9SWuFuXmnliAQwW/8Bm+j rXiwgJnXoVLZaerSaLkXtOuGv3VfKMuO81TwuyHwFk20nigjRfz1bLXBHBWzlh2Xst i7MPL6/zUEE9skgQdcUcfJqqgUS1gZF6OYv5ssEw= Received: from [127.0.0.1] (localhost [127.0.0.1]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits)) (No client certificate requested) by smtp02.mail.de (Postfix) with ESMTPSA id 4F65DA024A for ; Mon, 8 Jun 2020 00:27:41 +0200 (CEST) From: Thilo Borgmann To: FFmpeg development discussions and patches Autocrypt: addr=thilo.borgmann@mail.de; prefer-encrypt=mutual; keydata= xsBNBF1NyqgBCAC/eJ7l/Ic+5bhj3N4eTyLRMCQVyxPF6sIDu0RqZCsLYx6GjH6BBrPcewbG wLfWNqWPWpcHLbOwDE2FWSBgDbc7Zwrmtkxt4+RNj2/JYRyCiV1uIRm1rlcf80pqDEYM+1O8 23b/JrONn7pQpX8alrYfhP3tLR2PKO/wHmG4AlSEG5T8angmGMvfKVSzxq7E07MIdUqiHHj/ t/F+6WFkpaec++CWcU+9s9IWRV+HskgihqZBqvzRYptvFi81con+VqpYjtpqoYAj4XwqM6j4 /8kTobgPo0n/QRCFcpZYRA7SCT4LbwOvy+qZ1e5372rzOcIF6PGdVzH4CCRT1Ypg1D6TABEB AAHNJ1RoaWxvIEJvcmdtYW5uIDx0aGlsby5ib3JnbWFubkBtYWlsLmRlPsLAqwQTAQoAPhYh BM4dt/RNIPw63Z/+WiV8W48dILkvBQJdTcqoAhsDBQkDwmcABQsJCAcDBRUKCQgLBRYCAwEA Ah4BAheAACEJECV8W48dILkvFiEEzh239E0g/Drdn/5aJXxbjx0guS/UtAf+JkEY+fQ29Gcv 509tfZW+uvTEmXzvIWmMP7TGYHGnHc/swhB8IY25J7/Z88qUxD0tTjnTHlNEEk4ZYAwHrgfv G/epK/AccKmPTj/FsmoUp4cRLwq17rQv2nc8L7i/Yg6syYTHaRF0SCQ8TPvcSoC4hP3IBWZj t23R0TyDeSnvK/+IeIsNejgz37Q+bWBtWsvUl6EBB0y51T6dp1RjsBS3Ot4FkFOqzMqCc3y1 808khhLgBnU24LnA62RMcUfvgMIRx0w8ioj1xJyp3U6c/JFhHxlLW5uVnOZ/odhuf+Hnel2u wyRCQxI2dLhBDZ9LVbospxZQok2GgRJIK6cnX23afc7ATQRdTcqoAQgAxQIqcXiQTaIFAWXc 9YEGuhrQF+TmKF7Jt1IGFmvfdmofnoFZ/8teZB03XP1VSVI/IXM7CTsEfQlBMgGcc9Tj3c9Z v+De/FfjBLJYOYKJIleIfhIZBLr6Hxru2qGma+piKXjbJCBJabSIu4YDM6iH3D2GJwanSspc ee3yvTSR7we1hcoavemw3pseurg6Y4dWsKEJLNP2xZ0C7fyidQsIh7RtNuzKsSVqqx1YbBwO 4cek4gQfJ9UC0nvt9X/pX1COhDeNAsTI8h2iC13Gi14a+EWF8ppvK0V3i5VDaxWrreUDY1Nt L6qGiQte/X4tvzRLEIe1gpT5wRK/QVXARlF8lQARAQABwsCTBBgBCgAmFiEEzh239E0g/Drd n/5aJXxbjx0guS8FAl1NyqgCGwwFCQPCZwAAIQkQJXxbjx0guS8WIQTOHbf0TSD8Ot2f/lol fFuPHSC5L+GLCACkU8DKD+HOEPvxTftn3pQ6YE+yfwSeS1uBjH6D2SsXdTrAZEE9KNjqYExr PuMy1GxAH3CeD+Kqc0sra5I9s3AdNAM1YeHQbY4zWaHfcaeU/cF/c2MxyhnRbr/UF382PUY5 yoWAmIBomSZdaifXXuU/CosZkpk01LDfl5fx5SfF13TrZ1FtPbXmP5S0n2HzxLM64hF0RzVz zR8xEofnP7jWJGcO7KcUCqSy64KGgNlYzyCWso+Tf0AJOtWYkfRvI/MyruItQ31jRs7VRh67 /lX38m5iqqjjwQ2GNZq29qGCNmjmsBjgzMmoy+5jUuoy233waGIGRFt1g9pLiMmchdWR Message-ID: Date: Mon, 8 Jun 2020 00:27:41 +0200 MIME-Version: 1.0 Content-Language: en-US X-purgate: clean X-purgate: This mail is considered clean (visit http://www.eleven.de for further information) X-purgate-type: clean X-purgate-Ad: Categorized by eleven eXpurgate (R) http://www.eleven.de X-purgate: This mail is considered clean (visit http://www.eleven.de for further information) X-purgate: clean X-purgate-size: 25263 X-purgate-ID: 154282::1591568861-0000058E-1D8B43F0/0/0 Subject: [FFmpeg-devel] [PATCH] lavdevice: Add AudioToolbox output device. X-BeenThere: ffmpeg-devel@ffmpeg.org X-Mailman-Version: 2.1.20 Precedence: list List-Id: FFmpeg development discussions and patches List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Reply-To: FFmpeg development discussions and patches Errors-To: ffmpeg-devel-bounces@ffmpeg.org Sender: "ffmpeg-devel" Hi, $subject. Enables native audio output on OSX. OSX accepts numerous formats, so there are several output devices. -Thilo From bdabbc6a919ccff20d6ae16acff1a5d0f8ca46b8 Mon Sep 17 00:00:00 2001 From: Thilo Borgmann Date: Mon, 8 Jun 2020 00:20:25 +0200 Subject: [PATCH] lavdevice: Add AudioToolbox output device. --- configure | 3 + libavdevice/Makefile | 1 + libavdevice/alldevices.c | 10 ++ libavdevice/audiotoolbox.m | 308 +++++++++++++++++++++++++++++++++++++ 4 files changed, 322 insertions(+) create mode 100644 libavdevice/audiotoolbox.m diff --git a/configure b/configure index f97cad0298..1aab998d8e 100755 --- a/configure +++ b/configure @@ -3366,6 +3366,8 @@ alsa_outdev_deps="alsa" avfoundation_indev_deps="avfoundation corevideo coremedia pthreads" avfoundation_indev_suggest="coregraphics applicationservices" avfoundation_indev_extralibs="-framework Foundation" +audiotoolbox_outdev_deps="audiotoolbox pthreads" +audiotoolbox_outdev_extralibs="-framework AudioToolbox -framework CoreAudio" bktr_indev_deps_any="dev_bktr_ioctl_bt848_h machine_ioctl_bt848_h dev_video_bktr_ioctl_bt848_h dev_ic_bt8xx_h" caca_outdev_deps="libcaca" decklink_deps_any="libdl LoadLibrary" @@ -6151,6 +6153,7 @@ enabled videotoolbox && check_apple_framework VideoToolbox check_apple_framework CoreFoundation check_apple_framework CoreMedia check_apple_framework CoreVideo +check_apple_framework CoreAudio enabled avfoundation && { disable coregraphics applicationservices diff --git a/libavdevice/Makefile b/libavdevice/Makefile index 6ea62b914e..0dfe47a1f4 100644 --- a/libavdevice/Makefile +++ b/libavdevice/Makefile @@ -15,6 +15,7 @@ OBJS-$(CONFIG_SHARED) += reverse.o OBJS-$(CONFIG_ALSA_INDEV) += alsa_dec.o alsa.o timefilter.o OBJS-$(CONFIG_ALSA_OUTDEV) += alsa_enc.o alsa.o OBJS-$(CONFIG_ANDROID_CAMERA_INDEV) += android_camera.o +OBJS-$(CONFIG_AUDIOTOOLBOX_OUTDEV) += audiotoolbox.o OBJS-$(CONFIG_AVFOUNDATION_INDEV) += avfoundation.o OBJS-$(CONFIG_BKTR_INDEV) += bktr.o OBJS-$(CONFIG_CACA_OUTDEV) += caca.o diff --git a/libavdevice/alldevices.c b/libavdevice/alldevices.c index 8633433254..4246474536 100644 --- a/libavdevice/alldevices.c +++ b/libavdevice/alldevices.c @@ -27,6 +27,16 @@ extern AVInputFormat ff_alsa_demuxer; extern AVOutputFormat ff_alsa_muxer; extern AVInputFormat ff_android_camera_demuxer; +extern AVOutputFormat ff_audiotoolbox_muxer; +extern AVOutputFormat ff_audiotoolbox_f32_muxer; +extern AVOutputFormat ff_audiotoolbox_s32_muxer; +extern AVOutputFormat ff_audiotoolbox_s24_muxer; +extern AVOutputFormat ff_audiotoolbox_s16_muxer; +extern AVOutputFormat ff_audiotoolbox_s8_muxer; +extern AVOutputFormat ff_audiotoolbox_u32_muxer; +extern AVOutputFormat ff_audiotoolbox_u24_muxer; +extern AVOutputFormat ff_audiotoolbox_u16_muxer; +extern AVOutputFormat ff_audiotoolbox_u8_muxer; extern AVInputFormat ff_avfoundation_demuxer; extern AVInputFormat ff_bktr_demuxer; extern AVOutputFormat ff_caca_muxer; diff --git a/libavdevice/audiotoolbox.m b/libavdevice/audiotoolbox.m new file mode 100644 index 0000000000..9950e1fadd --- /dev/null +++ b/libavdevice/audiotoolbox.m @@ -0,0 +1,308 @@ +/* + * AudioToolbox output device + * Copyright (c) 2020 Thilo Borgmann + * + * This file is part of FFmpeg. + * + * FFmpeg is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * FFmpeg is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with FFmpeg; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** + * @file + * AudioToolbox output device + * @author Thilo Borgmann + */ + +#import +#include + +#include "libavutil/opt.h" +#include "libavformat/internal.h" +#include "libavutil/internal.h" +#include "avdevice.h" + +typedef struct +{ + AVClass* class; + + AudioDeviceID* devices; + int num_devices; + + AudioQueueBufferRef buffer[2]; + pthread_mutex_t buffer_lock[2]; + int cur_buf; + AudioQueueRef queue; + + int list_devices; + int audio_device_index; + +} ATContext; + +static int check_status(ATContext *ctx, OSStatus *status, const char *msg) +{ + if (*status != noErr) { + av_log(ctx, AV_LOG_ERROR, "Error: %s (%i)\n", msg, *status); + return 1; + } else { + av_log(ctx, AV_LOG_DEBUG, " OK : %s\n", msg); + return 0; + } +} + +static void queue_callback(void* atctx, AudioQueueRef inAQ, + AudioQueueBufferRef inBuffer) +{ + // unlock the buffer that has just been consumed + ATContext *ctx = (ATContext*)atctx; + for (int i = 0; i < 2; i++) { + if (inBuffer == ctx->buffer[i]) { + pthread_mutex_unlock(&ctx->buffer_lock[i]); + } + } +} + +static av_cold int at_write_header(AVFormatContext *s) +{ + ATContext *ctx = (ATContext*)s->priv_data; + OSStatus err = noErr; + CFStringRef device_UID = NULL; + + // get devices + UInt32 data_size = 0; + AudioObjectPropertyAddress prop; + prop.mSelector = kAudioHardwarePropertyDevices; + prop.mScope = kAudioObjectPropertyScopeGlobal; + prop.mElement = kAudioObjectPropertyElementMaster; + err = AudioObjectGetPropertyDataSize(kAudioObjectSystemObject, &prop, 0, NULL, &data_size); + if (check_status(ctx, &err, "AudioObjectGetPropertyDataSize devices")) + return AVERROR(EINVAL); + + ctx->num_devices = data_size / sizeof(AudioDeviceID); + + ctx->devices = (AudioDeviceID*)(av_malloc(data_size)); + err = AudioObjectGetPropertyData(kAudioObjectSystemObject, &prop, 0, NULL, &data_size, ctx->devices); + if (check_status(ctx, &err, "AudioObjectGetPropertyData devices")) + return AVERROR(EINVAL); + + // list devices + if (ctx->list_devices) { + CFStringRef device_name = NULL; + prop.mScope = kAudioDevicePropertyScopeInput; + + av_log(ctx, AV_LOG_INFO, "CoreAudio devices:\n"); + for(UInt32 i = 0; i < ctx->num_devices; ++i) { + // UID + data_size = sizeof(device_UID); + prop.mSelector = kAudioDevicePropertyDeviceUID; + err = AudioObjectGetPropertyData(ctx->devices[i], &prop, 0, NULL, &data_size, &device_UID); + if (check_status(ctx, &err, "AudioObjectGetPropertyData UID")) + continue; + + // name + data_size = sizeof(device_name); + prop.mSelector = kAudioDevicePropertyDeviceNameCFString; + err = AudioObjectGetPropertyData(ctx->devices[i], &prop, 0, NULL, &data_size, &device_name); + if (check_status(ctx, &err, "AudioObjecTGetPropertyData name")) + continue; + + av_log(ctx, AV_LOG_INFO, "[%d] %30s, %s\n", i, + CFStringGetCStringPtr(device_name, kCFStringEncodingMacRoman), + CFStringGetCStringPtr(device_UID, kCFStringEncodingMacRoman)); + } + } + + // get user-defined device UID or use default device + // -audio_device_index overrides any URL given + const char *stream_name = s->url; + if (stream_name && ctx->audio_device_index == -1) { + sscanf(stream_name, "%d", &ctx->audio_device_index); + } + + if (ctx->audio_device_index >= 0) { + // get UID of selected device + data_size = sizeof(device_UID); + prop.mSelector = kAudioDevicePropertyDeviceUID; + err = AudioObjectGetPropertyData(ctx->devices[ctx->audio_device_index], &prop, 0, NULL, &data_size, &device_UID); + if (check_status(ctx, &err, "AudioObjecTGetPropertyData UID")) + return AVERROR(EINVAL); + } else { + // use default device + device_UID = NULL; + } + + av_log(ctx, AV_LOG_DEBUG, "stream_name: %s\n", stream_name); + av_log(ctx, AV_LOG_DEBUG, "audio_device_idnex: %i\n", ctx->audio_device_index); + av_log(ctx, AV_LOG_DEBUG, "UID: %s\n", CFStringGetCStringPtr(device_UID, kCFStringEncodingMacRoman)); + + // check input stream + if (s->nb_streams != 1 || s->streams[0]->codecpar->codec_type != AVMEDIA_TYPE_AUDIO) { + av_log(ctx, AV_LOG_ERROR, "Only a single audio stream is supported.\n"); + return AVERROR(EINVAL); + } + + AVCodecParameters *codecpar = s->streams[0]->codecpar; + + // audio format + AudioStreamBasicDescription device_format = {0}; + device_format.mSampleRate = codecpar->sample_rate; + device_format.mFormatID = kAudioFormatLinearPCM; + device_format.mFormatFlags |= (codecpar->format == AV_SAMPLE_FMT_FLT) ? kLinearPCMFormatFlagIsFloat : 0; + device_format.mFormatFlags |= (codecpar->codec_id == AV_CODEC_ID_PCM_S8) ? kLinearPCMFormatFlagIsSignedInteger : 0; + device_format.mFormatFlags |= (codecpar->codec_id == AV_NE(AV_CODEC_ID_PCM_S16BE, AV_CODEC_ID_PCM_S16LE)) ? kLinearPCMFormatFlagIsSignedInteger : 0; + device_format.mFormatFlags |= (codecpar->codec_id == AV_NE(AV_CODEC_ID_PCM_S24BE, AV_CODEC_ID_PCM_S24LE)) ? kLinearPCMFormatFlagIsSignedInteger : 0; + device_format.mFormatFlags |= (codecpar->codec_id == AV_NE(AV_CODEC_ID_PCM_S32BE, AV_CODEC_ID_PCM_S32LE)) ? kLinearPCMFormatFlagIsSignedInteger : 0; + device_format.mFormatFlags |= (av_sample_fmt_is_planar(codecpar->format)) ? kAudioFormatFlagIsNonInterleaved : 0; + device_format.mFormatFlags |= AV_NE(kAudioFormatFlagIsBigEndian, 0); + device_format.mChannelsPerFrame = codecpar->channels; + device_format.mBitsPerChannel = (codecpar->codec_id == AV_NE(AV_CODEC_ID_PCM_S24BE, AV_CODEC_ID_PCM_S24LE)) ? 24 : (av_get_bytes_per_sample(codecpar->format) << 3); + device_format.mBytesPerFrame = (device_format.mBitsPerChannel >> 3) * device_format.mChannelsPerFrame; + device_format.mFramesPerPacket = 1; + device_format.mBytesPerPacket = device_format.mBytesPerFrame * device_format.mFramesPerPacket; + device_format.mReserved = 0; + + av_log(ctx, AV_LOG_DEBUG, "device_format.mSampleRate = %i\n", codecpar->sample_rate); + av_log(ctx, AV_LOG_DEBUG, "device_format.mFormatID = %s\n", "kAudioFormatLinearPCM"); + av_log(ctx, AV_LOG_DEBUG, "device_format.mFormatFlags |= %s\n", (codecpar->format == AV_SAMPLE_FMT_FLT) ? "kLinearPCMFormatFlagIsFloat" : "0"); + av_log(ctx, AV_LOG_DEBUG, "device_format.mFormatFlags |= %s\n", (codecpar->codec_id == AV_CODEC_ID_PCM_S8) ? "kLinearPCMFormatFlagIsSignedInteger" : "0"); + av_log(ctx, AV_LOG_DEBUG, "device_format.mFormatFlags |= %s\n", (codecpar->codec_id == AV_NE(AV_CODEC_ID_PCM_S32BE, AV_CODEC_ID_PCM_S32LE)) ? "kLinearPCMFormatFlagIsSignedInteger" : "0"); + av_log(ctx, AV_LOG_DEBUG, "device_format.mFormatFlags |= %s\n", (codecpar->codec_id == AV_NE(AV_CODEC_ID_PCM_S16BE, AV_CODEC_ID_PCM_S16LE)) ? "kLinearPCMFormatFlagIsSignedInteger" : "0"); + av_log(ctx, AV_LOG_DEBUG, "device_format.mFormatFlags |= %s\n", (codecpar->codec_id == AV_NE(AV_CODEC_ID_PCM_S24BE, AV_CODEC_ID_PCM_S24LE)) ? "kLinearPCMFormatFlagIsSignedInteger" : "0"); + av_log(ctx, AV_LOG_DEBUG, "device_format.mFormatFlags |= %s\n", (av_sample_fmt_is_planar(codecpar->format)) ? "kAudioFormatFlagIsNonInterleaved" : "0"); + av_log(ctx, AV_LOG_DEBUG, "device_format.mFormatFlags |= %s\n", AV_NE("kAudioFormatFlagIsBigEndian", "0")); + av_log(ctx, AV_LOG_DEBUG, "device_format.mFormatFlags == %i\n", device_format.mFormatFlags); + av_log(ctx, AV_LOG_DEBUG, "device_format.mChannelsPerFrame = %i\n", codecpar->channels); + av_log(ctx, AV_LOG_DEBUG, "device_format.mBitsPerChannel = %i\n", av_get_bytes_per_sample(codecpar->format) << 3); + av_log(ctx, AV_LOG_DEBUG, "device_format.mBytesPerFrame = %i\n", (device_format.mBitsPerChannel >> 3) * codecpar->channels); + av_log(ctx, AV_LOG_DEBUG, "device_format.mBytesPerPacket = %i\n", device_format.mBytesPerFrame); + av_log(ctx, AV_LOG_DEBUG, "device_format.mFramesPerPacket = %i\n", 1); + av_log(ctx, AV_LOG_DEBUG, "device_format.mReserved = %i\n", 0); + + // create new output queue for the device + err = AudioQueueNewOutput(&device_format, queue_callback, ctx, + NULL, kCFRunLoopCommonModes, + 0, &ctx->queue); + if (check_status(ctx, &err, "AudioQueueNewOutput")) + return AVERROR(EINVAL); + + // set user-defined device or leave untouched for default + if (device_UID != NULL) { + err = AudioQueueSetProperty(ctx->queue, kAudioQueueProperty_CurrentDevice, &device_UID, sizeof(device_UID)); + if (check_status(ctx, &err, "AudioQueueSetProperty output UID")) + return AVERROR(EINVAL); + } + + // start the queue + err = AudioQueueStart(ctx->queue, NULL); + if (check_status(ctx, &err, "AudioQueueStart")) + return AVERROR(EINVAL); + + // init the mutexes for double-buffering + pthread_mutex_init(&ctx->buffer_lock[0], NULL); + pthread_mutex_init(&ctx->buffer_lock[1], NULL); + + return 0; +} + +static int at_write_packet(AVFormatContext *s, AVPacket *pkt) +{ + ATContext *ctx = (ATContext*)s->priv_data; + OSStatus err = noErr; + + // use the other buffer + ctx->cur_buf = !ctx->cur_buf; + + // lock for writing or wait for the buffer to be available + // will be unlocked by queue callback + pthread_mutex_lock(&ctx->buffer_lock[ctx->cur_buf]); + + // (re-)allocate the buffer if not existant or of different size + if (!ctx->buffer[ctx->cur_buf] || ctx->buffer[ctx->cur_buf]->mAudioDataBytesCapacity != pkt->size) { + err = AudioQueueAllocateBuffer(ctx->queue, pkt->size, &ctx->buffer[ctx->cur_buf]); + if (check_status(ctx, &err, "AudioQueueAllocateBuffer")) { + pthread_mutex_unlock(&ctx->buffer_lock[ctx->cur_buf]); + return AVERROR(ENOMEM); + } + } + + AudioQueueBufferRef buf = ctx->buffer[ctx->cur_buf]; + + // copy audio data into buffer and enqueue the buffer + memcpy(buf->mAudioData, pkt->data, buf->mAudioDataBytesCapacity); + buf->mAudioDataByteSize = buf->mAudioDataBytesCapacity; + err = AudioQueueEnqueueBuffer(ctx->queue, buf, 0, NULL); + if (check_status(ctx, &err, "AudioQueueEnqueueBuffer")) { + pthread_mutex_unlock(&ctx->buffer_lock[ctx->cur_buf]); + return AVERROR(EINVAL); + } + + return 0; +} + +static av_cold int at_write_trailer(AVFormatContext *s) +{ + ATContext *ctx = (ATContext*)s->priv_data; + OSStatus err = noErr; + + av_freep(&ctx->devices); + pthread_mutex_destroy(&ctx->buffer_lock[0]); + pthread_mutex_destroy(&ctx->buffer_lock[1]); + + err = AudioQueueFlush(ctx->queue); + check_status(ctx, &err, "AudioQueueFlush"); + err = AudioQueueDispose(ctx->queue, true); + check_status(ctx, &err, "AudioQueueDispose"); + + return 0; +} + +static const AVOption options[] = { + { "list_devices", "list available audio devices", offsetof(ATContext, list_devices), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, AV_OPT_FLAG_ENCODING_PARAM }, + { "audio_device_index", "select audio device by index (starts at 0)", offsetof(ATContext, audio_device_index), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM }, + { NULL }, +}; + +static const AVClass at_class = { + .class_name = "AudioToolbox outdev", + .item_name = av_default_item_name, + .option = options, + .version = LIBAVUTIL_VERSION_INT, + .category = AV_CLASS_CATEGORY_DEVICE_AUDIO_OUTPUT, +}; + +#define ATDEF(name_, long_name_, codec) \ +AVOutputFormat ff_ ## name_ ## _muxer = { \ + .name = #name_, \ + .long_name = NULL_IF_CONFIG_SMALL(long_name_), \ + .priv_data_size = sizeof(ATContext), \ + .audio_codec = codec, \ + .video_codec = AV_CODEC_ID_NONE, \ + .write_header = at_write_header, \ + .write_packet = at_write_packet, \ + .write_trailer = at_write_trailer, \ + .flags = AVFMT_NOFILE, \ + .priv_class = &at_class, \ +}; + +ATDEF(audiotoolbox, "AudioToolbox (S16) output device", AV_NE(AV_CODEC_ID_PCM_S16BE, AV_CODEC_ID_PCM_S16LE)); +ATDEF(audiotoolbox_f32, "AudioToolbox (F32) output device", AV_NE(AV_CODEC_ID_PCM_F32BE, AV_CODEC_ID_PCM_F32LE)); +ATDEF(audiotoolbox_s32, "AudioToolbox (S32) output device", AV_NE(AV_CODEC_ID_PCM_S32BE, AV_CODEC_ID_PCM_S32LE)); +ATDEF(audiotoolbox_s24, "AudioToolbox (S24) output device", AV_NE(AV_CODEC_ID_PCM_S24BE, AV_CODEC_ID_PCM_S24LE)); +ATDEF(audiotoolbox_s16, "AudioToolbox (S16) output device", AV_NE(AV_CODEC_ID_PCM_S16BE, AV_CODEC_ID_PCM_S16LE)); +ATDEF(audiotoolbox_s8, "AudioToolbox (S8) output device", AV_CODEC_ID_PCM_S8); +ATDEF(audiotoolbox_u32, "AudioToolbox (U32) output device", AV_NE(AV_CODEC_ID_PCM_U32BE, AV_CODEC_ID_PCM_U32LE)); +ATDEF(audiotoolbox_u24, "AudioToolbox (U24) output device", AV_NE(AV_CODEC_ID_PCM_U24BE, AV_CODEC_ID_PCM_U24LE)); +ATDEF(audiotoolbox_u16, "AudioToolbox (U16) output device", AV_NE(AV_CODEC_ID_PCM_U16BE, AV_CODEC_ID_PCM_U16LE)); +ATDEF(audiotoolbox_u8, "AudioToolbox (U8) output device", AV_CODEC_ID_PCM_U8); +