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