avcodec/idctdsp: Transmit studio_profile to init instead of using AVCodecContext...
[ffmpeg.git] / libavcodec / audiotoolboxdec.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 #include "config.h"
26 #include "avcodec.h"
27 #include "ac3_parser_internal.h"
28 #include "bytestream.h"
29 #include "internal.h"
30 #include "mpegaudiodecheader.h"
31 #include "libavutil/avassert.h"
32 #include "libavutil/opt.h"
33 #include "libavutil/log.h"
34
35 #if __MAC_OS_X_VERSION_MIN_REQUIRED < 101100
36 #define kAudioFormatEnhancedAC3 'ec-3'
37 #endif
38
39 typedef struct ATDecodeContext {
40     AVClass *av_class;
41
42     AudioConverterRef converter;
43     AudioStreamPacketDescription pkt_desc;
44     AVPacket in_pkt;
45     AVPacket new_in_pkt;
46     char *decoded_data;
47     int channel_map[64];
48
49     uint8_t *extradata;
50     int extradata_size;
51
52     int64_t last_pts;
53     int eof;
54 } ATDecodeContext;
55
56 static UInt32 ffat_get_format_id(enum AVCodecID codec, int profile)
57 {
58     switch (codec) {
59     case AV_CODEC_ID_AAC:
60         return kAudioFormatMPEG4AAC;
61     case AV_CODEC_ID_AC3:
62         return kAudioFormatAC3;
63     case AV_CODEC_ID_ADPCM_IMA_QT:
64         return kAudioFormatAppleIMA4;
65     case AV_CODEC_ID_ALAC:
66         return kAudioFormatAppleLossless;
67     case AV_CODEC_ID_AMR_NB:
68         return kAudioFormatAMR;
69     case AV_CODEC_ID_EAC3:
70         return kAudioFormatEnhancedAC3;
71     case AV_CODEC_ID_GSM_MS:
72         return kAudioFormatMicrosoftGSM;
73     case AV_CODEC_ID_ILBC:
74         return kAudioFormatiLBC;
75     case AV_CODEC_ID_MP1:
76         return kAudioFormatMPEGLayer1;
77     case AV_CODEC_ID_MP2:
78         return kAudioFormatMPEGLayer2;
79     case AV_CODEC_ID_MP3:
80         return kAudioFormatMPEGLayer3;
81     case AV_CODEC_ID_PCM_ALAW:
82         return kAudioFormatALaw;
83     case AV_CODEC_ID_PCM_MULAW:
84         return kAudioFormatULaw;
85     case AV_CODEC_ID_QDMC:
86         return kAudioFormatQDesign;
87     case AV_CODEC_ID_QDM2:
88         return kAudioFormatQDesign2;
89     default:
90         av_assert0(!"Invalid codec ID!");
91         return 0;
92     }
93 }
94
95 static int ffat_get_channel_id(AudioChannelLabel label)
96 {
97     if (label == 0)
98         return -1;
99     else if (label <= kAudioChannelLabel_LFEScreen)
100         return label - 1;
101     else if (label <= kAudioChannelLabel_RightSurround)
102         return label + 4;
103     else if (label <= kAudioChannelLabel_CenterSurround)
104         return label + 1;
105     else if (label <= kAudioChannelLabel_RightSurroundDirect)
106         return label + 23;
107     else if (label <= kAudioChannelLabel_TopBackRight)
108         return label - 1;
109     else if (label < kAudioChannelLabel_RearSurroundLeft)
110         return -1;
111     else if (label <= kAudioChannelLabel_RearSurroundRight)
112         return label - 29;
113     else if (label <= kAudioChannelLabel_RightWide)
114         return label - 4;
115     else if (label == kAudioChannelLabel_LFE2)
116         return ff_ctzll(AV_CH_LOW_FREQUENCY_2);
117     else if (label == kAudioChannelLabel_Mono)
118         return ff_ctzll(AV_CH_FRONT_CENTER);
119     else
120         return -1;
121 }
122
123 static int ffat_compare_channel_descriptions(const void* a, const void* b)
124 {
125     const AudioChannelDescription* da = a;
126     const AudioChannelDescription* db = b;
127     return ffat_get_channel_id(da->mChannelLabel) - ffat_get_channel_id(db->mChannelLabel);
128 }
129
130 static AudioChannelLayout *ffat_convert_layout(AudioChannelLayout *layout, UInt32* size)
131 {
132     AudioChannelLayoutTag tag = layout->mChannelLayoutTag;
133     AudioChannelLayout *new_layout;
134     if (tag == kAudioChannelLayoutTag_UseChannelDescriptions)
135         return layout;
136     else if (tag == kAudioChannelLayoutTag_UseChannelBitmap)
137         AudioFormatGetPropertyInfo(kAudioFormatProperty_ChannelLayoutForBitmap,
138                                    sizeof(UInt32), &layout->mChannelBitmap, size);
139     else
140         AudioFormatGetPropertyInfo(kAudioFormatProperty_ChannelLayoutForTag,
141                                    sizeof(AudioChannelLayoutTag), &tag, size);
142     new_layout = av_malloc(*size);
143     if (!new_layout) {
144         av_free(layout);
145         return NULL;
146     }
147     if (tag == kAudioChannelLayoutTag_UseChannelBitmap)
148         AudioFormatGetProperty(kAudioFormatProperty_ChannelLayoutForBitmap,
149                                sizeof(UInt32), &layout->mChannelBitmap, size, new_layout);
150     else
151         AudioFormatGetProperty(kAudioFormatProperty_ChannelLayoutForTag,
152                                sizeof(AudioChannelLayoutTag), &tag, size, new_layout);
153     new_layout->mChannelLayoutTag = kAudioChannelLayoutTag_UseChannelDescriptions;
154     av_free(layout);
155     return new_layout;
156 }
157
158 static int ffat_update_ctx(AVCodecContext *avctx)
159 {
160     ATDecodeContext *at = avctx->priv_data;
161     AudioStreamBasicDescription format;
162     UInt32 size = sizeof(format);
163     if (!AudioConverterGetProperty(at->converter,
164                                    kAudioConverterCurrentInputStreamDescription,
165                                    &size, &format)) {
166         if (format.mSampleRate)
167             avctx->sample_rate = format.mSampleRate;
168         avctx->channels = format.mChannelsPerFrame;
169         avctx->channel_layout = av_get_default_channel_layout(avctx->channels);
170         avctx->frame_size = format.mFramesPerPacket;
171     }
172
173     if (!AudioConverterGetProperty(at->converter,
174                                    kAudioConverterCurrentOutputStreamDescription,
175                                    &size, &format)) {
176         format.mSampleRate = avctx->sample_rate;
177         format.mChannelsPerFrame = avctx->channels;
178         AudioConverterSetProperty(at->converter,
179                                   kAudioConverterCurrentOutputStreamDescription,
180                                   size, &format);
181     }
182
183     if (!AudioConverterGetPropertyInfo(at->converter, kAudioConverterOutputChannelLayout,
184                                        &size, NULL) && size) {
185         AudioChannelLayout *layout = av_malloc(size);
186         uint64_t layout_mask = 0;
187         int i;
188         if (!layout)
189             return AVERROR(ENOMEM);
190         AudioConverterGetProperty(at->converter, kAudioConverterOutputChannelLayout,
191                                   &size, layout);
192         if (!(layout = ffat_convert_layout(layout, &size)))
193             return AVERROR(ENOMEM);
194         for (i = 0; i < layout->mNumberChannelDescriptions; i++) {
195             int id = ffat_get_channel_id(layout->mChannelDescriptions[i].mChannelLabel);
196             if (id < 0)
197                 goto done;
198             if (layout_mask & (1 << id))
199                 goto done;
200             layout_mask |= 1 << id;
201             layout->mChannelDescriptions[i].mChannelFlags = i; // Abusing flags as index
202         }
203         avctx->channel_layout = layout_mask;
204         qsort(layout->mChannelDescriptions, layout->mNumberChannelDescriptions,
205               sizeof(AudioChannelDescription), &ffat_compare_channel_descriptions);
206         for (i = 0; i < layout->mNumberChannelDescriptions; i++)
207             at->channel_map[i] = layout->mChannelDescriptions[i].mChannelFlags;
208 done:
209         av_free(layout);
210     }
211
212     if (!avctx->frame_size)
213         avctx->frame_size = 2048;
214
215     return 0;
216 }
217
218 static void put_descr(PutByteContext *pb, int tag, unsigned int size)
219 {
220     int i = 3;
221     bytestream2_put_byte(pb, tag);
222     for (; i > 0; i--)
223         bytestream2_put_byte(pb, (size >> (7 * i)) | 0x80);
224     bytestream2_put_byte(pb, size & 0x7F);
225 }
226
227 static uint8_t* ffat_get_magic_cookie(AVCodecContext *avctx, UInt32 *cookie_size)
228 {
229     ATDecodeContext *at = avctx->priv_data;
230     if (avctx->codec_id == AV_CODEC_ID_AAC) {
231         char *extradata;
232         PutByteContext pb;
233         *cookie_size = 5 + 3 + 5+13 + 5+at->extradata_size;
234         if (!(extradata = av_malloc(*cookie_size)))
235             return NULL;
236
237         bytestream2_init_writer(&pb, extradata, *cookie_size);
238
239         // ES descriptor
240         put_descr(&pb, 0x03, 3 + 5+13 + 5+at->extradata_size);
241         bytestream2_put_be16(&pb, 0);
242         bytestream2_put_byte(&pb, 0x00); // flags (= no flags)
243
244         // DecoderConfig descriptor
245         put_descr(&pb, 0x04, 13 + 5+at->extradata_size);
246
247         // Object type indication
248         bytestream2_put_byte(&pb, 0x40);
249
250         bytestream2_put_byte(&pb, 0x15); // flags (= Audiostream)
251
252         bytestream2_put_be24(&pb, 0); // Buffersize DB
253
254         bytestream2_put_be32(&pb, 0); // maxbitrate
255         bytestream2_put_be32(&pb, 0); // avgbitrate
256
257         // DecoderSpecific info descriptor
258         put_descr(&pb, 0x05, at->extradata_size);
259         bytestream2_put_buffer(&pb, at->extradata, at->extradata_size);
260         return extradata;
261     } else {
262         *cookie_size = at->extradata_size;
263         return at->extradata;
264     }
265 }
266
267 static av_cold int ffat_usable_extradata(AVCodecContext *avctx)
268 {
269     ATDecodeContext *at = avctx->priv_data;
270     return at->extradata_size &&
271            (avctx->codec_id == AV_CODEC_ID_ALAC ||
272             avctx->codec_id == AV_CODEC_ID_QDM2 ||
273             avctx->codec_id == AV_CODEC_ID_QDMC ||
274             avctx->codec_id == AV_CODEC_ID_AAC);
275 }
276
277 static int ffat_set_extradata(AVCodecContext *avctx)
278 {
279     ATDecodeContext *at = avctx->priv_data;
280     if (ffat_usable_extradata(avctx)) {
281         OSStatus status;
282         UInt32 cookie_size;
283         uint8_t *cookie = ffat_get_magic_cookie(avctx, &cookie_size);
284         if (!cookie)
285             return AVERROR(ENOMEM);
286
287         status = AudioConverterSetProperty(at->converter,
288                                            kAudioConverterDecompressionMagicCookie,
289                                            cookie_size, cookie);
290         if (status != 0)
291             av_log(avctx, AV_LOG_WARNING, "AudioToolbox cookie error: %i\n", (int)status);
292
293         if (cookie != at->extradata)
294             av_free(cookie);
295     }
296     return 0;
297 }
298
299 static av_cold int ffat_create_decoder(AVCodecContext *avctx, AVPacket *pkt)
300 {
301     ATDecodeContext *at = avctx->priv_data;
302     OSStatus status;
303     int i;
304
305     enum AVSampleFormat sample_fmt = (avctx->bits_per_raw_sample == 32) ?
306                                      AV_SAMPLE_FMT_S32 : AV_SAMPLE_FMT_S16;
307
308     AudioStreamBasicDescription in_format = {
309         .mFormatID = ffat_get_format_id(avctx->codec_id, avctx->profile),
310         .mBytesPerPacket = (avctx->codec_id == AV_CODEC_ID_ILBC) ? avctx->block_align : 0,
311     };
312     AudioStreamBasicDescription out_format = {
313         .mFormatID = kAudioFormatLinearPCM,
314         .mFormatFlags = kAudioFormatFlagIsSignedInteger | kAudioFormatFlagIsPacked,
315         .mFramesPerPacket = 1,
316         .mBitsPerChannel = av_get_bytes_per_sample(sample_fmt) * 8,
317     };
318
319     avctx->sample_fmt = sample_fmt;
320
321     if (ffat_usable_extradata(avctx)) {
322         UInt32 format_size = sizeof(in_format);
323         UInt32 cookie_size;
324         uint8_t *cookie = ffat_get_magic_cookie(avctx, &cookie_size);
325         if (!cookie)
326             return AVERROR(ENOMEM);
327         status = AudioFormatGetProperty(kAudioFormatProperty_FormatInfo,
328                                         cookie_size, cookie, &format_size, &in_format);
329         if (cookie != at->extradata)
330             av_free(cookie);
331         if (status != 0) {
332             av_log(avctx, AV_LOG_ERROR, "AudioToolbox header-parse error: %i\n", (int)status);
333             return AVERROR_UNKNOWN;
334         }
335 #if CONFIG_MP1_AT_DECODER || CONFIG_MP2_AT_DECODER || CONFIG_MP3_AT_DECODER
336     } else if (pkt && pkt->size >= 4 &&
337                (avctx->codec_id == AV_CODEC_ID_MP1 ||
338                 avctx->codec_id == AV_CODEC_ID_MP2 ||
339                 avctx->codec_id == AV_CODEC_ID_MP3)) {
340         enum AVCodecID codec_id;
341         int bit_rate;
342         if (ff_mpa_decode_header(AV_RB32(pkt->data), &avctx->sample_rate,
343                                  &in_format.mChannelsPerFrame, &avctx->frame_size,
344                                  &bit_rate, &codec_id) < 0)
345             return AVERROR_INVALIDDATA;
346         avctx->bit_rate = bit_rate;
347         in_format.mSampleRate = avctx->sample_rate;
348 #endif
349 #if CONFIG_AC3_AT_DECODER || CONFIG_EAC3_AT_DECODER
350     } else if (pkt && pkt->size >= 7 &&
351                (avctx->codec_id == AV_CODEC_ID_AC3 ||
352                 avctx->codec_id == AV_CODEC_ID_EAC3)) {
353         AC3HeaderInfo hdr;
354         GetBitContext gbc;
355         init_get_bits(&gbc, pkt->data, pkt->size);
356         if (ff_ac3_parse_header(&gbc, &hdr) < 0)
357             return AVERROR_INVALIDDATA;
358         in_format.mSampleRate = hdr.sample_rate;
359         in_format.mChannelsPerFrame = hdr.channels;
360         avctx->frame_size = hdr.num_blocks * 256;
361         avctx->bit_rate = hdr.bit_rate;
362 #endif
363     } else {
364         in_format.mSampleRate = avctx->sample_rate ? avctx->sample_rate : 44100;
365         in_format.mChannelsPerFrame = avctx->channels ? avctx->channels : 1;
366     }
367
368     avctx->sample_rate = out_format.mSampleRate = in_format.mSampleRate;
369     avctx->channels = out_format.mChannelsPerFrame = in_format.mChannelsPerFrame;
370
371     if (avctx->codec_id == AV_CODEC_ID_ADPCM_IMA_QT)
372         in_format.mFramesPerPacket = 64;
373
374     status = AudioConverterNew(&in_format, &out_format, &at->converter);
375
376     if (status != 0) {
377         av_log(avctx, AV_LOG_ERROR, "AudioToolbox init error: %i\n", (int)status);
378         return AVERROR_UNKNOWN;
379     }
380
381     if ((status = ffat_set_extradata(avctx)) < 0)
382         return status;
383
384     for (i = 0; i < (sizeof(at->channel_map) / sizeof(at->channel_map[0])); i++)
385         at->channel_map[i] = i;
386
387     ffat_update_ctx(avctx);
388
389     if(!(at->decoded_data = av_malloc(av_get_bytes_per_sample(avctx->sample_fmt)
390                                       * avctx->frame_size * avctx->channels)))
391         return AVERROR(ENOMEM);
392
393     at->last_pts = AV_NOPTS_VALUE;
394
395     return 0;
396 }
397
398 static av_cold int ffat_init_decoder(AVCodecContext *avctx)
399 {
400     ATDecodeContext *at = avctx->priv_data;
401     if (avctx->extradata_size) {
402         at->extradata = av_mallocz(avctx->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
403         if (!at->extradata)
404             return AVERROR(ENOMEM);
405         at->extradata_size = avctx->extradata_size;
406         memcpy(at->extradata, avctx->extradata, avctx->extradata_size);
407     }
408
409     if ((avctx->channels && avctx->sample_rate) || ffat_usable_extradata(avctx))
410         return ffat_create_decoder(avctx, NULL);
411     else
412         return 0;
413 }
414
415 static OSStatus ffat_decode_callback(AudioConverterRef converter, UInt32 *nb_packets,
416                                      AudioBufferList *data,
417                                      AudioStreamPacketDescription **packets,
418                                      void *inctx)
419 {
420     AVCodecContext *avctx = inctx;
421     ATDecodeContext *at = avctx->priv_data;
422
423     if (at->eof) {
424         *nb_packets = 0;
425         if (packets) {
426             *packets = &at->pkt_desc;
427             at->pkt_desc.mDataByteSize = 0;
428         }
429         return 0;
430     }
431
432     av_packet_unref(&at->in_pkt);
433     av_packet_move_ref(&at->in_pkt, &at->new_in_pkt);
434
435     if (!at->in_pkt.data) {
436         *nb_packets = 0;
437         return 1;
438     }
439
440     data->mNumberBuffers              = 1;
441     data->mBuffers[0].mNumberChannels = 0;
442     data->mBuffers[0].mDataByteSize   = at->in_pkt.size;
443     data->mBuffers[0].mData           = at->in_pkt.data;
444     *nb_packets = 1;
445
446     if (packets) {
447         *packets = &at->pkt_desc;
448         at->pkt_desc.mDataByteSize = at->in_pkt.size;
449     }
450
451     return 0;
452 }
453
454 #define COPY_SAMPLES(type) \
455     type *in_ptr = (type*)at->decoded_data; \
456     type *end_ptr = in_ptr + frame->nb_samples * avctx->channels; \
457     type *out_ptr = (type*)frame->data[0]; \
458     for (; in_ptr < end_ptr; in_ptr += avctx->channels, out_ptr += avctx->channels) { \
459         int c; \
460         for (c = 0; c < avctx->channels; c++) \
461             out_ptr[c] = in_ptr[at->channel_map[c]]; \
462     }
463
464 static void ffat_copy_samples(AVCodecContext *avctx, AVFrame *frame)
465 {
466     ATDecodeContext *at = avctx->priv_data;
467     if (avctx->sample_fmt == AV_SAMPLE_FMT_S32) {
468         COPY_SAMPLES(int32_t);
469     } else {
470         COPY_SAMPLES(int16_t);
471     }
472 }
473
474 static int ffat_decode(AVCodecContext *avctx, void *data,
475                        int *got_frame_ptr, AVPacket *avpkt)
476 {
477     ATDecodeContext *at = avctx->priv_data;
478     AVFrame *frame = data;
479     int pkt_size = avpkt->size;
480     OSStatus ret;
481     AudioBufferList out_buffers;
482
483     if (avctx->codec_id == AV_CODEC_ID_AAC) {
484         if (!at->extradata_size) {
485             uint8_t *side_data;
486             int side_data_size = 0;
487
488             side_data = av_packet_get_side_data(avpkt, AV_PKT_DATA_NEW_EXTRADATA,
489                                                 &side_data_size);
490             if (side_data_size) {
491                 at->extradata = av_mallocz(side_data_size + AV_INPUT_BUFFER_PADDING_SIZE);
492                 if (!at->extradata)
493                     return AVERROR(ENOMEM);
494                 at->extradata_size = side_data_size;
495                 memcpy(at->extradata, side_data, side_data_size);
496             }
497         }
498     }
499
500     if (!at->converter) {
501         if ((ret = ffat_create_decoder(avctx, avpkt)) < 0) {
502             return ret;
503         }
504     }
505
506     out_buffers = (AudioBufferList){
507         .mNumberBuffers = 1,
508         .mBuffers = {
509             {
510                 .mNumberChannels = avctx->channels,
511                 .mDataByteSize = av_get_bytes_per_sample(avctx->sample_fmt) * avctx->frame_size
512                                  * avctx->channels,
513             }
514         }
515     };
516
517     av_packet_unref(&at->new_in_pkt);
518
519     if (avpkt->size) {
520         if ((ret = av_packet_ref(&at->new_in_pkt, avpkt)) < 0) {
521             return ret;
522         }
523     } else {
524         at->eof = 1;
525     }
526
527     frame->sample_rate = avctx->sample_rate;
528
529     frame->nb_samples = avctx->frame_size;
530
531     out_buffers.mBuffers[0].mData = at->decoded_data;
532
533     ret = AudioConverterFillComplexBuffer(at->converter, ffat_decode_callback, avctx,
534                                           &frame->nb_samples, &out_buffers, NULL);
535     if ((!ret || ret == 1) && frame->nb_samples) {
536         if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
537             return ret;
538         ffat_copy_samples(avctx, frame);
539         *got_frame_ptr = 1;
540         if (at->last_pts != AV_NOPTS_VALUE) {
541             frame->pts = at->last_pts;
542 #if FF_API_PKT_PTS
543 FF_DISABLE_DEPRECATION_WARNINGS
544             frame->pkt_pts = at->last_pts;
545 FF_ENABLE_DEPRECATION_WARNINGS
546 #endif
547             at->last_pts = avpkt->pts;
548         }
549     } else if (ret && ret != 1) {
550         av_log(avctx, AV_LOG_WARNING, "Decode error: %i\n", ret);
551     } else {
552         at->last_pts = avpkt->pts;
553     }
554
555     return pkt_size;
556 }
557
558 static av_cold void ffat_decode_flush(AVCodecContext *avctx)
559 {
560     ATDecodeContext *at = avctx->priv_data;
561     AudioConverterReset(at->converter);
562     av_packet_unref(&at->new_in_pkt);
563     av_packet_unref(&at->in_pkt);
564 }
565
566 static av_cold int ffat_close_decoder(AVCodecContext *avctx)
567 {
568     ATDecodeContext *at = avctx->priv_data;
569     if (at->converter)
570         AudioConverterDispose(at->converter);
571     av_packet_unref(&at->new_in_pkt);
572     av_packet_unref(&at->in_pkt);
573     av_freep(&at->decoded_data);
574     av_freep(&at->extradata);
575     return 0;
576 }
577
578 #define FFAT_DEC_CLASS(NAME) \
579     static const AVClass ffat_##NAME##_dec_class = { \
580         .class_name = "at_" #NAME "_dec", \
581         .version    = LIBAVUTIL_VERSION_INT, \
582     };
583
584 #define FFAT_DEC(NAME, ID, bsf_name) \
585     FFAT_DEC_CLASS(NAME) \
586     AVCodec ff_##NAME##_at_decoder = { \
587         .name           = #NAME "_at", \
588         .long_name      = NULL_IF_CONFIG_SMALL(#NAME " (AudioToolbox)"), \
589         .type           = AVMEDIA_TYPE_AUDIO, \
590         .id             = ID, \
591         .priv_data_size = sizeof(ATDecodeContext), \
592         .init           = ffat_init_decoder, \
593         .close          = ffat_close_decoder, \
594         .decode         = ffat_decode, \
595         .flush          = ffat_decode_flush, \
596         .priv_class     = &ffat_##NAME##_dec_class, \
597         .bsfs           = bsf_name, \
598         .capabilities   = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY, \
599         .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP, \
600         .wrapper_name   = "at", \
601     };
602
603 FFAT_DEC(aac,          AV_CODEC_ID_AAC, "aac_adtstoasc")
604 FFAT_DEC(ac3,          AV_CODEC_ID_AC3, NULL)
605 FFAT_DEC(adpcm_ima_qt, AV_CODEC_ID_ADPCM_IMA_QT, NULL)
606 FFAT_DEC(alac,         AV_CODEC_ID_ALAC, NULL)
607 FFAT_DEC(amr_nb,       AV_CODEC_ID_AMR_NB, NULL)
608 FFAT_DEC(eac3,         AV_CODEC_ID_EAC3, NULL)
609 FFAT_DEC(gsm_ms,       AV_CODEC_ID_GSM_MS, NULL)
610 FFAT_DEC(ilbc,         AV_CODEC_ID_ILBC, NULL)
611 FFAT_DEC(mp1,          AV_CODEC_ID_MP1, NULL)
612 FFAT_DEC(mp2,          AV_CODEC_ID_MP2, NULL)
613 FFAT_DEC(mp3,          AV_CODEC_ID_MP3, NULL)
614 FFAT_DEC(pcm_alaw,     AV_CODEC_ID_PCM_ALAW, NULL)
615 FFAT_DEC(pcm_mulaw,    AV_CODEC_ID_PCM_MULAW, NULL)
616 FFAT_DEC(qdmc,         AV_CODEC_ID_QDMC, NULL)
617 FFAT_DEC(qdm2,         AV_CODEC_ID_QDM2, NULL)