FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
audiotoolboxdec.c
Go to the documentation of this file.
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_internal.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 {
41 
42  AudioConverterRef converter;
43  AudioStreamPacketDescription pkt_desc;
46  char *decoded_data;
47  int channel_map[64];
48 
51 
52  int64_t last_pts;
53  int eof;
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;
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:
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;
82  return kAudioFormatALaw;
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)
117  else if (label == kAudioChannelLabel_Mono)
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;
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);
260  return extradata;
261  } else {
262  *cookie_size = at->extradata_size;
263  return at->extradata;
264  }
265 }
266 
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 
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 
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) ?
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;
354  GetBitContext gbc;
355  init_get_bits(&gbc, pkt->data, pkt->size);
356  if (ff_ac3_parse_header(&gbc, &hdr) < 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 
390  * avctx->frame_size * avctx->channels)))
391  return AVERROR(ENOMEM);
392 
393  at->last_pts = AV_NOPTS_VALUE;
394 
395  return 0;
396 }
397 
399 {
400  ATDecodeContext *at = avctx->priv_data;
401  if (avctx->extradata_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);
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 
465 {
466  ATDecodeContext *at = avctx->priv_data;
467  if (avctx->sample_fmt == AV_SAMPLE_FMT_S32) {
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 
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 
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
544  frame->pkt_pts = at->last_pts;
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 
559 {
560  ATDecodeContext *at = avctx->priv_data;
561  AudioConverterReset(at->converter);
563  av_packet_unref(&at->in_pkt);
564 }
565 
567 {
568  ATDecodeContext *at = avctx->priv_data;
569  if (at->converter)
570  AudioConverterDispose(at->converter);
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  .wrapper_name = "at", \
601  };
602 
603 FFAT_DEC(aac, AV_CODEC_ID_AAC, "aac_adtstoasc")
605 FFAT_DEC(adpcm_ima_qt, AV_CODEC_ID_ADPCM_IMA_QT, NULL)
static uint8_t * ffat_get_magic_cookie(AVCodecContext *avctx, UInt32 *cookie_size)
#define NULL
Definition: coverity.c:32
uint8_t * extradata
int ff_ac3_parse_header(GetBitContext *gbc, AC3HeaderInfo *hdr)
Parse AC-3 frame header.
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
This structure describes decoded (raw) audio or video data.
Definition: frame.h:201
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:101
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
int64_t bit_rate
the average bitrate
Definition: avcodec.h:1552
int size
Definition: avcodec.h:1415
const char * b
Definition: vf_curves.c:113
static av_always_inline void bytestream2_init_writer(PutByteContext *p, uint8_t *buf, int buf_size)
Definition: bytestream.h:143
static av_cold int ffat_create_decoder(AVCodecContext *avctx, AVPacket *pkt)
#define AV_CH_LOW_FREQUENCY_2
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:236
static AVPacket pkt
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:2725
int profile
profile
Definition: avcodec.h:2827
int block_align
number of bytes per packet if constant and known or 0 Used by some WAV based audio codecs...
Definition: avcodec.h:2194
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:2165
uint8_t
#define av_cold
Definition: attributes.h:82
#define av_malloc(s)
AVOptions.
#define COPY_SAMPLES(type)
static AudioChannelLayout * ffat_convert_layout(AudioChannelLayout *layout, UInt32 *size)
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:294
AVClass * av_class
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1602
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_RB32
Definition: bytestream.h:87
static AVFrame * frame
uint8_t * data
Definition: avcodec.h:1414
void av_packet_move_ref(AVPacket *dst, AVPacket *src)
Move every field in src to dst and reset src.
Definition: avpacket.c:645
uint32_t tag
Definition: movenc.c:1448
static av_cold void ffat_decode_flush(AVCodecContext *avctx)
ptrdiff_t size
Definition: opengl_enc.c:101
static void put_descr(PutByteContext *pb, int tag, unsigned int size)
signed 32 bits
Definition: samplefmt.h:62
#define av_log(a,...)
int av_packet_ref(AVPacket *dst, const AVPacket *src)
Setup a new reference to the data described by a given packet.
Definition: avpacket.c:599
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: avcodec.h:215
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
#define AVERROR(e)
Definition: error.h:43
uint8_t * av_packet_get_side_data(const AVPacket *pkt, enum AVPacketSideDataType type, int *size)
Get side information from packet.
Definition: avpacket.c:350
preferred ID for decoding MPEG audio layer 1, 2 or 3
Definition: avcodec.h:552
simple assert() macros that are a bit more flexible than ISO C assert().
Coded AC-3 header values up to the lfeon element, plus derived values.
Definition: ac3.h:176
uint16_t sample_rate
Definition: ac3.h:200
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:2208
#define FFAT_DEC(NAME, ID, bsf_name)
static int ffat_get_channel_id(AudioChannelLabel label)
static int ffat_update_ctx(AVCodecContext *avctx)
#define ff_ctzll
Definition: intmath.h:126
uint32_t bit_rate
Definition: ac3.h:201
static av_cold int ffat_usable_extradata(AVCodecContext *avctx)
AudioStreamPacketDescription pkt_desc
int32_t
AudioConverterRef converter
enum AVCodecID codec_id
Definition: vaapi_decode.c:236
#define AV_CH_FRONT_CENTER
static av_always_inline unsigned int bytestream2_put_buffer(PutByteContext *p, const uint8_t *src, unsigned int size)
Definition: bytestream.h:282
int frame_size
Number of samples per channel in an audio frame.
Definition: avcodec.h:2177
The AV_PKT_DATA_NEW_EXTRADATA is used to notify the codec or the format that the extradata buffer was...
Definition: avcodec.h:1155
Libavcodec external API header.
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
enum AVCodecID codec_id
Definition: avcodec.h:1512
int sample_rate
samples per second
Definition: avcodec.h:2157
static av_cold int ffat_init_decoder(AVCodecContext *avctx)
main external API structure.
Definition: avcodec.h:1502
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:590
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1886
static int ffat_set_extradata(AVCodecContext *avctx)
int extradata_size
Definition: avcodec.h:1603
static const char * format
Definition: movenc.c:47
Describe the class of an AVClass context structure.
Definition: log.h:67
int sample_rate
Sample rate of the audio data.
Definition: frame.h:374
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:425
mfxU16 profile
Definition: qsvenc.c:44
#define kAudioFormatEnhancedAC3
int av_get_bytes_per_sample(enum AVSampleFormat sample_fmt)
Return number of bytes per sample.
Definition: samplefmt.c:106
attribute_deprecated int64_t pkt_pts
PTS copied from the AVPacket that was decoded to produce this frame.
Definition: frame.h:302
MPEG Audio header decoder.
static int ffat_decode(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:84
common internal api header.
signed 16 bits
Definition: samplefmt.h:61
#define AVERROR_UNKNOWN
Unknown error, typically from an external library.
Definition: error.h:71
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:770
void * priv_data
Definition: avcodec.h:1529
static OSStatus ffat_decode_callback(AudioConverterRef converter, UInt32 *nb_packets, AudioBufferList *data, AudioStreamPacketDescription **packets, void *inctx)
int ff_mpa_decode_header(uint32_t head, int *sample_rate, int *channels, int *frame_size, int *bit_rate, enum AVCodecID *codec_id)
#define av_free(p)
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:85
int channels
number of audio channels
Definition: avcodec.h:2158
uint8_t channels
Definition: ac3.h:202
uint64_t layout
static int ffat_compare_channel_descriptions(const void *a, const void *b)
static av_cold int ffat_close_decoder(AVCodecContext *avctx)
int64_t av_get_default_channel_layout(int nb_channels)
Return default channel layout for a given number of channels.
static UInt32 ffat_get_format_id(enum AVCodecID codec, int profile)
#define av_freep(p)
int num_blocks
number of audio blocks
Definition: ac3.h:192
static void ffat_copy_samples(AVCodecContext *avctx, AVFrame *frame)
enum AVCodecID id
This structure stores compressed data.
Definition: avcodec.h:1391
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:267
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: avcodec.h:1407
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248