diff options
Diffstat (limited to 'libavcodec/audiotoolboxdec.c')
-rw-r--r-- | libavcodec/audiotoolboxdec.c | 617 |
1 files changed, 617 insertions, 0 deletions
diff --git a/libavcodec/audiotoolboxdec.c b/libavcodec/audiotoolboxdec.c new file mode 100644 index 0000000..5c0a9de --- /dev/null +++ b/libavcodec/audiotoolboxdec.c @@ -0,0 +1,617 @@ +/* + * Audio Toolbox system codecs + * + * copyright (c) 2016 Rodger Combs + * + * This file is part of FFmpeg. + * + * FFmpeg is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * FFmpeg is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with FFmpeg; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#include <AudioToolbox/AudioToolbox.h> + +#include "config.h" +#include "avcodec.h" +#include "ac3_parser_internal.h" +#include "bytestream.h" +#include "internal.h" +#include "mpegaudiodecheader.h" +#include "libavutil/avassert.h" +#include "libavutil/opt.h" +#include "libavutil/log.h" + +#if __MAC_OS_X_VERSION_MIN_REQUIRED < 101100 +#define kAudioFormatEnhancedAC3 'ec-3' +#endif + +typedef struct ATDecodeContext { + AVClass *av_class; + + AudioConverterRef converter; + AudioStreamPacketDescription pkt_desc; + AVPacket in_pkt; + AVPacket new_in_pkt; + char *decoded_data; + int channel_map[64]; + + uint8_t *extradata; + int extradata_size; + + int64_t last_pts; + int eof; +} ATDecodeContext; + +static UInt32 ffat_get_format_id(enum AVCodecID codec, int profile) +{ + switch (codec) { + case AV_CODEC_ID_AAC: + return kAudioFormatMPEG4AAC; + case AV_CODEC_ID_AC3: + return kAudioFormatAC3; + case AV_CODEC_ID_ADPCM_IMA_QT: + return kAudioFormatAppleIMA4; + case AV_CODEC_ID_ALAC: + return kAudioFormatAppleLossless; + case AV_CODEC_ID_AMR_NB: + return kAudioFormatAMR; + case AV_CODEC_ID_EAC3: + return kAudioFormatEnhancedAC3; + case AV_CODEC_ID_GSM_MS: + return kAudioFormatMicrosoftGSM; + case AV_CODEC_ID_ILBC: + return kAudioFormatiLBC; + case AV_CODEC_ID_MP1: + return kAudioFormatMPEGLayer1; + case AV_CODEC_ID_MP2: + return kAudioFormatMPEGLayer2; + case AV_CODEC_ID_MP3: + return kAudioFormatMPEGLayer3; + case AV_CODEC_ID_PCM_ALAW: + return kAudioFormatALaw; + case AV_CODEC_ID_PCM_MULAW: + return kAudioFormatULaw; + case AV_CODEC_ID_QDMC: + return kAudioFormatQDesign; + case AV_CODEC_ID_QDM2: + return kAudioFormatQDesign2; + default: + av_assert0(!"Invalid codec ID!"); + return 0; + } +} + +static int ffat_get_channel_id(AudioChannelLabel label) +{ + if (label == 0) + return -1; + else if (label <= kAudioChannelLabel_LFEScreen) + return label - 1; + else if (label <= kAudioChannelLabel_RightSurround) + return label + 4; + else if (label <= kAudioChannelLabel_CenterSurround) + return label + 1; + else if (label <= kAudioChannelLabel_RightSurroundDirect) + return label + 23; + else if (label <= kAudioChannelLabel_TopBackRight) + return label - 1; + else if (label < kAudioChannelLabel_RearSurroundLeft) + return -1; + else if (label <= kAudioChannelLabel_RearSurroundRight) + return label - 29; + else if (label <= kAudioChannelLabel_RightWide) + return label - 4; + else if (label == kAudioChannelLabel_LFE2) + return ff_ctzll(AV_CH_LOW_FREQUENCY_2); + else if (label == kAudioChannelLabel_Mono) + return ff_ctzll(AV_CH_FRONT_CENTER); + else + return -1; +} + +static int ffat_compare_channel_descriptions(const void* a, const void* b) +{ + const AudioChannelDescription* da = a; + const AudioChannelDescription* db = b; + return ffat_get_channel_id(da->mChannelLabel) - ffat_get_channel_id(db->mChannelLabel); +} + +static AudioChannelLayout *ffat_convert_layout(AudioChannelLayout *layout, UInt32* size) +{ + AudioChannelLayoutTag tag = layout->mChannelLayoutTag; + AudioChannelLayout *new_layout; + if (tag == kAudioChannelLayoutTag_UseChannelDescriptions) + return layout; + else if (tag == kAudioChannelLayoutTag_UseChannelBitmap) + AudioFormatGetPropertyInfo(kAudioFormatProperty_ChannelLayoutForBitmap, + sizeof(UInt32), &layout->mChannelBitmap, size); + else + AudioFormatGetPropertyInfo(kAudioFormatProperty_ChannelLayoutForTag, + sizeof(AudioChannelLayoutTag), &tag, size); + new_layout = av_malloc(*size); + if (!new_layout) { + av_free(layout); + return NULL; + } + if (tag == kAudioChannelLayoutTag_UseChannelBitmap) + AudioFormatGetProperty(kAudioFormatProperty_ChannelLayoutForBitmap, + sizeof(UInt32), &layout->mChannelBitmap, size, new_layout); + else + AudioFormatGetProperty(kAudioFormatProperty_ChannelLayoutForTag, + sizeof(AudioChannelLayoutTag), &tag, size, new_layout); + new_layout->mChannelLayoutTag = kAudioChannelLayoutTag_UseChannelDescriptions; + av_free(layout); + return new_layout; +} + +static int ffat_update_ctx(AVCodecContext *avctx) +{ + ATDecodeContext *at = avctx->priv_data; + AudioStreamBasicDescription format; + UInt32 size = sizeof(format); + if (!AudioConverterGetProperty(at->converter, + kAudioConverterCurrentInputStreamDescription, + &size, &format)) { + if (format.mSampleRate) + avctx->sample_rate = format.mSampleRate; + avctx->channels = format.mChannelsPerFrame; + avctx->channel_layout = av_get_default_channel_layout(avctx->channels); + avctx->frame_size = format.mFramesPerPacket; + } + + if (!AudioConverterGetProperty(at->converter, + kAudioConverterCurrentOutputStreamDescription, + &size, &format)) { + format.mSampleRate = avctx->sample_rate; + format.mChannelsPerFrame = avctx->channels; + AudioConverterSetProperty(at->converter, + kAudioConverterCurrentOutputStreamDescription, + size, &format); + } + + if (!AudioConverterGetPropertyInfo(at->converter, kAudioConverterOutputChannelLayout, + &size, NULL) && size) { + AudioChannelLayout *layout = av_malloc(size); + uint64_t layout_mask = 0; + int i; + if (!layout) + return AVERROR(ENOMEM); + AudioConverterGetProperty(at->converter, kAudioConverterOutputChannelLayout, + &size, layout); + if (!(layout = ffat_convert_layout(layout, &size))) + return AVERROR(ENOMEM); + for (i = 0; i < layout->mNumberChannelDescriptions; i++) { + int id = ffat_get_channel_id(layout->mChannelDescriptions[i].mChannelLabel); + if (id < 0) + goto done; + if (layout_mask & (1 << id)) + goto done; + layout_mask |= 1 << id; + layout->mChannelDescriptions[i].mChannelFlags = i; // Abusing flags as index + } + avctx->channel_layout = layout_mask; + qsort(layout->mChannelDescriptions, layout->mNumberChannelDescriptions, + sizeof(AudioChannelDescription), &ffat_compare_channel_descriptions); + for (i = 0; i < layout->mNumberChannelDescriptions; i++) + at->channel_map[i] = layout->mChannelDescriptions[i].mChannelFlags; +done: + av_free(layout); + } + + if (!avctx->frame_size) + avctx->frame_size = 2048; + + return 0; +} + +static void put_descr(PutByteContext *pb, int tag, unsigned int size) +{ + int i = 3; + bytestream2_put_byte(pb, tag); + for (; i > 0; i--) + bytestream2_put_byte(pb, (size >> (7 * i)) | 0x80); + bytestream2_put_byte(pb, size & 0x7F); +} + +static uint8_t* ffat_get_magic_cookie(AVCodecContext *avctx, UInt32 *cookie_size) +{ + ATDecodeContext *at = avctx->priv_data; + if (avctx->codec_id == AV_CODEC_ID_AAC) { + char *extradata; + PutByteContext pb; + *cookie_size = 5 + 3 + 5+13 + 5+at->extradata_size; + if (!(extradata = av_malloc(*cookie_size))) + return NULL; + + bytestream2_init_writer(&pb, extradata, *cookie_size); + + // ES descriptor + put_descr(&pb, 0x03, 3 + 5+13 + 5+at->extradata_size); + bytestream2_put_be16(&pb, 0); + bytestream2_put_byte(&pb, 0x00); // flags (= no flags) + + // DecoderConfig descriptor + put_descr(&pb, 0x04, 13 + 5+at->extradata_size); + + // Object type indication + bytestream2_put_byte(&pb, 0x40); + + bytestream2_put_byte(&pb, 0x15); // flags (= Audiostream) + + bytestream2_put_be24(&pb, 0); // Buffersize DB + + bytestream2_put_be32(&pb, 0); // maxbitrate + bytestream2_put_be32(&pb, 0); // avgbitrate + + // DecoderSpecific info descriptor + put_descr(&pb, 0x05, at->extradata_size); + bytestream2_put_buffer(&pb, at->extradata, at->extradata_size); + return extradata; + } else { + *cookie_size = at->extradata_size; + return at->extradata; + } +} + +static av_cold int ffat_usable_extradata(AVCodecContext *avctx) +{ + ATDecodeContext *at = avctx->priv_data; + return at->extradata_size && + (avctx->codec_id == AV_CODEC_ID_ALAC || + avctx->codec_id == AV_CODEC_ID_QDM2 || + avctx->codec_id == AV_CODEC_ID_QDMC || + avctx->codec_id == AV_CODEC_ID_AAC); +} + +static int ffat_set_extradata(AVCodecContext *avctx) +{ + ATDecodeContext *at = avctx->priv_data; + if (ffat_usable_extradata(avctx)) { + OSStatus status; + UInt32 cookie_size; + uint8_t *cookie = ffat_get_magic_cookie(avctx, &cookie_size); + if (!cookie) + return AVERROR(ENOMEM); + + status = AudioConverterSetProperty(at->converter, + kAudioConverterDecompressionMagicCookie, + cookie_size, cookie); + if (status != 0) + av_log(avctx, AV_LOG_WARNING, "AudioToolbox cookie error: %i\n", (int)status); + + if (cookie != at->extradata) + av_free(cookie); + } + return 0; +} + +static av_cold int ffat_create_decoder(AVCodecContext *avctx, AVPacket *pkt) +{ + ATDecodeContext *at = avctx->priv_data; + OSStatus status; + int i; + + enum AVSampleFormat sample_fmt = (avctx->bits_per_raw_sample == 32) ? + AV_SAMPLE_FMT_S32 : AV_SAMPLE_FMT_S16; + + AudioStreamBasicDescription in_format = { + .mFormatID = ffat_get_format_id(avctx->codec_id, avctx->profile), + .mBytesPerPacket = (avctx->codec_id == AV_CODEC_ID_ILBC) ? avctx->block_align : 0, + }; + AudioStreamBasicDescription out_format = { + .mFormatID = kAudioFormatLinearPCM, + .mFormatFlags = kAudioFormatFlagIsSignedInteger | kAudioFormatFlagIsPacked, + .mFramesPerPacket = 1, + .mBitsPerChannel = av_get_bytes_per_sample(sample_fmt) * 8, + }; + + avctx->sample_fmt = sample_fmt; + + if (ffat_usable_extradata(avctx)) { + UInt32 format_size = sizeof(in_format); + UInt32 cookie_size; + uint8_t *cookie = ffat_get_magic_cookie(avctx, &cookie_size); + if (!cookie) + return AVERROR(ENOMEM); + status = AudioFormatGetProperty(kAudioFormatProperty_FormatInfo, + cookie_size, cookie, &format_size, &in_format); + if (cookie != at->extradata) + av_free(cookie); + if (status != 0) { + av_log(avctx, AV_LOG_ERROR, "AudioToolbox header-parse error: %i\n", (int)status); + return AVERROR_UNKNOWN; + } +#if CONFIG_MP1_AT_DECODER || CONFIG_MP2_AT_DECODER || CONFIG_MP3_AT_DECODER + } else if (pkt && pkt->size >= 4 && + (avctx->codec_id == AV_CODEC_ID_MP1 || + avctx->codec_id == AV_CODEC_ID_MP2 || + avctx->codec_id == AV_CODEC_ID_MP3)) { + enum AVCodecID codec_id; + int bit_rate; + if (ff_mpa_decode_header(AV_RB32(pkt->data), &avctx->sample_rate, + &in_format.mChannelsPerFrame, &avctx->frame_size, + &bit_rate, &codec_id) < 0) + return AVERROR_INVALIDDATA; + avctx->bit_rate = bit_rate; + in_format.mSampleRate = avctx->sample_rate; +#endif +#if CONFIG_AC3_AT_DECODER || CONFIG_EAC3_AT_DECODER + } else if (pkt && pkt->size >= 7 && + (avctx->codec_id == AV_CODEC_ID_AC3 || + avctx->codec_id == AV_CODEC_ID_EAC3)) { + AC3HeaderInfo hdr; + GetBitContext gbc; + init_get_bits(&gbc, pkt->data, pkt->size); + if (ff_ac3_parse_header(&gbc, &hdr) < 0) + return AVERROR_INVALIDDATA; + in_format.mSampleRate = hdr.sample_rate; + in_format.mChannelsPerFrame = hdr.channels; + avctx->frame_size = hdr.num_blocks * 256; + avctx->bit_rate = hdr.bit_rate; +#endif + } else { + in_format.mSampleRate = avctx->sample_rate ? avctx->sample_rate : 44100; + in_format.mChannelsPerFrame = avctx->channels ? avctx->channels : 1; + } + + avctx->sample_rate = out_format.mSampleRate = in_format.mSampleRate; + avctx->channels = out_format.mChannelsPerFrame = in_format.mChannelsPerFrame; + + if (avctx->codec_id == AV_CODEC_ID_ADPCM_IMA_QT) + in_format.mFramesPerPacket = 64; + + status = AudioConverterNew(&in_format, &out_format, &at->converter); + + if (status != 0) { + av_log(avctx, AV_LOG_ERROR, "AudioToolbox init error: %i\n", (int)status); + return AVERROR_UNKNOWN; + } + + if ((status = ffat_set_extradata(avctx)) < 0) + return status; + + for (i = 0; i < (sizeof(at->channel_map) / sizeof(at->channel_map[0])); i++) + at->channel_map[i] = i; + + ffat_update_ctx(avctx); + + if(!(at->decoded_data = av_malloc(av_get_bytes_per_sample(avctx->sample_fmt) + * avctx->frame_size * avctx->channels))) + return AVERROR(ENOMEM); + + at->last_pts = AV_NOPTS_VALUE; + + return 0; +} + +static av_cold int ffat_init_decoder(AVCodecContext *avctx) +{ + ATDecodeContext *at = avctx->priv_data; + if (avctx->extradata_size) { + at->extradata = av_mallocz(avctx->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE); + if (!at->extradata) + return AVERROR(ENOMEM); + at->extradata_size = avctx->extradata_size; + memcpy(at->extradata, avctx->extradata, avctx->extradata_size); + } + + if ((avctx->channels && avctx->sample_rate) || ffat_usable_extradata(avctx)) + return ffat_create_decoder(avctx, NULL); + else + return 0; +} + +static OSStatus ffat_decode_callback(AudioConverterRef converter, UInt32 *nb_packets, + AudioBufferList *data, + AudioStreamPacketDescription **packets, + void *inctx) +{ + AVCodecContext *avctx = inctx; + ATDecodeContext *at = avctx->priv_data; + + if (at->eof) { + *nb_packets = 0; + if (packets) { + *packets = &at->pkt_desc; + at->pkt_desc.mDataByteSize = 0; + } + return 0; + } + + av_packet_unref(&at->in_pkt); + av_packet_move_ref(&at->in_pkt, &at->new_in_pkt); + + if (!at->in_pkt.data) { + *nb_packets = 0; + return 1; + } + + data->mNumberBuffers = 1; + data->mBuffers[0].mNumberChannels = 0; + data->mBuffers[0].mDataByteSize = at->in_pkt.size; + data->mBuffers[0].mData = at->in_pkt.data; + *nb_packets = 1; + + if (packets) { + *packets = &at->pkt_desc; + at->pkt_desc.mDataByteSize = at->in_pkt.size; + } + + return 0; +} + +#define COPY_SAMPLES(type) \ + type *in_ptr = (type*)at->decoded_data; \ + type *end_ptr = in_ptr + frame->nb_samples * avctx->channels; \ + type *out_ptr = (type*)frame->data[0]; \ + for (; in_ptr < end_ptr; in_ptr += avctx->channels, out_ptr += avctx->channels) { \ + int c; \ + for (c = 0; c < avctx->channels; c++) \ + out_ptr[c] = in_ptr[at->channel_map[c]]; \ + } + +static void ffat_copy_samples(AVCodecContext *avctx, AVFrame *frame) +{ + ATDecodeContext *at = avctx->priv_data; + if (avctx->sample_fmt == AV_SAMPLE_FMT_S32) { + COPY_SAMPLES(int32_t); + } else { + COPY_SAMPLES(int16_t); + } +} + +static int ffat_decode(AVCodecContext *avctx, void *data, + int *got_frame_ptr, AVPacket *avpkt) +{ + ATDecodeContext *at = avctx->priv_data; + AVFrame *frame = data; + int pkt_size = avpkt->size; + OSStatus ret; + AudioBufferList out_buffers; + + if (avctx->codec_id == AV_CODEC_ID_AAC) { + if (!at->extradata_size) { + uint8_t *side_data; + int side_data_size = 0; + + side_data = av_packet_get_side_data(avpkt, AV_PKT_DATA_NEW_EXTRADATA, + &side_data_size); + if (side_data_size) { + at->extradata = av_mallocz(side_data_size + AV_INPUT_BUFFER_PADDING_SIZE); + if (!at->extradata) + return AVERROR(ENOMEM); + at->extradata_size = side_data_size; + memcpy(at->extradata, side_data, side_data_size); + } + } + } + + if (!at->converter) { + if ((ret = ffat_create_decoder(avctx, avpkt)) < 0) { + return ret; + } + } + + out_buffers = (AudioBufferList){ + .mNumberBuffers = 1, + .mBuffers = { + { + .mNumberChannels = avctx->channels, + .mDataByteSize = av_get_bytes_per_sample(avctx->sample_fmt) * avctx->frame_size + * avctx->channels, + } + } + }; + + av_packet_unref(&at->new_in_pkt); + + if (avpkt->size) { + if ((ret = av_packet_ref(&at->new_in_pkt, avpkt)) < 0) { + return ret; + } + } else { + at->eof = 1; + } + + frame->sample_rate = avctx->sample_rate; + + frame->nb_samples = avctx->frame_size; + + out_buffers.mBuffers[0].mData = at->decoded_data; + + ret = AudioConverterFillComplexBuffer(at->converter, ffat_decode_callback, avctx, + &frame->nb_samples, &out_buffers, NULL); + if ((!ret || ret == 1) && frame->nb_samples) { + if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) + return ret; + ffat_copy_samples(avctx, frame); + *got_frame_ptr = 1; + if (at->last_pts != AV_NOPTS_VALUE) { + frame->pts = at->last_pts; +#if FF_API_PKT_PTS +FF_DISABLE_DEPRECATION_WARNINGS + frame->pkt_pts = at->last_pts; +FF_ENABLE_DEPRECATION_WARNINGS +#endif + at->last_pts = avpkt->pts; + } + } else if (ret && ret != 1) { + av_log(avctx, AV_LOG_WARNING, "Decode error: %i\n", ret); + } else { + at->last_pts = avpkt->pts; + } + + return pkt_size; +} + +static av_cold void ffat_decode_flush(AVCodecContext *avctx) +{ + ATDecodeContext *at = avctx->priv_data; + AudioConverterReset(at->converter); + av_packet_unref(&at->new_in_pkt); + av_packet_unref(&at->in_pkt); +} + +static av_cold int ffat_close_decoder(AVCodecContext *avctx) +{ + ATDecodeContext *at = avctx->priv_data; + if (at->converter) + AudioConverterDispose(at->converter); + av_packet_unref(&at->new_in_pkt); + av_packet_unref(&at->in_pkt); + av_freep(&at->decoded_data); + av_freep(&at->extradata); + return 0; +} + +#define FFAT_DEC_CLASS(NAME) \ + static const AVClass ffat_##NAME##_dec_class = { \ + .class_name = "at_" #NAME "_dec", \ + .version = LIBAVUTIL_VERSION_INT, \ + }; + +#define FFAT_DEC(NAME, ID, bsf_name) \ + FFAT_DEC_CLASS(NAME) \ + AVCodec ff_##NAME##_at_decoder = { \ + .name = #NAME "_at", \ + .long_name = NULL_IF_CONFIG_SMALL(#NAME " (AudioToolbox)"), \ + .type = AVMEDIA_TYPE_AUDIO, \ + .id = ID, \ + .priv_data_size = sizeof(ATDecodeContext), \ + .init = ffat_init_decoder, \ + .close = ffat_close_decoder, \ + .decode = ffat_decode, \ + .flush = ffat_decode_flush, \ + .priv_class = &ffat_##NAME##_dec_class, \ + .bsfs = bsf_name, \ + .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY, \ + .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP, \ + .wrapper_name = "at", \ + }; + +FFAT_DEC(aac, AV_CODEC_ID_AAC, "aac_adtstoasc") +FFAT_DEC(ac3, AV_CODEC_ID_AC3, NULL) +FFAT_DEC(adpcm_ima_qt, AV_CODEC_ID_ADPCM_IMA_QT, NULL) +FFAT_DEC(alac, AV_CODEC_ID_ALAC, NULL) +FFAT_DEC(amr_nb, AV_CODEC_ID_AMR_NB, NULL) +FFAT_DEC(eac3, AV_CODEC_ID_EAC3, NULL) +FFAT_DEC(gsm_ms, AV_CODEC_ID_GSM_MS, NULL) +FFAT_DEC(ilbc, AV_CODEC_ID_ILBC, NULL) +FFAT_DEC(mp1, AV_CODEC_ID_MP1, NULL) +FFAT_DEC(mp2, AV_CODEC_ID_MP2, NULL) +FFAT_DEC(mp3, AV_CODEC_ID_MP3, NULL) +FFAT_DEC(pcm_alaw, AV_CODEC_ID_PCM_ALAW, NULL) +FFAT_DEC(pcm_mulaw, AV_CODEC_ID_PCM_MULAW, NULL) +FFAT_DEC(qdmc, AV_CODEC_ID_QDMC, NULL) +FFAT_DEC(qdm2, AV_CODEC_ID_QDM2, NULL) |