lavc/audiotoolboxdec: support ADTS AAC input
[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 "bytestream.h"
28 #include "internal.h"
29 #include "libavutil/avassert.h"
30 #include "libavutil/opt.h"
31 #include "libavutil/log.h"
32
33 typedef struct ATDecodeContext {
34     AVClass *av_class;
35
36     AudioConverterRef converter;
37     AudioStreamPacketDescription pkt_desc;
38     AVPacket in_pkt;
39     AVPacket new_in_pkt;
40     AVBitStreamFilterContext *bsf;
41
42     unsigned pkt_size;
43     int64_t last_pts;
44     int eof;
45 } ATDecodeContext;
46
47 static UInt32 ffat_get_format_id(enum AVCodecID codec, int profile)
48 {
49     switch (codec) {
50     case AV_CODEC_ID_AAC:
51         return kAudioFormatMPEG4AAC;
52     case AV_CODEC_ID_AC3:
53         return kAudioFormatAC3;
54     case AV_CODEC_ID_ADPCM_IMA_QT:
55         return kAudioFormatAppleIMA4;
56     case AV_CODEC_ID_ALAC:
57         return kAudioFormatAppleLossless;
58     case AV_CODEC_ID_AMR_NB:
59         return kAudioFormatAMR;
60     case AV_CODEC_ID_GSM_MS:
61         return kAudioFormatMicrosoftGSM;
62     case AV_CODEC_ID_ILBC:
63         return kAudioFormatiLBC;
64     case AV_CODEC_ID_MP1:
65         return kAudioFormatMPEGLayer1;
66     case AV_CODEC_ID_MP2:
67         return kAudioFormatMPEGLayer2;
68     case AV_CODEC_ID_MP3:
69         return kAudioFormatMPEGLayer3;
70     case AV_CODEC_ID_PCM_ALAW:
71         return kAudioFormatALaw;
72     case AV_CODEC_ID_PCM_MULAW:
73         return kAudioFormatULaw;
74     case AV_CODEC_ID_QDMC:
75         return kAudioFormatQDesign;
76     case AV_CODEC_ID_QDM2:
77         return kAudioFormatQDesign2;
78     default:
79         av_assert0(!"Invalid codec ID!");
80         return 0;
81     }
82 }
83
84 static void ffat_update_ctx(AVCodecContext *avctx)
85 {
86     ATDecodeContext *at = avctx->priv_data;
87     AudioStreamBasicDescription in_format;
88     UInt32 size = sizeof(in_format);
89     if (!AudioConverterGetProperty(at->converter,
90                                    kAudioConverterCurrentInputStreamDescription,
91                                    &size, &in_format)) {
92         avctx->channels = in_format.mChannelsPerFrame;
93         at->pkt_size = in_format.mFramesPerPacket;
94     }
95
96     if (!at->pkt_size)
97         at->pkt_size = 2048;
98 }
99
100 static void put_descr(PutByteContext *pb, int tag, unsigned int size)
101 {
102     int i = 3;
103     bytestream2_put_byte(pb, tag);
104     for (; i > 0; i--)
105         bytestream2_put_byte(pb, (size >> (7 * i)) | 0x80);
106     bytestream2_put_byte(pb, size & 0x7F);
107 }
108
109 static av_cold int ffat_init_decoder(AVCodecContext *avctx)
110 {
111     ATDecodeContext *at = avctx->priv_data;
112     OSStatus status;
113
114     enum AVSampleFormat sample_fmt = (avctx->bits_per_raw_sample == 32) ?
115                                      AV_SAMPLE_FMT_S32 : AV_SAMPLE_FMT_S16;
116
117     AudioStreamBasicDescription in_format = {
118         .mSampleRate = avctx->sample_rate ? avctx->sample_rate : 44100,
119         .mFormatID = ffat_get_format_id(avctx->codec_id, avctx->profile),
120         .mBytesPerPacket = avctx->block_align,
121         .mChannelsPerFrame = avctx->channels ? avctx->channels : 1,
122     };
123     AudioStreamBasicDescription out_format = {
124         .mSampleRate = in_format.mSampleRate,
125         .mFormatID = kAudioFormatLinearPCM,
126         .mFormatFlags = kAudioFormatFlagIsSignedInteger | kAudioFormatFlagIsPacked,
127         .mFramesPerPacket = 1,
128         .mChannelsPerFrame = in_format.mChannelsPerFrame,
129         .mBitsPerChannel = av_get_bytes_per_sample(sample_fmt) * 8,
130     };
131
132     avctx->sample_fmt = sample_fmt;
133
134     if (avctx->codec_id == AV_CODEC_ID_ADPCM_IMA_QT)
135         in_format.mFramesPerPacket = 64;
136
137     status = AudioConverterNew(&in_format, &out_format, &at->converter);
138
139     if (status != 0) {
140         av_log(avctx, AV_LOG_ERROR, "AudioToolbox init error: %i\n", (int)status);
141         return AVERROR_UNKNOWN;
142     }
143
144     if (avctx->extradata_size) {
145         char *extradata = avctx->extradata;
146         int extradata_size = avctx->extradata_size;
147         if (avctx->codec_id == AV_CODEC_ID_AAC) {
148             PutByteContext pb;
149             extradata_size = 5 + 3 + 5+13 + 5+avctx->extradata_size;
150             if (!(extradata = av_malloc(extradata_size)))
151                 return AVERROR(ENOMEM);
152
153             bytestream2_init_writer(&pb, extradata, extradata_size);
154
155             // ES descriptor
156             put_descr(&pb, 0x03, 3 + 5+13 + 5+avctx->extradata_size);
157             bytestream2_put_be16(&pb, 0);
158             bytestream2_put_byte(&pb, 0x00); // flags (= no flags)
159
160             // DecoderConfig descriptor
161             put_descr(&pb, 0x04, 13 + 5+avctx->extradata_size);
162
163             // Object type indication
164             bytestream2_put_byte(&pb, 0x40);
165
166             bytestream2_put_byte(&pb, 0x15); // flags (= Audiostream)
167
168             bytestream2_put_be24(&pb, 0); // Buffersize DB
169
170             bytestream2_put_be32(&pb, 0); // maxbitrate
171             bytestream2_put_be32(&pb, 0); // avgbitrate
172
173             // DecoderSpecific info descriptor
174             put_descr(&pb, 0x05, avctx->extradata_size);
175             bytestream2_put_buffer(&pb, avctx->extradata, avctx->extradata_size);
176         }
177
178         status = AudioConverterSetProperty(at->converter,
179                                            kAudioConverterDecompressionMagicCookie,
180                                            extradata_size, extradata);
181         if (status != 0)
182             av_log(avctx, AV_LOG_WARNING, "AudioToolbox cookie error: %i\n", (int)status);
183     }
184
185     ffat_update_ctx(avctx);
186
187     at->last_pts = AV_NOPTS_VALUE;
188
189     return 0;
190 }
191
192 static OSStatus ffat_decode_callback(AudioConverterRef converter, UInt32 *nb_packets,
193                                      AudioBufferList *data,
194                                      AudioStreamPacketDescription **packets,
195                                      void *inctx)
196 {
197     AVCodecContext *avctx = inctx;
198     ATDecodeContext *at = avctx->priv_data;
199
200     if (at->eof) {
201         *nb_packets = 0;
202         if (packets) {
203             *packets = &at->pkt_desc;
204             at->pkt_desc.mDataByteSize = 0;
205         }
206         return 0;
207     }
208
209     av_packet_move_ref(&at->in_pkt, &at->new_in_pkt);
210     at->new_in_pkt.data = 0;
211     at->new_in_pkt.size = 0;
212
213     if (!at->in_pkt.data) {
214         *nb_packets = 0;
215         return 1;
216     }
217
218     data->mNumberBuffers              = 1;
219     data->mBuffers[0].mNumberChannels = 0;
220     data->mBuffers[0].mDataByteSize   = at->in_pkt.size;
221     data->mBuffers[0].mData           = at->in_pkt.data;
222     *nb_packets = 1;
223
224     if (packets) {
225         *packets = &at->pkt_desc;
226         at->pkt_desc.mDataByteSize = at->in_pkt.size;
227     }
228
229     return 0;
230 }
231
232 static int ffat_decode(AVCodecContext *avctx, void *data,
233                        int *got_frame_ptr, AVPacket *avpkt)
234 {
235     ATDecodeContext *at = avctx->priv_data;
236     AVFrame *frame = data;
237     int pkt_size = avpkt->size;
238     AVPacket filtered_packet;
239     OSStatus ret;
240
241     AudioBufferList out_buffers = {
242         .mNumberBuffers = 1,
243         .mBuffers = {
244             {
245                 .mNumberChannels = avctx->channels,
246                 .mDataByteSize = av_get_bytes_per_sample(avctx->sample_fmt) * at->pkt_size * avctx->channels,
247             }
248         }
249     };
250
251     if (avctx->codec_id == AV_CODEC_ID_AAC && avpkt->size > 2 &&
252         (AV_RB16(avpkt->data) & 0xfff0) == 0xfff0) {
253         int first = 0;
254         uint8_t *p_filtered = NULL;
255         int      n_filtered = 0;
256         if (!at->bsf) {
257             first = 1;
258             if(!(at->bsf = av_bitstream_filter_init("aac_adtstoasc")))
259                 return AVERROR(ENOMEM);
260         }
261
262         ret = av_bitstream_filter_filter(at->bsf, avctx, NULL, &p_filtered, &n_filtered,
263                                          avpkt->data, avpkt->size, 0);
264         if (ret >= 0 && p_filtered != avpkt->data) {
265             filtered_packet = *avpkt;
266             avpkt = &filtered_packet;
267             avpkt->data = p_filtered;
268             avpkt->size = n_filtered;
269         }
270
271         if (first) {
272             if ((ret = ffat_set_extradata(avctx)) < 0)
273                 return ret;
274             ffat_update_ctx(avctx);
275             out_buffers.mBuffers[0].mNumberChannels = avctx->channels;
276             out_buffers.mBuffers[0].mDataByteSize = av_get_bytes_per_sample(avctx->sample_fmt) * at->pkt_size * avctx->channels;
277         }
278     }
279
280     av_packet_unref(&at->new_in_pkt);
281
282     if (avpkt->size) {
283         if ((ret = av_packet_ref(&at->new_in_pkt, avpkt)) < 0)
284             return ret;
285         at->new_in_pkt.data = avpkt->data;
286     } else {
287         at->eof = 1;
288     }
289
290     frame->sample_rate = avctx->sample_rate;
291
292     frame->nb_samples = at->pkt_size;
293     ff_get_buffer(avctx, frame, 0);
294
295     out_buffers.mBuffers[0].mData = frame->data[0];
296
297     ret = AudioConverterFillComplexBuffer(at->converter, ffat_decode_callback, avctx,
298                                           &frame->nb_samples, &out_buffers, NULL);
299     if ((!ret || ret == 1) && frame->nb_samples) {
300         *got_frame_ptr = 1;
301         if (at->last_pts != AV_NOPTS_VALUE) {
302             frame->pts = at->last_pts;
303             at->last_pts = avpkt->pts;
304         }
305     } else if (ret && ret != 1) {
306         av_log(avctx, AV_LOG_WARNING, "Decode error: %i\n", ret);
307     } else {
308         at->last_pts = avpkt->pts;
309     }
310
311     return pkt_size;
312 }
313
314 static av_cold void ffat_decode_flush(AVCodecContext *avctx)
315 {
316     ATDecodeContext *at = avctx->priv_data;
317     AudioConverterReset(at->converter);
318     av_packet_unref(&at->new_in_pkt);
319     av_packet_unref(&at->in_pkt);
320 }
321
322 static av_cold int ffat_close_decoder(AVCodecContext *avctx)
323 {
324     ATDecodeContext *at = avctx->priv_data;
325     AudioConverterDispose(at->converter);
326     av_packet_unref(&at->new_in_pkt);
327     av_packet_unref(&at->in_pkt);
328     return 0;
329 }
330
331 #define FFAT_DEC_CLASS(NAME) \
332     static const AVClass ffat_##NAME##_dec_class = { \
333         .class_name = "at_" #NAME "_dec", \
334         .version    = LIBAVUTIL_VERSION_INT, \
335     };
336
337 #define FFAT_DEC(NAME, ID) \
338     FFAT_DEC_CLASS(NAME) \
339     AVCodec ff_##NAME##_at_decoder = { \
340         .name           = #NAME "_at", \
341         .long_name      = NULL_IF_CONFIG_SMALL(#NAME " (AudioToolbox)"), \
342         .type           = AVMEDIA_TYPE_AUDIO, \
343         .id             = ID, \
344         .priv_data_size = sizeof(ATDecodeContext), \
345         .init           = ffat_init_decoder, \
346         .close          = ffat_close_decoder, \
347         .decode         = ffat_decode, \
348         .flush          = ffat_decode_flush, \
349         .priv_class     = &ffat_##NAME##_dec_class, \
350         .capabilities   = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY, \
351         .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE, \
352     };
353
354 FFAT_DEC(aac,          AV_CODEC_ID_AAC)
355 FFAT_DEC(ac3,          AV_CODEC_ID_AC3)
356 FFAT_DEC(adpcm_ima_qt, AV_CODEC_ID_ADPCM_IMA_QT)
357 FFAT_DEC(alac,         AV_CODEC_ID_ALAC)
358 FFAT_DEC(amr_nb,       AV_CODEC_ID_AMR_NB)
359 FFAT_DEC(gsm_ms,       AV_CODEC_ID_GSM_MS)
360 FFAT_DEC(ilbc,         AV_CODEC_ID_ILBC)
361 FFAT_DEC(mp1,          AV_CODEC_ID_MP1)
362 FFAT_DEC(mp2,          AV_CODEC_ID_MP2)
363 FFAT_DEC(mp3,          AV_CODEC_ID_MP3)
364 FFAT_DEC(pcm_alaw,     AV_CODEC_ID_PCM_ALAW)
365 FFAT_DEC(pcm_mulaw,    AV_CODEC_ID_PCM_MULAW)
366 FFAT_DEC(qdmc,         AV_CODEC_ID_QDMC)
367 FFAT_DEC(qdm2,         AV_CODEC_ID_QDM2)