libavdevice/audiotoolbox.m - manifest_repos/ffmpeg - Git at Google

 /*
  * AudioToolbox output device
  * Copyright (c) 2020 Thilo Borgmann <thilo.borgmann@mail.de>
  *
  * 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 <thilo.borgmann@mail.de>
  */

 #import <AudioToolbox/AudioToolbox.h>
 #include <pthread.h>

 #include "libavutil/opt.h"
 #include "libavformat/internal.h"
 #include "libavutil/internal.h"
 #include "avdevice.h"

 typedef struct
 {
     AVClass             *class;

     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(AVFormatContext *avctx, OSStatus *status, const char *msg)
 {
     if (*status != noErr) {
         av_log(avctx, AV_LOG_ERROR, "Error: %s (%i)\n", msg, *status);
         return 1;
     } else {
         av_log(avctx, 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 *avctx)
 {
     ATContext *ctx = (ATContext*)avctx->priv_data;
     OSStatus err = noErr;
     CFStringRef device_UID = NULL;
     AudioDeviceID *devices;
     int num_devices;


     // 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(avctx, &err, "AudioObjectGetPropertyDataSize devices"))
         return AVERROR(EINVAL);

     num_devices = data_size / sizeof(AudioDeviceID);

     devices = (AudioDeviceID*)(av_malloc(data_size));
     err = AudioObjectGetPropertyData(kAudioObjectSystemObject, &prop, 0, NULL, &data_size, devices);
     if (check_status(avctx, &err, "AudioObjectGetPropertyData devices")) {
         av_freep(&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 < num_devices; ++i) {
             // UID
             data_size = sizeof(device_UID);
             prop.mSelector = kAudioDevicePropertyDeviceUID;
             err = AudioObjectGetPropertyData(devices[i], &prop, 0, NULL, &data_size, &device_UID);
             if (check_status(avctx, &err, "AudioObjectGetPropertyData UID"))
                 continue;

             // name
             data_size = sizeof(device_name);
             prop.mSelector = kAudioDevicePropertyDeviceNameCFString;
             err = AudioObjectGetPropertyData(devices[i], &prop, 0, NULL, &data_size, &device_name);
             if (check_status(avctx, &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 = avctx->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(devices[ctx->audio_device_index], &prop, 0, NULL, &data_size, &device_UID);
         if (check_status(avctx, &err, "AudioObjecTGetPropertyData UID")) {
             av_freep(&devices);
             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 (avctx->nb_streams != 1 || avctx->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);
     }

     av_freep(&devices);
     AVCodecParameters *codecpar = avctx->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      |= (codecpar->codec_id == AV_CODEC_ID_PCM_F32BE) ? kAudioFormatFlagIsBigEndian : 0;
     device_format.mFormatFlags      |= (codecpar->codec_id == AV_CODEC_ID_PCM_S16BE) ? kAudioFormatFlagIsBigEndian : 0;
     device_format.mFormatFlags      |= (codecpar->codec_id == AV_CODEC_ID_PCM_S24BE) ? kAudioFormatFlagIsBigEndian : 0;
     device_format.mFormatFlags      |= (codecpar->codec_id == AV_CODEC_ID_PCM_S32BE) ? 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", (codecpar->codec_id == AV_CODEC_ID_PCM_F32BE) ? "kAudioFormatFlagIsBigEndian" : "0");
     av_log(ctx, AV_LOG_DEBUG, "device_format.mFormatFlags      |= %s\n", (codecpar->codec_id == AV_CODEC_ID_PCM_S16BE) ? "kAudioFormatFlagIsBigEndian" : "0");
     av_log(ctx, AV_LOG_DEBUG, "device_format.mFormatFlags      |= %s\n", (codecpar->codec_id == AV_CODEC_ID_PCM_S24BE) ? "kAudioFormatFlagIsBigEndian" : "0");
     av_log(ctx, AV_LOG_DEBUG, "device_format.mFormatFlags      |= %s\n", (codecpar->codec_id == AV_CODEC_ID_PCM_S32BE) ? "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(avctx, &err, "AudioQueueNewOutput")) {
         if (err == kAudioFormatUnsupportedDataFormatError)
             av_log(ctx, AV_LOG_ERROR, "Unsupported output format.\n");
         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(avctx, &err, "AudioQueueSetProperty output UID"))
             return AVERROR(EINVAL);
     }

     // start the queue
     err = AudioQueueStart(ctx->queue, NULL);
     if (check_status(avctx, &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 *avctx, AVPacket *pkt)
 {
     ATContext *ctx = (ATContext*)avctx->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(avctx, &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(avctx, &err, "AudioQueueEnqueueBuffer")) {
         pthread_mutex_unlock(&ctx->buffer_lock[ctx->cur_buf]);
         return AVERROR(EINVAL);
     }

     return 0;
 }

 static av_cold int at_write_trailer(AVFormatContext *avctx)
 {
     ATContext *ctx = (ATContext*)avctx->priv_data;
     OSStatus err = noErr;

     pthread_mutex_destroy(&ctx->buffer_lock[0]);
     pthread_mutex_destroy(&ctx->buffer_lock[1]);

     err = AudioQueueFlush(ctx->queue);
     check_status(avctx, &err, "AudioQueueFlush");
     err = AudioQueueDispose(ctx->queue, true);
     check_status(avctx, &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",
     .item_name  = av_default_item_name,
     .option     = options,
     .version    = LIBAVUTIL_VERSION_INT,
     .category   = AV_CLASS_CATEGORY_DEVICE_AUDIO_OUTPUT,
 };

 AVOutputFormat ff_audiotoolbox_muxer = {
     .name           = "audiotoolbox",
     .long_name      = NULL_IF_CONFIG_SMALL("AudioToolbox output device"),
     .priv_data_size = sizeof(ATContext),
     .audio_codec    = AV_NE(AV_CODEC_ID_PCM_S16BE, AV_CODEC_ID_PCM_S16LE),
     .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,
 };
	/*
	* AudioToolbox output device
	* Copyright (c) 2020 Thilo Borgmann <thilo.borgmann@mail.de>
	*
	* 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 <thilo.borgmann@mail.de>
	*/

	#import <AudioToolbox/AudioToolbox.h>
	#include <pthread.h>

	#include "libavutil/opt.h"
	#include "libavformat/internal.h"
	#include "libavutil/internal.h"
	#include "avdevice.h"

	typedef struct
	{
	AVClass *class;

	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(AVFormatContext avctx, OSStatus status, const char *msg)
	{
	if (*status != noErr) {
	av_log(avctx, AV_LOG_ERROR, "Error: %s (%i)\n", msg, *status);
	return 1;
	} else {
	av_log(avctx, 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 *avctx)
	{
	ATContext ctx = (ATContext)avctx->priv_data;
	OSStatus err = noErr;
	CFStringRef device_UID = NULL;
	AudioDeviceID *devices;
	int num_devices;


	// 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(avctx, &err, "AudioObjectGetPropertyDataSize devices"))
	return AVERROR(EINVAL);

	num_devices = data_size / sizeof(AudioDeviceID);

	devices = (AudioDeviceID*)(av_malloc(data_size));
	err = AudioObjectGetPropertyData(kAudioObjectSystemObject, &prop, 0, NULL, &data_size, devices);
	if (check_status(avctx, &err, "AudioObjectGetPropertyData devices")) {
	av_freep(&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 < num_devices; ++i) {
	// UID
	data_size = sizeof(device_UID);
	prop.mSelector = kAudioDevicePropertyDeviceUID;
	err = AudioObjectGetPropertyData(devices[i], &prop, 0, NULL, &data_size, &device_UID);
	if (check_status(avctx, &err, "AudioObjectGetPropertyData UID"))
	continue;

	// name
	data_size = sizeof(device_name);
	prop.mSelector = kAudioDevicePropertyDeviceNameCFString;
	err = AudioObjectGetPropertyData(devices[i], &prop, 0, NULL, &data_size, &device_name);
	if (check_status(avctx, &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 = avctx->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(devices[ctx->audio_device_index], &prop, 0, NULL, &data_size, &device_UID);
	if (check_status(avctx, &err, "AudioObjecTGetPropertyData UID")) {
	av_freep(&devices);
	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 (avctx->nb_streams != 1 \|\| avctx->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);
	}

	av_freep(&devices);
	AVCodecParameters *codecpar = avctx->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 \|= (codecpar->codec_id == AV_CODEC_ID_PCM_F32BE) ? kAudioFormatFlagIsBigEndian : 0;
	device_format.mFormatFlags \|= (codecpar->codec_id == AV_CODEC_ID_PCM_S16BE) ? kAudioFormatFlagIsBigEndian : 0;
	device_format.mFormatFlags \|= (codecpar->codec_id == AV_CODEC_ID_PCM_S24BE) ? kAudioFormatFlagIsBigEndian : 0;
	device_format.mFormatFlags \|= (codecpar->codec_id == AV_CODEC_ID_PCM_S32BE) ? 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", (codecpar->codec_id == AV_CODEC_ID_PCM_F32BE) ? "kAudioFormatFlagIsBigEndian" : "0");
	av_log(ctx, AV_LOG_DEBUG, "device_format.mFormatFlags \|= %s\n", (codecpar->codec_id == AV_CODEC_ID_PCM_S16BE) ? "kAudioFormatFlagIsBigEndian" : "0");
	av_log(ctx, AV_LOG_DEBUG, "device_format.mFormatFlags \|= %s\n", (codecpar->codec_id == AV_CODEC_ID_PCM_S24BE) ? "kAudioFormatFlagIsBigEndian" : "0");
	av_log(ctx, AV_LOG_DEBUG, "device_format.mFormatFlags \|= %s\n", (codecpar->codec_id == AV_CODEC_ID_PCM_S32BE) ? "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(avctx, &err, "AudioQueueNewOutput")) {
	if (err == kAudioFormatUnsupportedDataFormatError)
	av_log(ctx, AV_LOG_ERROR, "Unsupported output format.\n");
	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(avctx, &err, "AudioQueueSetProperty output UID"))
	return AVERROR(EINVAL);
	}

	// start the queue
	err = AudioQueueStart(ctx->queue, NULL);
	if (check_status(avctx, &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 avctx, AVPacket pkt)
	{
	ATContext ctx = (ATContext)avctx->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(avctx, &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(avctx, &err, "AudioQueueEnqueueBuffer")) {
	pthread_mutex_unlock(&ctx->buffer_lock[ctx->cur_buf]);
	return AVERROR(EINVAL);
	}

	return 0;
	}

	static av_cold int at_write_trailer(AVFormatContext *avctx)
	{
	ATContext ctx = (ATContext)avctx->priv_data;
	OSStatus err = noErr;

	pthread_mutex_destroy(&ctx->buffer_lock[0]);
	pthread_mutex_destroy(&ctx->buffer_lock[1]);

	err = AudioQueueFlush(ctx->queue);
	check_status(avctx, &err, "AudioQueueFlush");
	err = AudioQueueDispose(ctx->queue, true);
	check_status(avctx, &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",
	.item_name = av_default_item_name,
	.option = options,
	.version = LIBAVUTIL_VERSION_INT,
	.category = AV_CLASS_CATEGORY_DEVICE_AUDIO_OUTPUT,
	};

	AVOutputFormat ff_audiotoolbox_muxer = {
	.name = "audiotoolbox",
	.long_name = NULL_IF_CONFIG_SMALL("AudioToolbox output device"),
	.priv_data_size = sizeof(ATContext),
	.audio_codec = AV_NE(AV_CODEC_ID_PCM_S16BE, AV_CODEC_ID_PCM_S16LE),
	.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,
	};