summaryrefslogtreecommitdiffstats
path: root/libavcodec/audiotoolboxenc.c
diff options
context:
space:
mode:
Diffstat (limited to 'libavcodec/audiotoolboxenc.c')
-rw-r--r--libavcodec/audiotoolboxenc.c661
1 files changed, 661 insertions, 0 deletions
diff --git a/libavcodec/audiotoolboxenc.c b/libavcodec/audiotoolboxenc.c
new file mode 100644
index 0000000..2c18916
--- /dev/null
+++ b/libavcodec/audiotoolboxenc.c
@@ -0,0 +1,661 @@
+/*
+ * Audio Toolbox system codecs
+ *
+ * copyright (c) 2016 Rodger Combs
+ *
+ * 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
+ */
+
+#include <AudioToolbox/AudioToolbox.h>
+
+#define FF_BUFQUEUE_SIZE 256
+#include "libavfilter/bufferqueue.h"
+
+#include "config.h"
+#include "audio_frame_queue.h"
+#include "avcodec.h"
+#include "bytestream.h"
+#include "internal.h"
+#include "libavformat/isom.h"
+#include "libavutil/avassert.h"
+#include "libavutil/opt.h"
+#include "libavutil/log.h"
+
+typedef struct ATDecodeContext {
+ AVClass *av_class;
+ int mode;
+ int quality;
+
+ AudioConverterRef converter;
+ struct FFBufQueue frame_queue;
+ struct FFBufQueue used_frame_queue;
+
+ unsigned pkt_size;
+ AudioFrameQueue afq;
+ int eof;
+ int frame_size;
+
+ AVFrame* encoding_frame;
+} ATDecodeContext;
+
+static UInt32 ffat_get_format_id(enum AVCodecID codec, int profile)
+{
+ switch (codec) {
+ case AV_CODEC_ID_AAC:
+ switch (profile) {
+ case FF_PROFILE_AAC_LOW:
+ default:
+ return kAudioFormatMPEG4AAC;
+ case FF_PROFILE_AAC_HE:
+ return kAudioFormatMPEG4AAC_HE;
+ case FF_PROFILE_AAC_HE_V2:
+ return kAudioFormatMPEG4AAC_HE_V2;
+ case FF_PROFILE_AAC_LD:
+ return kAudioFormatMPEG4AAC_LD;
+ case FF_PROFILE_AAC_ELD:
+ return kAudioFormatMPEG4AAC_ELD;
+ }
+ case AV_CODEC_ID_ADPCM_IMA_QT:
+ return kAudioFormatAppleIMA4;
+ case AV_CODEC_ID_ALAC:
+ return kAudioFormatAppleLossless;
+ case AV_CODEC_ID_ILBC:
+ return kAudioFormatiLBC;
+ case AV_CODEC_ID_PCM_ALAW:
+ return kAudioFormatALaw;
+ case AV_CODEC_ID_PCM_MULAW:
+ return kAudioFormatULaw;
+ default:
+ av_assert0(!"Invalid codec ID!");
+ return 0;
+ }
+}
+
+static void ffat_update_ctx(AVCodecContext *avctx)
+{
+ ATDecodeContext *at = avctx->priv_data;
+ UInt32 size = sizeof(unsigned);
+ AudioConverterPrimeInfo prime_info;
+ AudioStreamBasicDescription out_format;
+
+ AudioConverterGetProperty(at->converter,
+ kAudioConverterPropertyMaximumOutputPacketSize,
+ &size, &at->pkt_size);
+
+ if (at->pkt_size <= 0)
+ at->pkt_size = 1024 * 50;
+
+ size = sizeof(prime_info);
+
+ if (!AudioConverterGetProperty(at->converter,
+ kAudioConverterPrimeInfo,
+ &size, &prime_info)) {
+ avctx->initial_padding = prime_info.leadingFrames;
+ }
+
+ size = sizeof(out_format);
+ if (!AudioConverterGetProperty(at->converter,
+ kAudioConverterCurrentOutputStreamDescription,
+ &size, &out_format)) {
+ if (out_format.mFramesPerPacket)
+ avctx->frame_size = out_format.mFramesPerPacket;
+ if (out_format.mBytesPerPacket && avctx->codec_id == AV_CODEC_ID_ILBC)
+ avctx->block_align = out_format.mBytesPerPacket;
+ }
+
+ at->frame_size = avctx->frame_size;
+ if (avctx->codec_id == AV_CODEC_ID_PCM_MULAW ||
+ avctx->codec_id == AV_CODEC_ID_PCM_ALAW) {
+ at->pkt_size *= 1024;
+ avctx->frame_size *= 1024;
+ }
+}
+
+static int read_descr(GetByteContext *gb, int *tag)
+{
+ int len = 0;
+ int count = 4;
+ *tag = bytestream2_get_byte(gb);
+ while (count--) {
+ int c = bytestream2_get_byte(gb);
+ len = (len << 7) | (c & 0x7f);
+ if (!(c & 0x80))
+ break;
+ }
+ return len;
+}
+
+static int get_ilbc_mode(AVCodecContext *avctx)
+{
+ if (avctx->block_align == 38)
+ return 20;
+ else if (avctx->block_align == 50)
+ return 30;
+ else if (avctx->bit_rate > 0)
+ return avctx->bit_rate <= 14000 ? 30 : 20;
+ else
+ return 30;
+}
+
+static av_cold int get_channel_label(int channel)
+{
+ uint64_t map = 1 << channel;
+ if (map <= AV_CH_LOW_FREQUENCY)
+ return channel + 1;
+ else if (map <= AV_CH_BACK_RIGHT)
+ return channel + 29;
+ else if (map <= AV_CH_BACK_CENTER)
+ return channel - 1;
+ else if (map <= AV_CH_SIDE_RIGHT)
+ return channel - 4;
+ else if (map <= AV_CH_TOP_BACK_RIGHT)
+ return channel + 1;
+ else if (map <= AV_CH_STEREO_RIGHT)
+ return -1;
+ else if (map <= AV_CH_WIDE_RIGHT)
+ return channel + 4;
+ else if (map <= AV_CH_SURROUND_DIRECT_RIGHT)
+ return channel - 23;
+ else if (map == AV_CH_LOW_FREQUENCY_2)
+ return kAudioChannelLabel_LFE2;
+ else
+ return -1;
+}
+
+static int remap_layout(AudioChannelLayout *layout, uint64_t in_layout, int count)
+{
+ int i;
+ int c = 0;
+ layout->mChannelLayoutTag = kAudioChannelLayoutTag_UseChannelDescriptions;
+ layout->mNumberChannelDescriptions = count;
+ for (i = 0; i < count; i++) {
+ int label;
+ while (!(in_layout & (1 << c)) && c < 64)
+ c++;
+ if (c == 64)
+ return AVERROR(EINVAL); // This should never happen
+ label = get_channel_label(c);
+ layout->mChannelDescriptions[i].mChannelLabel = label;
+ if (label < 0)
+ return AVERROR(EINVAL);
+ c++;
+ }
+ return 0;
+}
+
+static int get_aac_tag(uint64_t in_layout)
+{
+ switch (in_layout) {
+ case AV_CH_LAYOUT_MONO:
+ return kAudioChannelLayoutTag_Mono;
+ case AV_CH_LAYOUT_STEREO:
+ return kAudioChannelLayoutTag_Stereo;
+ case AV_CH_LAYOUT_QUAD:
+ return kAudioChannelLayoutTag_AAC_Quadraphonic;
+ case AV_CH_LAYOUT_OCTAGONAL:
+ return kAudioChannelLayoutTag_AAC_Octagonal;
+ case AV_CH_LAYOUT_SURROUND:
+ return kAudioChannelLayoutTag_AAC_3_0;
+ case AV_CH_LAYOUT_4POINT0:
+ return kAudioChannelLayoutTag_AAC_4_0;
+ case AV_CH_LAYOUT_5POINT0:
+ return kAudioChannelLayoutTag_AAC_5_0;
+ case AV_CH_LAYOUT_5POINT1:
+ return kAudioChannelLayoutTag_AAC_5_1;
+ case AV_CH_LAYOUT_6POINT0:
+ return kAudioChannelLayoutTag_AAC_6_0;
+ case AV_CH_LAYOUT_6POINT1:
+ return kAudioChannelLayoutTag_AAC_6_1;
+ case AV_CH_LAYOUT_7POINT0:
+ return kAudioChannelLayoutTag_AAC_7_0;
+ case AV_CH_LAYOUT_7POINT1_WIDE_BACK:
+ return kAudioChannelLayoutTag_AAC_7_1;
+ case AV_CH_LAYOUT_7POINT1:
+ return kAudioChannelLayoutTag_MPEG_7_1_C;
+ default:
+ return 0;
+ }
+}
+
+static av_cold int ffat_init_encoder(AVCodecContext *avctx)
+{
+ ATDecodeContext *at = avctx->priv_data;
+ OSStatus status;
+
+ AudioStreamBasicDescription in_format = {
+ .mSampleRate = avctx->sample_rate,
+ .mFormatID = kAudioFormatLinearPCM,
+ .mFormatFlags = ((avctx->sample_fmt == AV_SAMPLE_FMT_FLT ||
+ avctx->sample_fmt == AV_SAMPLE_FMT_DBL) ? kAudioFormatFlagIsFloat
+ : avctx->sample_fmt == AV_SAMPLE_FMT_U8 ? 0
+ : kAudioFormatFlagIsSignedInteger)
+ | kAudioFormatFlagIsPacked,
+ .mBytesPerPacket = av_get_bytes_per_sample(avctx->sample_fmt) * avctx->channels,
+ .mFramesPerPacket = 1,
+ .mBytesPerFrame = av_get_bytes_per_sample(avctx->sample_fmt) * avctx->channels,
+ .mChannelsPerFrame = avctx->channels,
+ .mBitsPerChannel = av_get_bytes_per_sample(avctx->sample_fmt) * 8,
+ };
+ AudioStreamBasicDescription out_format = {
+ .mSampleRate = avctx->sample_rate,
+ .mFormatID = ffat_get_format_id(avctx->codec_id, avctx->profile),
+ .mChannelsPerFrame = in_format.mChannelsPerFrame,
+ };
+ UInt32 layout_size = sizeof(AudioChannelLayout) +
+ sizeof(AudioChannelDescription) * avctx->channels;
+ AudioChannelLayout *channel_layout = av_malloc(layout_size);
+
+ if (!channel_layout)
+ return AVERROR(ENOMEM);
+
+ if (avctx->codec_id == AV_CODEC_ID_ILBC) {
+ int mode = get_ilbc_mode(avctx);
+ out_format.mFramesPerPacket = 8000 * mode / 1000;
+ out_format.mBytesPerPacket = (mode == 20 ? 38 : 50);
+ }
+
+ status = AudioConverterNew(&in_format, &out_format, &at->converter);
+
+ if (status != 0) {
+ av_log(avctx, AV_LOG_ERROR, "AudioToolbox init error: %i\n", (int)status);
+ av_free(channel_layout);
+ return AVERROR_UNKNOWN;
+ }
+
+ if (!avctx->channel_layout)
+ avctx->channel_layout = av_get_default_channel_layout(avctx->channels);
+
+ if ((status = remap_layout(channel_layout, avctx->channel_layout, avctx->channels)) < 0) {
+ av_log(avctx, AV_LOG_ERROR, "Invalid channel layout\n");
+ av_free(channel_layout);
+ return status;
+ }
+
+ if (AudioConverterSetProperty(at->converter, kAudioConverterInputChannelLayout,
+ layout_size, channel_layout)) {
+ av_log(avctx, AV_LOG_ERROR, "Unsupported input channel layout\n");
+ av_free(channel_layout);
+ return AVERROR(EINVAL);
+ }
+ if (avctx->codec_id == AV_CODEC_ID_AAC) {
+ int tag = get_aac_tag(avctx->channel_layout);
+ if (tag) {
+ channel_layout->mChannelLayoutTag = tag;
+ channel_layout->mNumberChannelDescriptions = 0;
+ }
+ }
+ if (AudioConverterSetProperty(at->converter, kAudioConverterOutputChannelLayout,
+ layout_size, channel_layout)) {
+ av_log(avctx, AV_LOG_ERROR, "Unsupported output channel layout\n");
+ av_free(channel_layout);
+ return AVERROR(EINVAL);
+ }
+ av_free(channel_layout);
+
+ if (avctx->bits_per_raw_sample)
+ AudioConverterSetProperty(at->converter,
+ kAudioConverterPropertyBitDepthHint,
+ sizeof(avctx->bits_per_raw_sample),
+ &avctx->bits_per_raw_sample);
+
+#if !TARGET_OS_IPHONE
+ if (at->mode == -1)
+ at->mode = (avctx->flags & AV_CODEC_FLAG_QSCALE) ?
+ kAudioCodecBitRateControlMode_Variable :
+ kAudioCodecBitRateControlMode_Constant;
+
+ AudioConverterSetProperty(at->converter, kAudioCodecPropertyBitRateControlMode,
+ sizeof(at->mode), &at->mode);
+
+ if (at->mode == kAudioCodecBitRateControlMode_Variable) {
+ int q = avctx->global_quality / FF_QP2LAMBDA;
+ if (q < 0 || q > 14) {
+ av_log(avctx, AV_LOG_WARNING,
+ "VBR quality %d out of range, should be 0-14\n", q);
+ q = av_clip(q, 0, 14);
+ }
+ q = 127 - q * 9;
+ AudioConverterSetProperty(at->converter, kAudioCodecPropertySoundQualityForVBR,
+ sizeof(q), &q);
+ } else
+#endif
+ if (avctx->bit_rate > 0) {
+ UInt32 rate = avctx->bit_rate;
+ UInt32 size;
+ status = AudioConverterGetPropertyInfo(at->converter,
+ kAudioConverterApplicableEncodeBitRates,
+ &size, NULL);
+ if (!status && size) {
+ UInt32 new_rate = rate;
+ int count;
+ int i;
+ AudioValueRange *ranges = av_malloc(size);
+ if (!ranges)
+ return AVERROR(ENOMEM);
+ AudioConverterGetProperty(at->converter,
+ kAudioConverterApplicableEncodeBitRates,
+ &size, ranges);
+ count = size / sizeof(AudioValueRange);
+ for (i = 0; i < count; i++) {
+ AudioValueRange *range = &ranges[i];
+ if (rate >= range->mMinimum && rate <= range->mMaximum) {
+ new_rate = rate;
+ break;
+ } else if (rate > range->mMaximum) {
+ new_rate = range->mMaximum;
+ } else {
+ new_rate = range->mMinimum;
+ break;
+ }
+ }
+ if (new_rate != rate) {
+ av_log(avctx, AV_LOG_WARNING,
+ "Bitrate %u not allowed; changing to %u\n", rate, new_rate);
+ rate = new_rate;
+ }
+ av_free(ranges);
+ }
+ AudioConverterSetProperty(at->converter, kAudioConverterEncodeBitRate,
+ sizeof(rate), &rate);
+ }
+
+ at->quality = 96 - at->quality * 32;
+ AudioConverterSetProperty(at->converter, kAudioConverterCodecQuality,
+ sizeof(at->quality), &at->quality);
+
+ if (!AudioConverterGetPropertyInfo(at->converter, kAudioConverterCompressionMagicCookie,
+ &avctx->extradata_size, NULL) &&
+ avctx->extradata_size) {
+ int extradata_size = avctx->extradata_size;
+ uint8_t *extradata;
+ if (!(avctx->extradata = av_mallocz(avctx->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE)))
+ return AVERROR(ENOMEM);
+ if (avctx->codec_id == AV_CODEC_ID_ALAC) {
+ avctx->extradata_size = 0x24;
+ AV_WB32(avctx->extradata, 0x24);
+ AV_WB32(avctx->extradata + 4, MKBETAG('a','l','a','c'));
+ extradata = avctx->extradata + 12;
+ avctx->extradata_size = 0x24;
+ } else {
+ extradata = avctx->extradata;
+ }
+ status = AudioConverterGetProperty(at->converter,
+ kAudioConverterCompressionMagicCookie,
+ &extradata_size, extradata);
+ if (status != 0) {
+ av_log(avctx, AV_LOG_ERROR, "AudioToolbox cookie error: %i\n", (int)status);
+ return AVERROR_UNKNOWN;
+ } else if (avctx->codec_id == AV_CODEC_ID_AAC) {
+ GetByteContext gb;
+ int tag, len;
+ bytestream2_init(&gb, extradata, extradata_size);
+ do {
+ len = read_descr(&gb, &tag);
+ if (tag == MP4DecConfigDescrTag) {
+ bytestream2_skip(&gb, 13);
+ len = read_descr(&gb, &tag);
+ if (tag == MP4DecSpecificDescrTag) {
+ len = FFMIN(gb.buffer_end - gb.buffer, len);
+ memmove(extradata, gb.buffer, len);
+ avctx->extradata_size = len;
+ break;
+ }
+ } else if (tag == MP4ESDescrTag) {
+ int flags;
+ bytestream2_skip(&gb, 2);
+ flags = bytestream2_get_byte(&gb);
+ if (flags & 0x80) //streamDependenceFlag
+ bytestream2_skip(&gb, 2);
+ if (flags & 0x40) //URL_Flag
+ bytestream2_skip(&gb, bytestream2_get_byte(&gb));
+ if (flags & 0x20) //OCRstreamFlag
+ bytestream2_skip(&gb, 2);
+ }
+ } while (bytestream2_get_bytes_left(&gb));
+ } else if (avctx->codec_id != AV_CODEC_ID_ALAC) {
+ avctx->extradata_size = extradata_size;
+ }
+ }
+
+ ffat_update_ctx(avctx);
+
+#if !TARGET_OS_IPHONE && defined(__MAC_10_9)
+ if (at->mode == kAudioCodecBitRateControlMode_Variable && avctx->rc_max_rate) {
+ UInt32 max_size = avctx->rc_max_rate * avctx->frame_size / avctx->sample_rate;
+ if (max_size)
+ AudioConverterSetProperty(at->converter, kAudioCodecPropertyPacketSizeLimitForVBR,
+ sizeof(max_size), &max_size);
+ }
+#endif
+
+ ff_af_queue_init(avctx, &at->afq);
+
+ at->encoding_frame = av_frame_alloc();
+ if (!at->encoding_frame)
+ return AVERROR(ENOMEM);
+
+ return 0;
+}
+
+static OSStatus ffat_encode_callback(AudioConverterRef converter, UInt32 *nb_packets,
+ AudioBufferList *data,
+ AudioStreamPacketDescription **packets,
+ void *inctx)
+{
+ AVCodecContext *avctx = inctx;
+ ATDecodeContext *at = avctx->priv_data;
+ AVFrame *frame;
+ int ret;
+
+ if (!at->frame_queue.available) {
+ if (at->eof) {
+ *nb_packets = 0;
+ return 0;
+ } else {
+ *nb_packets = 0;
+ return 1;
+ }
+ }
+
+ frame = ff_bufqueue_get(&at->frame_queue);
+
+ data->mNumberBuffers = 1;
+ data->mBuffers[0].mNumberChannels = avctx->channels;
+ data->mBuffers[0].mDataByteSize = frame->nb_samples *
+ av_get_bytes_per_sample(avctx->sample_fmt) *
+ avctx->channels;
+ data->mBuffers[0].mData = frame->data[0];
+ if (*nb_packets > frame->nb_samples)
+ *nb_packets = frame->nb_samples;
+
+ av_frame_unref(at->encoding_frame);
+ ret = av_frame_ref(at->encoding_frame, frame);
+ if (ret < 0) {
+ *nb_packets = 0;
+ return ret;
+ }
+
+ ff_bufqueue_add(avctx, &at->used_frame_queue, frame);
+
+ return 0;
+}
+
+static int ffat_encode(AVCodecContext *avctx, AVPacket *avpkt,
+ const AVFrame *frame, int *got_packet_ptr)
+{
+ ATDecodeContext *at = avctx->priv_data;
+ OSStatus ret;
+
+ AudioBufferList out_buffers = {
+ .mNumberBuffers = 1,
+ .mBuffers = {
+ {
+ .mNumberChannels = avctx->channels,
+ .mDataByteSize = at->pkt_size,
+ }
+ }
+ };
+ AudioStreamPacketDescription out_pkt_desc = {0};
+
+ if (frame) {
+ AVFrame *in_frame;
+
+ if (ff_bufqueue_is_full(&at->frame_queue)) {
+ /*
+ * The frame queue is significantly larger than needed in practice,
+ * but no clear way to determine the minimum number of samples to
+ * get output from AudioConverterFillComplexBuffer().
+ */
+ av_log(avctx, AV_LOG_ERROR, "Bug: frame queue is too small.\n");
+ return AVERROR_BUG;
+ }
+
+ if ((ret = ff_af_queue_add(&at->afq, frame)) < 0)
+ return ret;
+
+ in_frame = av_frame_clone(frame);
+ if (!in_frame)
+ return AVERROR(ENOMEM);
+
+ ff_bufqueue_add(avctx, &at->frame_queue, in_frame);
+ } else {
+ at->eof = 1;
+ }
+
+ if ((ret = ff_alloc_packet2(avctx, avpkt, at->pkt_size, 0)) < 0)
+ return ret;
+
+
+ out_buffers.mBuffers[0].mData = avpkt->data;
+
+ *got_packet_ptr = avctx->frame_size / at->frame_size;
+
+ ret = AudioConverterFillComplexBuffer(at->converter, ffat_encode_callback, avctx,
+ got_packet_ptr, &out_buffers,
+ (avctx->frame_size > at->frame_size) ? NULL : &out_pkt_desc);
+
+ ff_bufqueue_discard_all(&at->used_frame_queue);
+
+ if ((!ret || ret == 1) && *got_packet_ptr) {
+ avpkt->size = out_buffers.mBuffers[0].mDataByteSize;
+ ff_af_queue_remove(&at->afq, out_pkt_desc.mVariableFramesInPacket ?
+ out_pkt_desc.mVariableFramesInPacket :
+ avctx->frame_size,
+ &avpkt->pts,
+ &avpkt->duration);
+ } else if (ret && ret != 1) {
+ av_log(avctx, AV_LOG_WARNING, "Encode error: %i\n", ret);
+ }
+
+ return 0;
+}
+
+static av_cold void ffat_encode_flush(AVCodecContext *avctx)
+{
+ ATDecodeContext *at = avctx->priv_data;
+ AudioConverterReset(at->converter);
+ ff_bufqueue_discard_all(&at->frame_queue);
+ ff_bufqueue_discard_all(&at->used_frame_queue);
+}
+
+static av_cold int ffat_close_encoder(AVCodecContext *avctx)
+{
+ ATDecodeContext *at = avctx->priv_data;
+ AudioConverterDispose(at->converter);
+ ff_bufqueue_discard_all(&at->frame_queue);
+ ff_bufqueue_discard_all(&at->used_frame_queue);
+ ff_af_queue_close(&at->afq);
+ av_frame_free(&at->encoding_frame);
+ return 0;
+}
+
+static const AVProfile aac_profiles[] = {
+ { FF_PROFILE_AAC_LOW, "LC" },
+ { FF_PROFILE_AAC_HE, "HE-AAC" },
+ { FF_PROFILE_AAC_HE_V2, "HE-AACv2" },
+ { FF_PROFILE_AAC_LD, "LD" },
+ { FF_PROFILE_AAC_ELD, "ELD" },
+ { FF_PROFILE_UNKNOWN },
+};
+
+#define AE AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
+static const AVOption options[] = {
+#if !TARGET_OS_IPHONE
+ {"aac_at_mode", "ratecontrol mode", offsetof(ATDecodeContext, mode), AV_OPT_TYPE_INT, {.i64 = -1}, -1, kAudioCodecBitRateControlMode_Variable, AE, "mode"},
+ {"auto", "VBR if global quality is given; CBR otherwise", 0, AV_OPT_TYPE_CONST, {.i64 = -1}, INT_MIN, INT_MAX, AE, "mode"},
+ {"cbr", "constant bitrate", 0, AV_OPT_TYPE_CONST, {.i64 = kAudioCodecBitRateControlMode_Constant}, INT_MIN, INT_MAX, AE, "mode"},
+ {"abr", "long-term average bitrate", 0, AV_OPT_TYPE_CONST, {.i64 = kAudioCodecBitRateControlMode_LongTermAverage}, INT_MIN, INT_MAX, AE, "mode"},
+ {"cvbr", "constrained variable bitrate", 0, AV_OPT_TYPE_CONST, {.i64 = kAudioCodecBitRateControlMode_VariableConstrained}, INT_MIN, INT_MAX, AE, "mode"},
+ {"vbr" , "variable bitrate", 0, AV_OPT_TYPE_CONST, {.i64 = kAudioCodecBitRateControlMode_Variable}, INT_MIN, INT_MAX, AE, "mode"},
+#endif
+ {"aac_at_quality", "quality vs speed control", offsetof(ATDecodeContext, quality), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 2, AE},
+ { NULL },
+};
+
+#define FFAT_ENC_CLASS(NAME) \
+ static const AVClass ffat_##NAME##_enc_class = { \
+ .class_name = "at_" #NAME "_enc", \
+ .item_name = av_default_item_name, \
+ .option = options, \
+ .version = LIBAVUTIL_VERSION_INT, \
+ };
+
+#define FFAT_ENC(NAME, ID, PROFILES, ...) \
+ FFAT_ENC_CLASS(NAME) \
+ AVCodec ff_##NAME##_at_encoder = { \
+ .name = #NAME "_at", \
+ .long_name = NULL_IF_CONFIG_SMALL(#NAME " (AudioToolbox)"), \
+ .type = AVMEDIA_TYPE_AUDIO, \
+ .id = ID, \
+ .priv_data_size = sizeof(ATDecodeContext), \
+ .init = ffat_init_encoder, \
+ .close = ffat_close_encoder, \
+ .encode2 = ffat_encode, \
+ .flush = ffat_encode_flush, \
+ .priv_class = &ffat_##NAME##_enc_class, \
+ .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY __VA_ARGS__, \
+ .sample_fmts = (const enum AVSampleFormat[]) { \
+ AV_SAMPLE_FMT_S16, \
+ AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_NONE \
+ }, \
+ .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE, \
+ .profiles = PROFILES, \
+ .wrapper_name = "at", \
+ };
+
+static const uint64_t aac_at_channel_layouts[] = {
+ AV_CH_LAYOUT_MONO,
+ AV_CH_LAYOUT_STEREO,
+ AV_CH_LAYOUT_SURROUND,
+ AV_CH_LAYOUT_4POINT0,
+ AV_CH_LAYOUT_5POINT0,
+ AV_CH_LAYOUT_5POINT1,
+ AV_CH_LAYOUT_6POINT0,
+ AV_CH_LAYOUT_6POINT1,
+ AV_CH_LAYOUT_7POINT0,
+ AV_CH_LAYOUT_7POINT1_WIDE_BACK,
+ AV_CH_LAYOUT_QUAD,
+ AV_CH_LAYOUT_OCTAGONAL,
+ 0,
+};
+
+FFAT_ENC(aac, AV_CODEC_ID_AAC, aac_profiles, , .channel_layouts = aac_at_channel_layouts)
+//FFAT_ENC(adpcm_ima_qt, AV_CODEC_ID_ADPCM_IMA_QT, NULL)
+FFAT_ENC(alac, AV_CODEC_ID_ALAC, NULL, | AV_CODEC_CAP_VARIABLE_FRAME_SIZE | AV_CODEC_CAP_LOSSLESS)
+FFAT_ENC(ilbc, AV_CODEC_ID_ILBC, NULL)
+FFAT_ENC(pcm_alaw, AV_CODEC_ID_PCM_ALAW, NULL)
+FFAT_ENC(pcm_mulaw, AV_CODEC_ID_PCM_MULAW, NULL)
OpenPOWER on IntegriCloud