falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
87210 Commits
32 Branches
292MB
Tree: f4e593f7b5
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'f4e593f7b5'
${ noResults }
FFmpeg/libavcodec/audiotoolboxdec.c

617 lines
21KB
Raw Blame History 

  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 "ac3_parser.h"

  28. #include "bytestream.h"

  29. #include "internal.h"

  30. #include "mpegaudiodecheader.h"

  31. #include "libavutil/avassert.h"

  32. #include "libavutil/opt.h"

  33. #include "libavutil/log.h"

  34. 

  35. #if __MAC_OS_X_VERSION_MIN_REQUIRED < 101100

  36. #define kAudioFormatEnhancedAC3 'ec-3'

  37. #endif

  38. 

  39. typedef struct ATDecodeContext {

  40.     AVClass *av_class;

  41. 

  42.     AudioConverterRef converter;

  43.     AudioStreamPacketDescription pkt_desc;

  44.     AVPacket in_pkt;

  45.     AVPacket new_in_pkt;

  46.     char *decoded_data;

  47.     int channel_map[64];

  48. 

  49.     uint8_t *extradata;

  50.     int extradata_size;

  51. 

  52.     int64_t last_pts;

  53.     int eof;

  54. } ATDecodeContext;

  55. 

  56. static UInt32 ffat_get_format_id(enum AVCodecID codec, int profile)

  57. {

  58.     switch (codec) {

  59.     case AV_CODEC_ID_AAC:

  60.         return kAudioFormatMPEG4AAC;

  61.     case AV_CODEC_ID_AC3:

  62.         return kAudioFormatAC3;

  63.     case AV_CODEC_ID_ADPCM_IMA_QT:

  64.         return kAudioFormatAppleIMA4;

  65.     case AV_CODEC_ID_ALAC:

  66.         return kAudioFormatAppleLossless;

  67.     case AV_CODEC_ID_AMR_NB:

  68.         return kAudioFormatAMR;

  69.     case AV_CODEC_ID_EAC3:

  70.         return kAudioFormatEnhancedAC3;

  71.     case AV_CODEC_ID_GSM_MS:

  72.         return kAudioFormatMicrosoftGSM;

  73.     case AV_CODEC_ID_ILBC:

  74.         return kAudioFormatiLBC;

  75.     case AV_CODEC_ID_MP1:

  76.         return kAudioFormatMPEGLayer1;

  77.     case AV_CODEC_ID_MP2:

  78.         return kAudioFormatMPEGLayer2;

  79.     case AV_CODEC_ID_MP3:

  80.         return kAudioFormatMPEGLayer3;

  81.     case AV_CODEC_ID_PCM_ALAW:

  82.         return kAudioFormatALaw;

  83.     case AV_CODEC_ID_PCM_MULAW:

  84.         return kAudioFormatULaw;

  85.     case AV_CODEC_ID_QDMC:

  86.         return kAudioFormatQDesign;

  87.     case AV_CODEC_ID_QDM2:

  88.         return kAudioFormatQDesign2;

  89.     default:

  90.         av_assert0(!"Invalid codec ID!");

  91.         return 0;

  92.     }

  93. }

  94. 

  95. static int ffat_get_channel_id(AudioChannelLabel label)

  96. {

  97.     if (label == 0)

  98.         return -1;

  99.     else if (label <= kAudioChannelLabel_LFEScreen)

  100.         return label - 1;

  101.     else if (label <= kAudioChannelLabel_RightSurround)

  102.         return label + 4;

  103.     else if (label <= kAudioChannelLabel_CenterSurround)

  104.         return label + 1;

  105.     else if (label <= kAudioChannelLabel_RightSurroundDirect)

  106.         return label + 23;

  107.     else if (label <= kAudioChannelLabel_TopBackRight)

  108.         return label - 1;

  109.     else if (label < kAudioChannelLabel_RearSurroundLeft)

  110.         return -1;

  111.     else if (label <= kAudioChannelLabel_RearSurroundRight)

  112.         return label - 29;

  113.     else if (label <= kAudioChannelLabel_RightWide)

  114.         return label - 4;

  115.     else if (label == kAudioChannelLabel_LFE2)

  116.         return ff_ctzll(AV_CH_LOW_FREQUENCY_2);

  117.     else if (label == kAudioChannelLabel_Mono)

  118.         return ff_ctzll(AV_CH_FRONT_CENTER);

  119.     else

  120.         return -1;

  121. }

  122. 

  123. static int ffat_compare_channel_descriptions(const void* a, const void* b)

  124. {

  125.     const AudioChannelDescription* da = a;

  126.     const AudioChannelDescription* db = b;

  127.     return ffat_get_channel_id(da->mChannelLabel) - ffat_get_channel_id(db->mChannelLabel);

  128. }

  129. 

  130. static AudioChannelLayout *ffat_convert_layout(AudioChannelLayout *layout, UInt32* size)

  131. {

  132.     AudioChannelLayoutTag tag = layout->mChannelLayoutTag;

  133.     AudioChannelLayout *new_layout;

  134.     if (tag == kAudioChannelLayoutTag_UseChannelDescriptions)

  135.         return layout;

  136.     else if (tag == kAudioChannelLayoutTag_UseChannelBitmap)

  137.         AudioFormatGetPropertyInfo(kAudioFormatProperty_ChannelLayoutForBitmap,

  138.                                    sizeof(UInt32), &layout->mChannelBitmap, size);

  139.     else

  140.         AudioFormatGetPropertyInfo(kAudioFormatProperty_ChannelLayoutForTag,

  141.                                    sizeof(AudioChannelLayoutTag), &tag, size);

  142.     new_layout = av_malloc(*size);

  143.     if (!new_layout) {

  144.         av_free(layout);

  145.         return NULL;

  146.     }

  147.     if (tag == kAudioChannelLayoutTag_UseChannelBitmap)

  148.         AudioFormatGetProperty(kAudioFormatProperty_ChannelLayoutForBitmap,

  149.                                sizeof(UInt32), &layout->mChannelBitmap, size, new_layout);

  150.     else

  151.         AudioFormatGetProperty(kAudioFormatProperty_ChannelLayoutForTag,

  152.                                sizeof(AudioChannelLayoutTag), &tag, size, new_layout);

  153.     new_layout->mChannelLayoutTag = kAudioChannelLayoutTag_UseChannelDescriptions;

  154.     av_free(layout);

  155.     return new_layout;

  156. }

  157. 

  158. static int ffat_update_ctx(AVCodecContext *avctx)

  159. {

  160.     ATDecodeContext *at = avctx->priv_data;

  161.     AudioStreamBasicDescription format;

  162.     UInt32 size = sizeof(format);

  163.     if (!AudioConverterGetProperty(at->converter,

  164.                                    kAudioConverterCurrentInputStreamDescription,

  165.                                    &size, &format)) {

  166.         if (format.mSampleRate)

  167.             avctx->sample_rate = format.mSampleRate;

  168.         avctx->channels = format.mChannelsPerFrame;

  169.         avctx->channel_layout = av_get_default_channel_layout(avctx->channels);

  170.         avctx->frame_size = format.mFramesPerPacket;

  171.     }

  172. 

  173.     if (!AudioConverterGetProperty(at->converter,

  174.                                    kAudioConverterCurrentOutputStreamDescription,

  175.                                    &size, &format)) {

  176.         format.mSampleRate = avctx->sample_rate;

  177.         format.mChannelsPerFrame = avctx->channels;

  178.         AudioConverterSetProperty(at->converter,

  179.                                   kAudioConverterCurrentOutputStreamDescription,

  180.                                   size, &format);

  181.     }

  182. 

  183.     if (!AudioConverterGetPropertyInfo(at->converter, kAudioConverterOutputChannelLayout,

  184.                                        &size, NULL) && size) {

  185.         AudioChannelLayout *layout = av_malloc(size);

  186.         uint64_t layout_mask = 0;

  187.         int i;

  188.         if (!layout)

  189.             return AVERROR(ENOMEM);

  190.         AudioConverterGetProperty(at->converter, kAudioConverterOutputChannelLayout,

  191.                                   &size, layout);

  192.         if (!(layout = ffat_convert_layout(layout, &size)))

  193.             return AVERROR(ENOMEM);

  194.         for (i = 0; i < layout->mNumberChannelDescriptions; i++) {

  195.             int id = ffat_get_channel_id(layout->mChannelDescriptions[i].mChannelLabel);

  196.             if (id < 0)

  197.                 goto done;

  198.             if (layout_mask & (1 << id))

  199.                 goto done;

  200.             layout_mask |= 1 << id;

  201.             layout->mChannelDescriptions[i].mChannelFlags = i; // Abusing flags as index

  202.         }

  203.         avctx->channel_layout = layout_mask;

  204.         qsort(layout->mChannelDescriptions, layout->mNumberChannelDescriptions,

  205.               sizeof(AudioChannelDescription), &ffat_compare_channel_descriptions);

  206.         for (i = 0; i < layout->mNumberChannelDescriptions; i++)

  207.             at->channel_map[i] = layout->mChannelDescriptions[i].mChannelFlags;

  208. done:

  209.         av_free(layout);

  210.     }

  211. 

  212.     if (!avctx->frame_size)

  213.         avctx->frame_size = 2048;

  214. 

  215.     return 0;

  216. }

  217. 

  218. static void put_descr(PutByteContext *pb, int tag, unsigned int size)

  219. {

  220.     int i = 3;

  221.     bytestream2_put_byte(pb, tag);

  222.     for (; i > 0; i--)

  223.         bytestream2_put_byte(pb, (size >> (7 * i)) | 0x80);

  224.     bytestream2_put_byte(pb, size & 0x7F);

  225. }

  226. 

  227. static uint8_t* ffat_get_magic_cookie(AVCodecContext *avctx, UInt32 *cookie_size)

  228. {

  229.     ATDecodeContext *at = avctx->priv_data;

  230.     if (avctx->codec_id == AV_CODEC_ID_AAC) {

  231.         char *extradata;

  232.         PutByteContext pb;

  233.         *cookie_size = 5 + 3 + 5+13 + 5+at->extradata_size;

  234.         if (!(extradata = av_malloc(*cookie_size)))

  235.             return NULL;

  236. 

  237.         bytestream2_init_writer(&pb, extradata, *cookie_size);

  238. 

  239.         // ES descriptor

  240.         put_descr(&pb, 0x03, 3 + 5+13 + 5+at->extradata_size);

  241.         bytestream2_put_be16(&pb, 0);

  242.         bytestream2_put_byte(&pb, 0x00); // flags (= no flags)

  243. 

  244.         // DecoderConfig descriptor

  245.         put_descr(&pb, 0x04, 13 + 5+at->extradata_size);

  246. 

  247.         // Object type indication

  248.         bytestream2_put_byte(&pb, 0x40);

  249. 

  250.         bytestream2_put_byte(&pb, 0x15); // flags (= Audiostream)

  251. 

  252.         bytestream2_put_be24(&pb, 0); // Buffersize DB

  253. 

  254.         bytestream2_put_be32(&pb, 0); // maxbitrate

  255.         bytestream2_put_be32(&pb, 0); // avgbitrate

  256. 

  257.         // DecoderSpecific info descriptor

  258.         put_descr(&pb, 0x05, at->extradata_size);

  259.         bytestream2_put_buffer(&pb, at->extradata, at->extradata_size);

  260.         return extradata;

  261.     } else {

  262.         *cookie_size = at->extradata_size;

  263.         return at->extradata;

  264.     }

  265. }

  266. 

  267. static av_cold int ffat_usable_extradata(AVCodecContext *avctx)

  268. {

  269.     ATDecodeContext *at = avctx->priv_data;

  270.     return at->extradata_size &&

  271.            (avctx->codec_id == AV_CODEC_ID_ALAC ||

  272.             avctx->codec_id == AV_CODEC_ID_QDM2 ||

  273.             avctx->codec_id == AV_CODEC_ID_QDMC ||

  274.             avctx->codec_id == AV_CODEC_ID_AAC);

  275. }

  276. 

  277. static int ffat_set_extradata(AVCodecContext *avctx)

  278. {

  279.     ATDecodeContext *at = avctx->priv_data;

  280.     if (ffat_usable_extradata(avctx)) {

  281.         OSStatus status;

  282.         UInt32 cookie_size;

  283.         uint8_t *cookie = ffat_get_magic_cookie(avctx, &cookie_size);

  284.         if (!cookie)

  285.             return AVERROR(ENOMEM);

  286. 

  287.         status = AudioConverterSetProperty(at->converter,

  288.                                            kAudioConverterDecompressionMagicCookie,

  289.                                            cookie_size, cookie);

  290.         if (status != 0)

  291.             av_log(avctx, AV_LOG_WARNING, "AudioToolbox cookie error: %i\n", (int)status);

  292. 

  293.         if (cookie != at->extradata)

  294.             av_free(cookie);

  295.     }

  296.     return 0;

  297. }

  298. 

  299. static av_cold int ffat_create_decoder(AVCodecContext *avctx, AVPacket *pkt)

  300. {

  301.     ATDecodeContext *at = avctx->priv_data;

  302.     OSStatus status;

  303.     int i;

  304. 

  305.     enum AVSampleFormat sample_fmt = (avctx->bits_per_raw_sample == 32) ?

  306.                                      AV_SAMPLE_FMT_S32 : AV_SAMPLE_FMT_S16;

  307. 

  308.     AudioStreamBasicDescription in_format = {

  309.         .mFormatID = ffat_get_format_id(avctx->codec_id, avctx->profile),

  310.         .mBytesPerPacket = (avctx->codec_id == AV_CODEC_ID_ILBC) ? avctx->block_align : 0,

  311.     };

  312.     AudioStreamBasicDescription out_format = {

  313.         .mFormatID = kAudioFormatLinearPCM,

  314.         .mFormatFlags = kAudioFormatFlagIsSignedInteger | kAudioFormatFlagIsPacked,

  315.         .mFramesPerPacket = 1,

  316.         .mBitsPerChannel = av_get_bytes_per_sample(sample_fmt) * 8,

  317.     };

  318. 

  319.     avctx->sample_fmt = sample_fmt;

  320. 

  321.     if (ffat_usable_extradata(avctx)) {

  322.         UInt32 format_size = sizeof(in_format);

  323.         UInt32 cookie_size;

  324.         uint8_t *cookie = ffat_get_magic_cookie(avctx, &cookie_size);

  325.         if (!cookie)

  326.             return AVERROR(ENOMEM);

  327.         status = AudioFormatGetProperty(kAudioFormatProperty_FormatInfo,

  328.                                         cookie_size, cookie, &format_size, &in_format);

  329.         if (cookie != at->extradata)

  330.             av_free(cookie);

  331.         if (status != 0) {

  332.             av_log(avctx, AV_LOG_ERROR, "AudioToolbox header-parse error: %i\n", (int)status);

  333.             return AVERROR_UNKNOWN;

  334.         }

  335. #if CONFIG_MP1_AT_DECODER || CONFIG_MP2_AT_DECODER || CONFIG_MP3_AT_DECODER

  336.     } else if (pkt && pkt->size >= 4 &&

  337.                (avctx->codec_id == AV_CODEC_ID_MP1 ||

  338.                 avctx->codec_id == AV_CODEC_ID_MP2 ||

  339.                 avctx->codec_id == AV_CODEC_ID_MP3)) {

  340.         enum AVCodecID codec_id;

  341.         int bit_rate;

  342.         if (ff_mpa_decode_header(AV_RB32(pkt->data), &avctx->sample_rate,

  343.                                  &in_format.mChannelsPerFrame, &avctx->frame_size,

  344.                                  &bit_rate, &codec_id) < 0)

  345.             return AVERROR_INVALIDDATA;

  346.         avctx->bit_rate = bit_rate;

  347.         in_format.mSampleRate = avctx->sample_rate;

  348. #endif

  349. #if CONFIG_AC3_AT_DECODER || CONFIG_EAC3_AT_DECODER

  350.     } else if (pkt && pkt->size >= 7 &&

  351.                (avctx->codec_id == AV_CODEC_ID_AC3 ||

  352.                 avctx->codec_id == AV_CODEC_ID_EAC3)) {

  353.         AC3HeaderInfo hdr, *phdr = &hdr;

  354.         GetBitContext gbc;

  355.         init_get_bits(&gbc, pkt->data, pkt->size);

  356.         if (avpriv_ac3_parse_header(&gbc, &phdr) < 0)

  357.             return AVERROR_INVALIDDATA;

  358.         in_format.mSampleRate = hdr.sample_rate;

  359.         in_format.mChannelsPerFrame = hdr.channels;

  360.         avctx->frame_size = hdr.num_blocks * 256;

  361.         avctx->bit_rate = hdr.bit_rate;

  362. #endif

  363.     } else {

  364.         in_format.mSampleRate = avctx->sample_rate ? avctx->sample_rate : 44100;

  365.         in_format.mChannelsPerFrame = avctx->channels ? avctx->channels : 1;

  366.     }

  367. 

  368.     avctx->sample_rate = out_format.mSampleRate = in_format.mSampleRate;

  369.     avctx->channels = out_format.mChannelsPerFrame = in_format.mChannelsPerFrame;

  370. 

  371.     if (avctx->codec_id == AV_CODEC_ID_ADPCM_IMA_QT)

  372.         in_format.mFramesPerPacket = 64;

  373. 

  374.     status = AudioConverterNew(&in_format, &out_format, &at->converter);

  375. 

  376.     if (status != 0) {

  377.         av_log(avctx, AV_LOG_ERROR, "AudioToolbox init error: %i\n", (int)status);

  378.         return AVERROR_UNKNOWN;

  379.     }

  380. 

  381.     if ((status = ffat_set_extradata(avctx)) < 0)

  382.         return status;

  383. 

  384.     for (i = 0; i < (sizeof(at->channel_map) / sizeof(at->channel_map[0])); i++)

  385.         at->channel_map[i] = i;

  386. 

  387.     ffat_update_ctx(avctx);

  388. 

  389.     if(!(at->decoded_data = av_malloc(av_get_bytes_per_sample(avctx->sample_fmt)

  390.                                       * avctx->frame_size * avctx->channels)))

  391.         return AVERROR(ENOMEM);

  392. 

  393.     at->last_pts = AV_NOPTS_VALUE;

  394. 

  395.     return 0;

  396. }

  397. 

  398. static av_cold int ffat_init_decoder(AVCodecContext *avctx)

  399. {

  400.     ATDecodeContext *at = avctx->priv_data;

  401.     if (avctx->extradata_size) {

  402.         at->extradata = av_mallocz(avctx->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);

  403.         if (!at->extradata)

  404.             return AVERROR(ENOMEM);

  405.         at->extradata_size = avctx->extradata_size;

  406.         memcpy(at->extradata, avctx->extradata, avctx->extradata_size);

  407.     }

  408. 

  409.     if ((avctx->channels && avctx->sample_rate) || ffat_usable_extradata(avctx))

  410.         return ffat_create_decoder(avctx, NULL);

  411.     else

  412.         return 0;

  413. }

  414. 

  415. static OSStatus ffat_decode_callback(AudioConverterRef converter, UInt32 *nb_packets,

  416.                                      AudioBufferList *data,

  417.                                      AudioStreamPacketDescription **packets,

  418.                                      void *inctx)

  419. {

  420.     AVCodecContext *avctx = inctx;

  421.     ATDecodeContext *at = avctx->priv_data;

  422. 

  423.     if (at->eof) {

  424.         *nb_packets = 0;

  425.         if (packets) {

  426.             *packets = &at->pkt_desc;

  427.             at->pkt_desc.mDataByteSize = 0;

  428.         }

  429.         return 0;

  430.     }

  431. 

  432.     av_packet_unref(&at->in_pkt);

  433.     av_packet_move_ref(&at->in_pkt, &at->new_in_pkt);

  434. 

  435.     if (!at->in_pkt.data) {

  436.         *nb_packets = 0;

  437.         return 1;

  438.     }

  439. 

  440.     data->mNumberBuffers              = 1;

  441.     data->mBuffers[0].mNumberChannels = 0;

  442.     data->mBuffers[0].mDataByteSize   = at->in_pkt.size;

  443.     data->mBuffers[0].mData           = at->in_pkt.data;

  444.     *nb_packets = 1;

  445. 

  446.     if (packets) {

  447.         *packets = &at->pkt_desc;

  448.         at->pkt_desc.mDataByteSize = at->in_pkt.size;

  449.     }

  450. 

  451.     return 0;

  452. }

  453. 

  454. #define COPY_SAMPLES(type) \

  455.     type *in_ptr = (type*)at->decoded_data; \

  456.     type *end_ptr = in_ptr + frame->nb_samples * avctx->channels; \

  457.     type *out_ptr = (type*)frame->data[0]; \

  458.     for (; in_ptr < end_ptr; in_ptr += avctx->channels, out_ptr += avctx->channels) { \

  459.         int c; \

  460.         for (c = 0; c < avctx->channels; c++) \

  461.             out_ptr[c] = in_ptr[at->channel_map[c]]; \

  462.     }

  463. 

  464. static void ffat_copy_samples(AVCodecContext *avctx, AVFrame *frame)

  465. {

  466.     ATDecodeContext *at = avctx->priv_data;

  467.     if (avctx->sample_fmt == AV_SAMPLE_FMT_S32) {

  468.         COPY_SAMPLES(int32_t);

  469.     } else {

  470.         COPY_SAMPLES(int16_t);

  471.     }

  472. }

  473. 

  474. static int ffat_decode(AVCodecContext *avctx, void *data,

  475.                        int *got_frame_ptr, AVPacket *avpkt)

  476. {

  477.     ATDecodeContext *at = avctx->priv_data;

  478.     AVFrame *frame = data;

  479.     int pkt_size = avpkt->size;

  480.     OSStatus ret;

  481.     AudioBufferList out_buffers;

  482. 

  483.     if (avctx->codec_id == AV_CODEC_ID_AAC) {

  484.         if (!at->extradata_size) {

  485.             uint8_t *side_data;

  486.             int side_data_size = 0;

  487. 

  488.             side_data = av_packet_get_side_data(avpkt, AV_PKT_DATA_NEW_EXTRADATA,

  489.                                                 &side_data_size);

  490.             if (side_data_size) {

  491.                 at->extradata = av_mallocz(side_data_size + AV_INPUT_BUFFER_PADDING_SIZE);

  492.                 if (!at->extradata)

  493.                     return AVERROR(ENOMEM);

  494.                 at->extradata_size = side_data_size;

  495.                 memcpy(at->extradata, side_data, side_data_size);

  496.             }

  497.         }

  498.     }

  499. 

  500.     if (!at->converter) {

  501.         if ((ret = ffat_create_decoder(avctx, avpkt)) < 0) {

  502.             return ret;

  503.         }

  504.     }

  505. 

  506.     out_buffers = (AudioBufferList){

  507.         .mNumberBuffers = 1,

  508.         .mBuffers = {

  509.             {

  510.                 .mNumberChannels = avctx->channels,

  511.                 .mDataByteSize = av_get_bytes_per_sample(avctx->sample_fmt) * avctx->frame_size

  512.                                  * avctx->channels,

  513.             }

  514.         }

  515.     };

  516. 

  517.     av_packet_unref(&at->new_in_pkt);

  518. 

  519.     if (avpkt->size) {

  520.         if ((ret = av_packet_ref(&at->new_in_pkt, avpkt)) < 0) {

  521.             return ret;

  522.         }

  523.     } else {

  524.         at->eof = 1;

  525.     }

  526. 

  527.     frame->sample_rate = avctx->sample_rate;

  528. 

  529.     frame->nb_samples = avctx->frame_size;

  530. 

  531.     out_buffers.mBuffers[0].mData = at->decoded_data;

  532. 

  533.     ret = AudioConverterFillComplexBuffer(at->converter, ffat_decode_callback, avctx,

  534.                                           &frame->nb_samples, &out_buffers, NULL);

  535.     if ((!ret || ret == 1) && frame->nb_samples) {

  536.         if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)

  537.             return ret;

  538.         ffat_copy_samples(avctx, frame);

  539.         *got_frame_ptr = 1;

  540.         if (at->last_pts != AV_NOPTS_VALUE) {

  541.             frame->pts = at->last_pts;

  542. #if FF_API_PKT_PTS

  543. FF_DISABLE_DEPRECATION_WARNINGS

  544.             frame->pkt_pts = at->last_pts;

  545. FF_ENABLE_DEPRECATION_WARNINGS

  546. #endif

  547.             at->last_pts = avpkt->pts;

  548.         }

  549.     } else if (ret && ret != 1) {

  550.         av_log(avctx, AV_LOG_WARNING, "Decode error: %i\n", ret);

  551.     } else {

  552.         at->last_pts = avpkt->pts;

  553.     }

  554. 

  555.     return pkt_size;

  556. }

  557. 

  558. static av_cold void ffat_decode_flush(AVCodecContext *avctx)

  559. {

  560.     ATDecodeContext *at = avctx->priv_data;

  561.     AudioConverterReset(at->converter);

  562.     av_packet_unref(&at->new_in_pkt);

  563.     av_packet_unref(&at->in_pkt);

  564. }

  565. 

  566. static av_cold int ffat_close_decoder(AVCodecContext *avctx)

  567. {

  568.     ATDecodeContext *at = avctx->priv_data;

  569.     if (at->converter)

  570.         AudioConverterDispose(at->converter);

  571.     av_packet_unref(&at->new_in_pkt);

  572.     av_packet_unref(&at->in_pkt);

  573.     av_freep(&at->decoded_data);

  574.     av_freep(&at->extradata);

  575.     return 0;

  576. }

  577. 

  578. #define FFAT_DEC_CLASS(NAME) \

  579.     static const AVClass ffat_##NAME##_dec_class = { \

  580.         .class_name = "at_" #NAME "_dec", \

  581.         .version    = LIBAVUTIL_VERSION_INT, \

  582.     };

  583. 

  584. #define FFAT_DEC(NAME, ID, bsf_name) \

  585.     FFAT_DEC_CLASS(NAME) \

  586.     AVCodec ff_##NAME##_at_decoder = { \

  587.         .name           = #NAME "_at", \

  588.         .long_name      = NULL_IF_CONFIG_SMALL(#NAME " (AudioToolbox)"), \

  589.         .type           = AVMEDIA_TYPE_AUDIO, \

  590.         .id             = ID, \

  591.         .priv_data_size = sizeof(ATDecodeContext), \

  592.         .init           = ffat_init_decoder, \

  593.         .close          = ffat_close_decoder, \

  594.         .decode         = ffat_decode, \

  595.         .flush          = ffat_decode_flush, \

  596.         .priv_class     = &ffat_##NAME##_dec_class, \

  597.         .bsfs           = bsf_name, \

  598.         .capabilities   = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY, \

  599.         .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP, \

  600.     };

  601. 

  602. FFAT_DEC(aac,          AV_CODEC_ID_AAC, "aac_adtstoasc")

  603. FFAT_DEC(ac3,          AV_CODEC_ID_AC3, NULL)

  604. FFAT_DEC(adpcm_ima_qt, AV_CODEC_ID_ADPCM_IMA_QT, NULL)

  605. FFAT_DEC(alac,         AV_CODEC_ID_ALAC, NULL)

  606. FFAT_DEC(amr_nb,       AV_CODEC_ID_AMR_NB, NULL)

  607. FFAT_DEC(eac3,         AV_CODEC_ID_EAC3, NULL)

  608. FFAT_DEC(gsm_ms,       AV_CODEC_ID_GSM_MS, NULL)

  609. FFAT_DEC(ilbc,         AV_CODEC_ID_ILBC, NULL)

  610. FFAT_DEC(mp1,          AV_CODEC_ID_MP1, NULL)

  611. FFAT_DEC(mp2,          AV_CODEC_ID_MP2, NULL)

  612. FFAT_DEC(mp3,          AV_CODEC_ID_MP3, NULL)

  613. FFAT_DEC(pcm_alaw,     AV_CODEC_ID_PCM_ALAW, NULL)

  614. FFAT_DEC(pcm_mulaw,    AV_CODEC_ID_PCM_MULAW, NULL)

  615. FFAT_DEC(qdmc,         AV_CODEC_ID_QDMC, NULL)

  616. FFAT_DEC(qdm2,         AV_CODEC_ID_QDM2, NULL)