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