mirror of
https://github.com/FFmpeg/FFmpeg.git
synced 2024-12-07 11:13:41 +02:00
494f868e93
The decoders in this set either have a fixed channel count, or read it
from the bitstream, and thus do not require the channel count as
external information.
Fixes various regressions since
81503ac58a
, which requires a valid channel
count for decoders which do not set this capability.
Signed-off-by: Hendrik Leppkes <h.leppkes@gmail.com>
618 lines
21 KiB
C
618 lines
21 KiB
C
/*
|
|
* 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;
|
|
|
|
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 | AV_CODEC_CAP_CHANNEL_CONF, \
|
|
.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)
|