avcodec/pnm: Avoid structure pointer dereferences in inner loop in pnm_get()
[ffmpeg.git] / libavcodec / audiotoolboxenc.c
1 /*
2  * Audio Toolbox system codecs
3  *
4  * copyright (c) 2016 Rodger Combs
5  *
6  * This file is part of FFmpeg.
7  *
8  * FFmpeg is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * FFmpeg is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with FFmpeg; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22
23 #include <AudioToolbox/AudioToolbox.h>
24
25 #define FF_BUFQUEUE_SIZE 256
26 #include "libavfilter/bufferqueue.h"
27
28 #include "config.h"
29 #include "audio_frame_queue.h"
30 #include "avcodec.h"
31 #include "bytestream.h"
32 #include "internal.h"
33 #include "libavformat/isom.h"
34 #include "libavutil/avassert.h"
35 #include "libavutil/opt.h"
36 #include "libavutil/log.h"
37
38 typedef struct ATDecodeContext {
39     AVClass *av_class;
40     int mode;
41     int quality;
42
43     AudioConverterRef converter;
44     struct FFBufQueue frame_queue;
45     struct FFBufQueue used_frame_queue;
46
47     unsigned pkt_size;
48     AudioFrameQueue afq;
49     int eof;
50     int frame_size;
51
52     AVFrame* encoding_frame;
53 } ATDecodeContext;
54
55 static UInt32 ffat_get_format_id(enum AVCodecID codec, int profile)
56 {
57     switch (codec) {
58     case AV_CODEC_ID_AAC:
59         switch (profile) {
60         case FF_PROFILE_AAC_LOW:
61         default:
62             return kAudioFormatMPEG4AAC;
63         case FF_PROFILE_AAC_HE:
64             return kAudioFormatMPEG4AAC_HE;
65         case FF_PROFILE_AAC_HE_V2:
66             return kAudioFormatMPEG4AAC_HE_V2;
67         case FF_PROFILE_AAC_LD:
68             return kAudioFormatMPEG4AAC_LD;
69         case FF_PROFILE_AAC_ELD:
70             return kAudioFormatMPEG4AAC_ELD;
71         }
72     case AV_CODEC_ID_ADPCM_IMA_QT:
73         return kAudioFormatAppleIMA4;
74     case AV_CODEC_ID_ALAC:
75         return kAudioFormatAppleLossless;
76     case AV_CODEC_ID_ILBC:
77         return kAudioFormatiLBC;
78     case AV_CODEC_ID_PCM_ALAW:
79         return kAudioFormatALaw;
80     case AV_CODEC_ID_PCM_MULAW:
81         return kAudioFormatULaw;
82     default:
83         av_assert0(!"Invalid codec ID!");
84         return 0;
85     }
86 }
87
88 static void ffat_update_ctx(AVCodecContext *avctx)
89 {
90     ATDecodeContext *at = avctx->priv_data;
91     UInt32 size = sizeof(unsigned);
92     AudioConverterPrimeInfo prime_info;
93     AudioStreamBasicDescription out_format;
94
95     AudioConverterGetProperty(at->converter,
96                               kAudioConverterPropertyMaximumOutputPacketSize,
97                               &size, &at->pkt_size);
98
99     if (at->pkt_size <= 0)
100         at->pkt_size = 1024 * 50;
101
102     size = sizeof(prime_info);
103
104     if (!AudioConverterGetProperty(at->converter,
105                                    kAudioConverterPrimeInfo,
106                                    &size, &prime_info)) {
107         avctx->initial_padding = prime_info.leadingFrames;
108     }
109
110     size = sizeof(out_format);
111     if (!AudioConverterGetProperty(at->converter,
112                                    kAudioConverterCurrentOutputStreamDescription,
113                                    &size, &out_format)) {
114         if (out_format.mFramesPerPacket)
115             avctx->frame_size = out_format.mFramesPerPacket;
116         if (out_format.mBytesPerPacket && avctx->codec_id == AV_CODEC_ID_ILBC)
117             avctx->block_align = out_format.mBytesPerPacket;
118     }
119
120     at->frame_size = avctx->frame_size;
121     if (avctx->codec_id == AV_CODEC_ID_PCM_MULAW ||
122         avctx->codec_id == AV_CODEC_ID_PCM_ALAW) {
123         at->pkt_size *= 1024;
124         avctx->frame_size *= 1024;
125     }
126 }
127
128 static int read_descr(GetByteContext *gb, int *tag)
129 {
130     int len = 0;
131     int count = 4;
132     *tag = bytestream2_get_byte(gb);
133     while (count--) {
134         int c = bytestream2_get_byte(gb);
135         len = (len << 7) | (c & 0x7f);
136         if (!(c & 0x80))
137             break;
138     }
139     return len;
140 }
141
142 static int get_ilbc_mode(AVCodecContext *avctx)
143 {
144     if (avctx->block_align == 38)
145         return 20;
146     else if (avctx->block_align == 50)
147         return 30;
148     else if (avctx->bit_rate > 0)
149         return avctx->bit_rate <= 14000 ? 30 : 20;
150     else
151         return 30;
152 }
153
154 static av_cold int get_channel_label(int channel)
155 {
156     uint64_t map = 1 << channel;
157     if (map <= AV_CH_LOW_FREQUENCY)
158         return channel + 1;
159     else if (map <= AV_CH_BACK_RIGHT)
160         return channel + 29;
161     else if (map <= AV_CH_BACK_CENTER)
162         return channel - 1;
163     else if (map <= AV_CH_SIDE_RIGHT)
164         return channel - 4;
165     else if (map <= AV_CH_TOP_BACK_RIGHT)
166         return channel + 1;
167     else if (map <= AV_CH_STEREO_RIGHT)
168         return -1;
169     else if (map <= AV_CH_WIDE_RIGHT)
170         return channel + 4;
171     else if (map <= AV_CH_SURROUND_DIRECT_RIGHT)
172         return channel - 23;
173     else if (map == AV_CH_LOW_FREQUENCY_2)
174         return kAudioChannelLabel_LFE2;
175     else
176         return -1;
177 }
178
179 static int remap_layout(AudioChannelLayout *layout, uint64_t in_layout, int count)
180 {
181     int i;
182     int c = 0;
183     layout->mChannelLayoutTag = kAudioChannelLayoutTag_UseChannelDescriptions;
184     layout->mNumberChannelDescriptions = count;
185     for (i = 0; i < count; i++) {
186         int label;
187         while (!(in_layout & (1 << c)) && c < 64)
188             c++;
189         if (c == 64)
190             return AVERROR(EINVAL); // This should never happen
191         label = get_channel_label(c);
192         layout->mChannelDescriptions[i].mChannelLabel = label;
193         if (label < 0)
194             return AVERROR(EINVAL);
195         c++;
196     }
197     return 0;
198 }
199
200 static int get_aac_tag(uint64_t in_layout)
201 {
202     switch (in_layout) {
203     case AV_CH_LAYOUT_MONO:
204         return kAudioChannelLayoutTag_Mono;
205     case AV_CH_LAYOUT_STEREO:
206         return kAudioChannelLayoutTag_Stereo;
207     case AV_CH_LAYOUT_QUAD:
208         return kAudioChannelLayoutTag_AAC_Quadraphonic;
209     case AV_CH_LAYOUT_OCTAGONAL:
210         return kAudioChannelLayoutTag_AAC_Octagonal;
211     case AV_CH_LAYOUT_SURROUND:
212         return kAudioChannelLayoutTag_AAC_3_0;
213     case AV_CH_LAYOUT_4POINT0:
214         return kAudioChannelLayoutTag_AAC_4_0;
215     case AV_CH_LAYOUT_5POINT0:
216         return kAudioChannelLayoutTag_AAC_5_0;
217     case AV_CH_LAYOUT_5POINT1:
218         return kAudioChannelLayoutTag_AAC_5_1;
219     case AV_CH_LAYOUT_6POINT0:
220         return kAudioChannelLayoutTag_AAC_6_0;
221     case AV_CH_LAYOUT_6POINT1:
222         return kAudioChannelLayoutTag_AAC_6_1;
223     case AV_CH_LAYOUT_7POINT0:
224         return kAudioChannelLayoutTag_AAC_7_0;
225     case AV_CH_LAYOUT_7POINT1_WIDE_BACK:
226         return kAudioChannelLayoutTag_AAC_7_1;
227     case AV_CH_LAYOUT_7POINT1:
228         return kAudioChannelLayoutTag_MPEG_7_1_C;
229     default:
230         return 0;
231     }
232 }
233
234 static av_cold int ffat_init_encoder(AVCodecContext *avctx)
235 {
236     ATDecodeContext *at = avctx->priv_data;
237     OSStatus status;
238
239     AudioStreamBasicDescription in_format = {
240         .mSampleRate = avctx->sample_rate,
241         .mFormatID = kAudioFormatLinearPCM,
242         .mFormatFlags = ((avctx->sample_fmt == AV_SAMPLE_FMT_FLT ||
243                           avctx->sample_fmt == AV_SAMPLE_FMT_DBL) ? kAudioFormatFlagIsFloat
244                         : avctx->sample_fmt == AV_SAMPLE_FMT_U8 ? 0
245                         : kAudioFormatFlagIsSignedInteger)
246                         | kAudioFormatFlagIsPacked,
247         .mBytesPerPacket = av_get_bytes_per_sample(avctx->sample_fmt) * avctx->channels,
248         .mFramesPerPacket = 1,
249         .mBytesPerFrame = av_get_bytes_per_sample(avctx->sample_fmt) * avctx->channels,
250         .mChannelsPerFrame = avctx->channels,
251         .mBitsPerChannel = av_get_bytes_per_sample(avctx->sample_fmt) * 8,
252     };
253     AudioStreamBasicDescription out_format = {
254         .mSampleRate = avctx->sample_rate,
255         .mFormatID = ffat_get_format_id(avctx->codec_id, avctx->profile),
256         .mChannelsPerFrame = in_format.mChannelsPerFrame,
257     };
258     UInt32 layout_size = sizeof(AudioChannelLayout) +
259                          sizeof(AudioChannelDescription) * avctx->channels;
260     AudioChannelLayout *channel_layout = av_malloc(layout_size);
261
262     if (!channel_layout)
263         return AVERROR(ENOMEM);
264
265     if (avctx->codec_id == AV_CODEC_ID_ILBC) {
266         int mode = get_ilbc_mode(avctx);
267         out_format.mFramesPerPacket  = 8000 * mode / 1000;
268         out_format.mBytesPerPacket   = (mode == 20 ? 38 : 50);
269     }
270
271     status = AudioConverterNew(&in_format, &out_format, &at->converter);
272
273     if (status != 0) {
274         av_log(avctx, AV_LOG_ERROR, "AudioToolbox init error: %i\n", (int)status);
275         av_free(channel_layout);
276         return AVERROR_UNKNOWN;
277     }
278
279     if (!avctx->channel_layout)
280         avctx->channel_layout = av_get_default_channel_layout(avctx->channels);
281
282     if ((status = remap_layout(channel_layout, avctx->channel_layout, avctx->channels)) < 0) {
283         av_log(avctx, AV_LOG_ERROR, "Invalid channel layout\n");
284         av_free(channel_layout);
285         return status;
286     }
287
288     if (AudioConverterSetProperty(at->converter, kAudioConverterInputChannelLayout,
289                                   layout_size, channel_layout)) {
290         av_log(avctx, AV_LOG_ERROR, "Unsupported input channel layout\n");
291         av_free(channel_layout);
292         return AVERROR(EINVAL);
293     }
294     if (avctx->codec_id == AV_CODEC_ID_AAC) {
295         int tag = get_aac_tag(avctx->channel_layout);
296         if (tag) {
297             channel_layout->mChannelLayoutTag = tag;
298             channel_layout->mNumberChannelDescriptions = 0;
299         }
300     }
301     if (AudioConverterSetProperty(at->converter, kAudioConverterOutputChannelLayout,
302                                   layout_size, channel_layout)) {
303         av_log(avctx, AV_LOG_ERROR, "Unsupported output channel layout\n");
304         av_free(channel_layout);
305         return AVERROR(EINVAL);
306     }
307     av_free(channel_layout);
308
309     if (avctx->bits_per_raw_sample)
310         AudioConverterSetProperty(at->converter,
311                                   kAudioConverterPropertyBitDepthHint,
312                                   sizeof(avctx->bits_per_raw_sample),
313                                   &avctx->bits_per_raw_sample);
314
315 #if !TARGET_OS_IPHONE
316     if (at->mode == -1)
317         at->mode = (avctx->flags & AV_CODEC_FLAG_QSCALE) ?
318                    kAudioCodecBitRateControlMode_Variable :
319                    kAudioCodecBitRateControlMode_Constant;
320
321     AudioConverterSetProperty(at->converter, kAudioCodecPropertyBitRateControlMode,
322                               sizeof(at->mode), &at->mode);
323
324     if (at->mode == kAudioCodecBitRateControlMode_Variable) {
325         int q = avctx->global_quality / FF_QP2LAMBDA;
326         if (q < 0 || q > 14) {
327             av_log(avctx, AV_LOG_WARNING,
328                    "VBR quality %d out of range, should be 0-14\n", q);
329             q = av_clip(q, 0, 14);
330         }
331         q = 127 - q * 9;
332         AudioConverterSetProperty(at->converter, kAudioCodecPropertySoundQualityForVBR,
333                                   sizeof(q), &q);
334     } else
335 #endif
336     if (avctx->bit_rate > 0) {
337         UInt32 rate = avctx->bit_rate;
338         UInt32 size;
339         status = AudioConverterGetPropertyInfo(at->converter,
340                                                kAudioConverterApplicableEncodeBitRates,
341                                                &size, NULL);
342         if (!status && size) {
343             UInt32 new_rate = rate;
344             int count;
345             int i;
346             AudioValueRange *ranges = av_malloc(size);
347             if (!ranges)
348                 return AVERROR(ENOMEM);
349             AudioConverterGetProperty(at->converter,
350                                       kAudioConverterApplicableEncodeBitRates,
351                                       &size, ranges);
352             count = size / sizeof(AudioValueRange);
353             for (i = 0; i < count; i++) {
354                 AudioValueRange *range = &ranges[i];
355                 if (rate >= range->mMinimum && rate <= range->mMaximum) {
356                     new_rate = rate;
357                     break;
358                 } else if (rate > range->mMaximum) {
359                     new_rate = range->mMaximum;
360                 } else {
361                     new_rate = range->mMinimum;
362                     break;
363                 }
364             }
365             if (new_rate != rate) {
366                 av_log(avctx, AV_LOG_WARNING,
367                        "Bitrate %u not allowed; changing to %u\n", rate, new_rate);
368                 rate = new_rate;
369             }
370             av_free(ranges);
371         }
372         AudioConverterSetProperty(at->converter, kAudioConverterEncodeBitRate,
373                                   sizeof(rate), &rate);
374     }
375
376     at->quality = 96 - at->quality * 32;
377     AudioConverterSetProperty(at->converter, kAudioConverterCodecQuality,
378                               sizeof(at->quality), &at->quality);
379
380     if (!AudioConverterGetPropertyInfo(at->converter, kAudioConverterCompressionMagicCookie,
381                                        &avctx->extradata_size, NULL) &&
382         avctx->extradata_size) {
383         int extradata_size = avctx->extradata_size;
384         uint8_t *extradata;
385         if (!(avctx->extradata = av_mallocz(avctx->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE)))
386             return AVERROR(ENOMEM);
387         if (avctx->codec_id == AV_CODEC_ID_ALAC) {
388             avctx->extradata_size = 0x24;
389             AV_WB32(avctx->extradata,     0x24);
390             AV_WB32(avctx->extradata + 4, MKBETAG('a','l','a','c'));
391             extradata = avctx->extradata + 12;
392             avctx->extradata_size = 0x24;
393         } else {
394             extradata = avctx->extradata;
395         }
396         status = AudioConverterGetProperty(at->converter,
397                                            kAudioConverterCompressionMagicCookie,
398                                            &extradata_size, extradata);
399         if (status != 0) {
400             av_log(avctx, AV_LOG_ERROR, "AudioToolbox cookie error: %i\n", (int)status);
401             return AVERROR_UNKNOWN;
402         } else if (avctx->codec_id == AV_CODEC_ID_AAC) {
403             GetByteContext gb;
404             int tag, len;
405             bytestream2_init(&gb, extradata, extradata_size);
406             do {
407                 len = read_descr(&gb, &tag);
408                 if (tag == MP4DecConfigDescrTag) {
409                     bytestream2_skip(&gb, 13);
410                     len = read_descr(&gb, &tag);
411                     if (tag == MP4DecSpecificDescrTag) {
412                         len = FFMIN(gb.buffer_end - gb.buffer, len);
413                         memmove(extradata, gb.buffer, len);
414                         avctx->extradata_size = len;
415                         break;
416                     }
417                 } else if (tag == MP4ESDescrTag) {
418                     int flags;
419                     bytestream2_skip(&gb, 2);
420                     flags = bytestream2_get_byte(&gb);
421                     if (flags & 0x80) //streamDependenceFlag
422                         bytestream2_skip(&gb, 2);
423                     if (flags & 0x40) //URL_Flag
424                         bytestream2_skip(&gb, bytestream2_get_byte(&gb));
425                     if (flags & 0x20) //OCRstreamFlag
426                         bytestream2_skip(&gb, 2);
427                 }
428             } while (bytestream2_get_bytes_left(&gb));
429         } else if (avctx->codec_id != AV_CODEC_ID_ALAC) {
430             avctx->extradata_size = extradata_size;
431         }
432     }
433
434     ffat_update_ctx(avctx);
435
436 #if !TARGET_OS_IPHONE && defined(__MAC_10_9)
437     if (at->mode == kAudioCodecBitRateControlMode_Variable && avctx->rc_max_rate) {
438         UInt32 max_size = avctx->rc_max_rate * avctx->frame_size / avctx->sample_rate;
439         if (max_size)
440             AudioConverterSetProperty(at->converter, kAudioCodecPropertyPacketSizeLimitForVBR,
441                                       sizeof(max_size), &max_size);
442     }
443 #endif
444
445     ff_af_queue_init(avctx, &at->afq);
446
447     at->encoding_frame = av_frame_alloc();
448     if (!at->encoding_frame)
449         return AVERROR(ENOMEM);
450
451     return 0;
452 }
453
454 static OSStatus ffat_encode_callback(AudioConverterRef converter, UInt32 *nb_packets,
455                                      AudioBufferList *data,
456                                      AudioStreamPacketDescription **packets,
457                                      void *inctx)
458 {
459     AVCodecContext *avctx = inctx;
460     ATDecodeContext *at = avctx->priv_data;
461     AVFrame *frame;
462     int ret;
463
464     if (!at->frame_queue.available) {
465         if (at->eof) {
466             *nb_packets = 0;
467             return 0;
468         } else {
469             *nb_packets = 0;
470             return 1;
471         }
472     }
473
474     frame = ff_bufqueue_get(&at->frame_queue);
475
476     data->mNumberBuffers              = 1;
477     data->mBuffers[0].mNumberChannels = avctx->channels;
478     data->mBuffers[0].mDataByteSize   = frame->nb_samples *
479                                         av_get_bytes_per_sample(avctx->sample_fmt) *
480                                         avctx->channels;
481     data->mBuffers[0].mData           = frame->data[0];
482     if (*nb_packets > frame->nb_samples)
483         *nb_packets = frame->nb_samples;
484
485     av_frame_unref(at->encoding_frame);
486     ret = av_frame_ref(at->encoding_frame, frame);
487     if (ret < 0) {
488         *nb_packets = 0;
489         return ret;
490     }
491
492     ff_bufqueue_add(avctx, &at->used_frame_queue, frame);
493
494     return 0;
495 }
496
497 static int ffat_encode(AVCodecContext *avctx, AVPacket *avpkt,
498                        const AVFrame *frame, int *got_packet_ptr)
499 {
500     ATDecodeContext *at = avctx->priv_data;
501     OSStatus ret;
502
503     AudioBufferList out_buffers = {
504         .mNumberBuffers = 1,
505         .mBuffers = {
506             {
507                 .mNumberChannels = avctx->channels,
508                 .mDataByteSize = at->pkt_size,
509             }
510         }
511     };
512     AudioStreamPacketDescription out_pkt_desc = {0};
513
514     if (frame) {
515         AVFrame *in_frame;
516
517         if (ff_bufqueue_is_full(&at->frame_queue)) {
518             /*
519              * The frame queue is significantly larger than needed in practice,
520              * but no clear way to determine the minimum number of samples to
521              * get output from AudioConverterFillComplexBuffer().
522              */
523             av_log(avctx, AV_LOG_ERROR, "Bug: frame queue is too small.\n");
524             return AVERROR_BUG;
525         }
526
527         if ((ret = ff_af_queue_add(&at->afq, frame)) < 0)
528             return ret;
529
530         in_frame = av_frame_clone(frame);
531         if (!in_frame)
532             return AVERROR(ENOMEM);
533
534         ff_bufqueue_add(avctx, &at->frame_queue, in_frame);
535     } else {
536         at->eof = 1;
537     }
538
539     if ((ret = ff_alloc_packet2(avctx, avpkt, at->pkt_size, 0)) < 0)
540         return ret;
541
542
543     out_buffers.mBuffers[0].mData = avpkt->data;
544
545     *got_packet_ptr = avctx->frame_size / at->frame_size;
546
547     ret = AudioConverterFillComplexBuffer(at->converter, ffat_encode_callback, avctx,
548                                           got_packet_ptr, &out_buffers,
549                                           (avctx->frame_size > at->frame_size) ? NULL : &out_pkt_desc);
550
551     ff_bufqueue_discard_all(&at->used_frame_queue);
552
553     if ((!ret || ret == 1) && *got_packet_ptr) {
554         avpkt->size = out_buffers.mBuffers[0].mDataByteSize;
555         ff_af_queue_remove(&at->afq, out_pkt_desc.mVariableFramesInPacket ?
556                                      out_pkt_desc.mVariableFramesInPacket :
557                                      avctx->frame_size,
558                            &avpkt->pts,
559                            &avpkt->duration);
560     } else if (ret && ret != 1) {
561         av_log(avctx, AV_LOG_WARNING, "Encode error: %i\n", ret);
562     }
563
564     return 0;
565 }
566
567 static av_cold void ffat_encode_flush(AVCodecContext *avctx)
568 {
569     ATDecodeContext *at = avctx->priv_data;
570     AudioConverterReset(at->converter);
571     ff_bufqueue_discard_all(&at->frame_queue);
572     ff_bufqueue_discard_all(&at->used_frame_queue);
573 }
574
575 static av_cold int ffat_close_encoder(AVCodecContext *avctx)
576 {
577     ATDecodeContext *at = avctx->priv_data;
578     AudioConverterDispose(at->converter);
579     ff_bufqueue_discard_all(&at->frame_queue);
580     ff_bufqueue_discard_all(&at->used_frame_queue);
581     ff_af_queue_close(&at->afq);
582     av_frame_free(&at->encoding_frame);
583     return 0;
584 }
585
586 static const AVProfile aac_profiles[] = {
587     { FF_PROFILE_AAC_LOW,   "LC"       },
588     { FF_PROFILE_AAC_HE,    "HE-AAC"   },
589     { FF_PROFILE_AAC_HE_V2, "HE-AACv2" },
590     { FF_PROFILE_AAC_LD,    "LD"       },
591     { FF_PROFILE_AAC_ELD,   "ELD"      },
592     { FF_PROFILE_UNKNOWN },
593 };
594
595 #define AE AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
596 static const AVOption options[] = {
597 #if !TARGET_OS_IPHONE
598     {"aac_at_mode", "ratecontrol mode", offsetof(ATDecodeContext, mode), AV_OPT_TYPE_INT, {.i64 = -1}, -1, kAudioCodecBitRateControlMode_Variable, AE, "mode"},
599         {"auto", "VBR if global quality is given; CBR otherwise", 0, AV_OPT_TYPE_CONST, {.i64 = -1}, INT_MIN, INT_MAX, AE, "mode"},
600         {"cbr",  "constant bitrate", 0, AV_OPT_TYPE_CONST, {.i64 = kAudioCodecBitRateControlMode_Constant}, INT_MIN, INT_MAX, AE, "mode"},
601         {"abr",  "long-term average bitrate", 0, AV_OPT_TYPE_CONST, {.i64 = kAudioCodecBitRateControlMode_LongTermAverage}, INT_MIN, INT_MAX, AE, "mode"},
602         {"cvbr", "constrained variable bitrate", 0, AV_OPT_TYPE_CONST, {.i64 = kAudioCodecBitRateControlMode_VariableConstrained}, INT_MIN, INT_MAX, AE, "mode"},
603         {"vbr" , "variable bitrate", 0, AV_OPT_TYPE_CONST, {.i64 = kAudioCodecBitRateControlMode_Variable}, INT_MIN, INT_MAX, AE, "mode"},
604 #endif
605     {"aac_at_quality", "quality vs speed control", offsetof(ATDecodeContext, quality), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 2, AE},
606     { NULL },
607 };
608
609 #define FFAT_ENC_CLASS(NAME) \
610     static const AVClass ffat_##NAME##_enc_class = { \
611         .class_name = "at_" #NAME "_enc", \
612         .item_name  = av_default_item_name, \
613         .option     = options, \
614         .version    = LIBAVUTIL_VERSION_INT, \
615     };
616
617 #define FFAT_ENC(NAME, ID, PROFILES, ...) \
618     FFAT_ENC_CLASS(NAME) \
619     AVCodec ff_##NAME##_at_encoder = { \
620         .name           = #NAME "_at", \
621         .long_name      = NULL_IF_CONFIG_SMALL(#NAME " (AudioToolbox)"), \
622         .type           = AVMEDIA_TYPE_AUDIO, \
623         .id             = ID, \
624         .priv_data_size = sizeof(ATDecodeContext), \
625         .init           = ffat_init_encoder, \
626         .close          = ffat_close_encoder, \
627         .encode2        = ffat_encode, \
628         .flush          = ffat_encode_flush, \
629         .priv_class     = &ffat_##NAME##_enc_class, \
630         .capabilities   = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY __VA_ARGS__, \
631         .sample_fmts    = (const enum AVSampleFormat[]) { \
632             AV_SAMPLE_FMT_S16, \
633             AV_SAMPLE_FMT_U8,  AV_SAMPLE_FMT_NONE \
634         }, \
635         .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE, \
636         .profiles       = PROFILES, \
637         .wrapper_name   = "at", \
638     };
639
640 static const uint64_t aac_at_channel_layouts[] = {
641     AV_CH_LAYOUT_MONO,
642     AV_CH_LAYOUT_STEREO,
643     AV_CH_LAYOUT_SURROUND,
644     AV_CH_LAYOUT_4POINT0,
645     AV_CH_LAYOUT_5POINT0,
646     AV_CH_LAYOUT_5POINT1,
647     AV_CH_LAYOUT_6POINT0,
648     AV_CH_LAYOUT_6POINT1,
649     AV_CH_LAYOUT_7POINT0,
650     AV_CH_LAYOUT_7POINT1_WIDE_BACK,
651     AV_CH_LAYOUT_QUAD,
652     AV_CH_LAYOUT_OCTAGONAL,
653     0,
654 };
655
656 FFAT_ENC(aac,          AV_CODEC_ID_AAC,          aac_profiles, , .channel_layouts = aac_at_channel_layouts)
657 //FFAT_ENC(adpcm_ima_qt, AV_CODEC_ID_ADPCM_IMA_QT, NULL)
658 FFAT_ENC(alac,         AV_CODEC_ID_ALAC,         NULL, | AV_CODEC_CAP_VARIABLE_FRAME_SIZE | AV_CODEC_CAP_LOSSLESS)
659 FFAT_ENC(ilbc,         AV_CODEC_ID_ILBC,         NULL)
660 FFAT_ENC(pcm_alaw,     AV_CODEC_ID_PCM_ALAW,     NULL)
661 FFAT_ENC(pcm_mulaw,    AV_CODEC_ID_PCM_MULAW,    NULL)