4797b2aae960156eae75acf59ca75454e5cf0178
[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 #include "config.h"
26 #include "audio_frame_queue.h"
27 #include "avcodec.h"
28 #include "bytestream.h"
29 #include "internal.h"
30 #include "libavformat/isom.h"
31 #include "libavutil/avassert.h"
32 #include "libavutil/opt.h"
33 #include "libavutil/log.h"
34
35 typedef struct ATDecodeContext {
36     AVClass *av_class;
37     int mode;
38     int quality;
39
40     AudioConverterRef converter;
41     AVFrame in_frame;
42     AVFrame new_in_frame;
43
44     unsigned pkt_size;
45     AudioFrameQueue afq;
46     int eof;
47     int frame_size;
48 } ATDecodeContext;
49
50 static UInt32 ffat_get_format_id(enum AVCodecID codec, int profile)
51 {
52     switch (codec) {
53     case AV_CODEC_ID_AAC:
54         switch (profile) {
55         case FF_PROFILE_AAC_LOW:
56         default:
57             return kAudioFormatMPEG4AAC;
58         case FF_PROFILE_AAC_HE:
59             return kAudioFormatMPEG4AAC_HE;
60         case FF_PROFILE_AAC_HE_V2:
61             return kAudioFormatMPEG4AAC_HE_V2;
62         case FF_PROFILE_AAC_LD:
63             return kAudioFormatMPEG4AAC_LD;
64         case FF_PROFILE_AAC_ELD:
65             return kAudioFormatMPEG4AAC_ELD;
66         }
67     case AV_CODEC_ID_ADPCM_IMA_QT:
68         return kAudioFormatAppleIMA4;
69     case AV_CODEC_ID_ALAC:
70         return kAudioFormatAppleLossless;
71     case AV_CODEC_ID_ILBC:
72         return kAudioFormatiLBC;
73     case AV_CODEC_ID_PCM_ALAW:
74         return kAudioFormatALaw;
75     case AV_CODEC_ID_PCM_MULAW:
76         return kAudioFormatULaw;
77     default:
78         av_assert0(!"Invalid codec ID!");
79         return 0;
80     }
81 }
82
83 static void ffat_update_ctx(AVCodecContext *avctx)
84 {
85     ATDecodeContext *at = avctx->priv_data;
86     UInt32 size = sizeof(unsigned);
87     AudioConverterPrimeInfo prime_info;
88     AudioStreamBasicDescription out_format;
89
90     AudioConverterGetProperty(at->converter,
91                               kAudioConverterPropertyMaximumOutputPacketSize,
92                               &size, &at->pkt_size);
93
94     if (at->pkt_size <= 0)
95         at->pkt_size = 1024 * 50;
96
97     size = sizeof(prime_info);
98
99     if (!AudioConverterGetProperty(at->converter,
100                                    kAudioConverterPrimeInfo,
101                                    &size, &prime_info)) {
102         avctx->initial_padding = prime_info.leadingFrames;
103     }
104
105     size = sizeof(out_format);
106     if (!AudioConverterGetProperty(at->converter,
107                                    kAudioConverterCurrentOutputStreamDescription,
108                                    &size, &out_format)) {
109         if (out_format.mFramesPerPacket)
110             avctx->frame_size = out_format.mFramesPerPacket;
111         if (out_format.mBytesPerPacket && avctx->codec_id == AV_CODEC_ID_ILBC)
112             avctx->block_align = out_format.mBytesPerPacket;
113     }
114
115     at->frame_size = avctx->frame_size;
116     if (avctx->codec_id == AV_CODEC_ID_PCM_MULAW ||
117         avctx->codec_id == AV_CODEC_ID_PCM_ALAW) {
118         at->pkt_size *= 1024;
119         avctx->frame_size *= 1024;
120     }
121 }
122
123 static int read_descr(GetByteContext *gb, int *tag)
124 {
125     int len = 0;
126     int count = 4;
127     *tag = bytestream2_get_byte(gb);
128     while (count--) {
129         int c = bytestream2_get_byte(gb);
130         len = (len << 7) | (c & 0x7f);
131         if (!(c & 0x80))
132             break;
133     }
134     return len;
135 }
136
137 static int get_ilbc_mode(AVCodecContext *avctx)
138 {
139     if (avctx->block_align == 38)
140         return 20;
141     else if (avctx->block_align == 50)
142         return 30;
143     else if (avctx->bit_rate > 0)
144         return avctx->bit_rate <= 14000 ? 30 : 20;
145     else
146         return 30;
147 }
148
149 static av_cold int ffat_init_encoder(AVCodecContext *avctx)
150 {
151     ATDecodeContext *at = avctx->priv_data;
152     OSStatus status;
153
154     AudioStreamBasicDescription in_format = {
155         .mSampleRate = avctx->sample_rate,
156         .mFormatID = kAudioFormatLinearPCM,
157         .mFormatFlags = ((avctx->sample_fmt == AV_SAMPLE_FMT_FLT ||
158                           avctx->sample_fmt == AV_SAMPLE_FMT_DBL) ? kAudioFormatFlagIsFloat
159                         : avctx->sample_fmt == AV_SAMPLE_FMT_U8 ? 0
160                         : kAudioFormatFlagIsSignedInteger)
161                         | kAudioFormatFlagIsPacked,
162         .mBytesPerPacket = av_get_bytes_per_sample(avctx->sample_fmt) * avctx->channels,
163         .mFramesPerPacket = 1,
164         .mBytesPerFrame = av_get_bytes_per_sample(avctx->sample_fmt) * avctx->channels,
165         .mChannelsPerFrame = avctx->channels,
166         .mBitsPerChannel = av_get_bytes_per_sample(avctx->sample_fmt) * 8,
167     };
168     AudioStreamBasicDescription out_format = {
169         .mSampleRate = avctx->sample_rate,
170         .mFormatID = ffat_get_format_id(avctx->codec_id, avctx->profile),
171         .mChannelsPerFrame = in_format.mChannelsPerFrame,
172     };
173     AudioChannelLayout channel_layout = {
174         .mChannelLayoutTag = kAudioChannelLayoutTag_UseChannelBitmap,
175         .mChannelBitmap = avctx->channel_layout,
176     };
177     UInt32 size = sizeof(channel_layout);
178
179     if (avctx->codec_id == AV_CODEC_ID_ILBC) {
180         int mode = get_ilbc_mode(avctx);
181         out_format.mFramesPerPacket  = 8000 * mode / 1000;
182         out_format.mBytesPerPacket   = (mode == 20 ? 38 : 50);
183     }
184
185     status = AudioConverterNew(&in_format, &out_format, &at->converter);
186
187     if (status != 0) {
188         av_log(avctx, AV_LOG_ERROR, "AudioToolbox init error: %i\n", (int)status);
189         return AVERROR_UNKNOWN;
190     }
191
192     size = sizeof(UInt32);
193
194     AudioConverterSetProperty(at->converter, kAudioConverterInputChannelLayout,
195                               size, &channel_layout);
196     AudioConverterSetProperty(at->converter, kAudioConverterOutputChannelLayout,
197                               size, &channel_layout);
198
199     if (avctx->bits_per_raw_sample) {
200         size = sizeof(avctx->bits_per_raw_sample);
201         AudioConverterSetProperty(at->converter,
202                                   kAudioConverterPropertyBitDepthHint,
203                                   size, &avctx->bits_per_raw_sample);
204     }
205
206     if (at->mode == -1)
207         at->mode = (avctx->flags & AV_CODEC_FLAG_QSCALE) ?
208                    kAudioCodecBitRateControlMode_Variable :
209                    kAudioCodecBitRateControlMode_Constant;
210
211     AudioConverterSetProperty(at->converter, kAudioCodecPropertyBitRateControlMode,
212                               size, &at->mode);
213
214     if (at->mode == kAudioCodecBitRateControlMode_Variable) {
215         int q = avctx->global_quality / FF_QP2LAMBDA;
216         if (q < 0 || q > 14) {
217             av_log(avctx, AV_LOG_WARNING,
218                    "VBR quality %d out of range, should be 0-14\n", q);
219             q = av_clip(q, 0, 14);
220         }
221         q = 127 - q * 9;
222         AudioConverterSetProperty(at->converter, kAudioCodecPropertySoundQualityForVBR,
223                                   size, &q);
224     } else if (avctx->bit_rate > 0) {
225         UInt32 rate = avctx->bit_rate;
226         AudioConverterSetProperty(at->converter, kAudioConverterEncodeBitRate,
227                                   size, &rate);
228     }
229
230     at->quality = 96 - at->quality * 32;
231     AudioConverterSetProperty(at->converter, kAudioConverterCodecQuality,
232                               size, &at->quality);
233
234     if (!AudioConverterGetPropertyInfo(at->converter, kAudioConverterCompressionMagicCookie,
235                                        &avctx->extradata_size, NULL) &&
236         avctx->extradata_size) {
237         int extradata_size = avctx->extradata_size;
238         uint8_t *extradata;
239         if (!(avctx->extradata = av_mallocz(avctx->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE)))
240             return AVERROR(ENOMEM);
241         if (avctx->codec_id == AV_CODEC_ID_ALAC) {
242             avctx->extradata_size = 0x24;
243             AV_WB32(avctx->extradata,     0x24);
244             AV_WB32(avctx->extradata + 4, MKBETAG('a','l','a','c'));
245             extradata = avctx->extradata + 12;
246             avctx->extradata_size = 0x24;
247         } else {
248             extradata = avctx->extradata;
249         }
250         status = AudioConverterGetProperty(at->converter,
251                                            kAudioConverterCompressionMagicCookie,
252                                            &extradata_size, extradata);
253         if (status != 0) {
254             av_log(avctx, AV_LOG_ERROR, "AudioToolbox cookie error: %i\n", (int)status);
255             return AVERROR_UNKNOWN;
256         } else if (avctx->codec_id == AV_CODEC_ID_AAC) {
257             GetByteContext gb;
258             int tag, len;
259             bytestream2_init(&gb, extradata, extradata_size);
260             do {
261                 len = read_descr(&gb, &tag);
262                 if (tag == MP4DecConfigDescrTag) {
263                     bytestream2_skip(&gb, 13);
264                     len = read_descr(&gb, &tag);
265                     if (tag == MP4DecSpecificDescrTag) {
266                         len = FFMIN(gb.buffer_end - gb.buffer, len);
267                         memmove(extradata, gb.buffer, len);
268                         avctx->extradata_size = len;
269                         break;
270                     }
271                 } else if (tag == MP4ESDescrTag) {
272                     int flags;
273                     bytestream2_skip(&gb, 2);
274                     flags = bytestream2_get_byte(&gb);
275                     if (flags & 0x80) //streamDependenceFlag
276                         bytestream2_skip(&gb, 2);
277                     if (flags & 0x40) //URL_Flag
278                         bytestream2_skip(&gb, bytestream2_get_byte(&gb));
279                     if (flags & 0x20) //OCRstreamFlag
280                         bytestream2_skip(&gb, 2);
281                 }
282             } while (bytestream2_get_bytes_left(&gb));
283         } else if (avctx->codec_id != AV_CODEC_ID_ALAC) {
284             avctx->extradata_size = extradata_size;
285         }
286     }
287
288     ffat_update_ctx(avctx);
289
290 #if !TARGET_OS_IPHONE && __MAC_OS_X_VERSION_MIN_REQUIRED >= 1090
291     if (at->mode == kAudioCodecBitRateControlMode_Variable && avctx->rc_max_rate) {
292         int max_size = avctx->rc_max_rate * avctx->frame_size / avctx->sample_rate;
293         if (max_size)
294         AudioConverterSetProperty(at->converter, kAudioCodecPropertyPacketSizeLimitForVBR,
295                                   size, &max_size);
296     }
297 #endif
298
299     ff_af_queue_init(avctx, &at->afq);
300
301     return 0;
302 }
303
304 static OSStatus ffat_encode_callback(AudioConverterRef converter, UInt32 *nb_packets,
305                                      AudioBufferList *data,
306                                      AudioStreamPacketDescription **packets,
307                                      void *inctx)
308 {
309     AVCodecContext *avctx = inctx;
310     ATDecodeContext *at = avctx->priv_data;
311
312     if (at->eof) {
313         *nb_packets = 0;
314         return 0;
315     }
316
317     av_frame_unref(&at->in_frame);
318     av_frame_move_ref(&at->in_frame, &at->new_in_frame);
319
320     if (!at->in_frame.data[0]) {
321         *nb_packets = 0;
322         return 1;
323     }
324
325     data->mNumberBuffers              = 1;
326     data->mBuffers[0].mNumberChannels = avctx->channels;
327     data->mBuffers[0].mDataByteSize   = at->in_frame.nb_samples *
328                                         av_get_bytes_per_sample(avctx->sample_fmt) *
329                                         avctx->channels;
330     data->mBuffers[0].mData           = at->in_frame.data[0];
331     if (*nb_packets > at->in_frame.nb_samples)
332         *nb_packets = at->in_frame.nb_samples;
333
334     return 0;
335 }
336
337 static int ffat_encode(AVCodecContext *avctx, AVPacket *avpkt,
338                        const AVFrame *frame, int *got_packet_ptr)
339 {
340     ATDecodeContext *at = avctx->priv_data;
341     OSStatus ret;
342
343     AudioBufferList out_buffers = {
344         .mNumberBuffers = 1,
345         .mBuffers = {
346             {
347                 .mNumberChannels = avctx->channels,
348                 .mDataByteSize = at->pkt_size,
349             }
350         }
351     };
352     AudioStreamPacketDescription out_pkt_desc = {0};
353
354     if ((ret = ff_alloc_packet2(avctx, avpkt, at->pkt_size, 0)) < 0)
355         return ret;
356
357     av_frame_unref(&at->new_in_frame);
358
359     if (frame) {
360         if ((ret = ff_af_queue_add(&at->afq, frame)) < 0)
361             return ret;
362         if ((ret = av_frame_ref(&at->new_in_frame, frame)) < 0)
363             return ret;
364     } else {
365         at->eof = 1;
366     }
367
368     out_buffers.mBuffers[0].mData = avpkt->data;
369
370     *got_packet_ptr = avctx->frame_size / at->frame_size;
371
372     ret = AudioConverterFillComplexBuffer(at->converter, ffat_encode_callback, avctx,
373                                           got_packet_ptr, &out_buffers,
374                                           (avctx->frame_size > at->frame_size) ? NULL : &out_pkt_desc);
375     if ((!ret || ret == 1) && *got_packet_ptr) {
376         avpkt->size = out_buffers.mBuffers[0].mDataByteSize;
377         ff_af_queue_remove(&at->afq, out_pkt_desc.mVariableFramesInPacket ?
378                                      out_pkt_desc.mVariableFramesInPacket :
379                                      avctx->frame_size,
380                            &avpkt->pts,
381                            &avpkt->duration);
382     } else if (ret && ret != 1) {
383         av_log(avctx, AV_LOG_WARNING, "Encode error: %i\n", ret);
384     }
385
386     return 0;
387 }
388
389 static av_cold void ffat_encode_flush(AVCodecContext *avctx)
390 {
391     ATDecodeContext *at = avctx->priv_data;
392     AudioConverterReset(at->converter);
393     av_frame_unref(&at->new_in_frame);
394     av_frame_unref(&at->in_frame);
395 }
396
397 static av_cold int ffat_close_encoder(AVCodecContext *avctx)
398 {
399     ATDecodeContext *at = avctx->priv_data;
400     AudioConverterDispose(at->converter);
401     av_frame_unref(&at->new_in_frame);
402     av_frame_unref(&at->in_frame);
403     ff_af_queue_close(&at->afq);
404     return 0;
405 }
406
407 static const AVProfile aac_profiles[] = {
408     { FF_PROFILE_AAC_LOW,   "LC"       },
409     { FF_PROFILE_AAC_HE,    "HE-AAC"   },
410     { FF_PROFILE_AAC_HE_V2, "HE-AACv2" },
411     { FF_PROFILE_AAC_LD,    "LD"       },
412     { FF_PROFILE_AAC_ELD,   "ELD"      },
413     { FF_PROFILE_UNKNOWN },
414 };
415
416 #define AE AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
417 static const AVOption options[] = {
418     {"aac_at_mode", "ratecontrol mode", offsetof(ATDecodeContext, mode), AV_OPT_TYPE_INT, {.i64 = -1}, -1, kAudioCodecBitRateControlMode_Variable, AE, "mode"},
419         {"auto", "VBR if global quality is given; CBR otherwise", 0, AV_OPT_TYPE_CONST, {.i64 = -1}, INT_MIN, INT_MAX, AE, "mode"},
420         {"cbr",  "constant bitrate", 0, AV_OPT_TYPE_CONST, {.i64 = kAudioCodecBitRateControlMode_Constant}, INT_MIN, INT_MAX, AE, "mode"},
421         {"abr",  "long-term average bitrate", 0, AV_OPT_TYPE_CONST, {.i64 = kAudioCodecBitRateControlMode_LongTermAverage}, INT_MIN, INT_MAX, AE, "mode"},
422         {"cvbr", "constrained variable bitrate", 0, AV_OPT_TYPE_CONST, {.i64 = kAudioCodecBitRateControlMode_VariableConstrained}, INT_MIN, INT_MAX, AE, "mode"},
423         {"vbr" , "variable bitrate", 0, AV_OPT_TYPE_CONST, {.i64 = kAudioCodecBitRateControlMode_Variable}, INT_MIN, INT_MAX, AE, "mode"},
424     {"aac_at_quality", "quality vs speed control", offsetof(ATDecodeContext, quality), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 2, AE},
425     { NULL },
426 };
427
428 #define FFAT_ENC_CLASS(NAME) \
429     static const AVClass ffat_##NAME##_enc_class = { \
430         .class_name = "at_" #NAME "_enc", \
431         .item_name  = av_default_item_name, \
432         .option     = options, \
433         .version    = LIBAVUTIL_VERSION_INT, \
434     };
435
436 #define FFAT_ENC(NAME, ID, PROFILES, ...) \
437     FFAT_ENC_CLASS(NAME) \
438     AVCodec ff_##NAME##_at_encoder = { \
439         .name           = #NAME "_at", \
440         .long_name      = NULL_IF_CONFIG_SMALL(#NAME " (AudioToolbox)"), \
441         .type           = AVMEDIA_TYPE_AUDIO, \
442         .id             = ID, \
443         .priv_data_size = sizeof(ATDecodeContext), \
444         .init           = ffat_init_encoder, \
445         .close          = ffat_close_encoder, \
446         .encode2        = ffat_encode, \
447         .flush          = ffat_encode_flush, \
448         .priv_class     = &ffat_##NAME##_enc_class, \
449         .capabilities   = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY __VA_ARGS__, \
450         .sample_fmts    = (const enum AVSampleFormat[]) { \
451             AV_SAMPLE_FMT_S16, \
452             AV_SAMPLE_FMT_U8,  AV_SAMPLE_FMT_NONE \
453         }, \
454         .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE, \
455         .profiles       = PROFILES, \
456     };
457
458 FFAT_ENC(aac,          AV_CODEC_ID_AAC,          aac_profiles)
459 //FFAT_ENC(adpcm_ima_qt, AV_CODEC_ID_ADPCM_IMA_QT, NULL)
460 FFAT_ENC(alac,         AV_CODEC_ID_ALAC,         NULL, | AV_CODEC_CAP_VARIABLE_FRAME_SIZE | AV_CODEC_CAP_LOSSLESS)
461 FFAT_ENC(ilbc,         AV_CODEC_ID_ILBC,         NULL)
462 FFAT_ENC(pcm_alaw,     AV_CODEC_ID_PCM_ALAW,     NULL)
463 FFAT_ENC(pcm_mulaw,    AV_CODEC_ID_PCM_MULAW,    NULL)