FFmpeg
libfdk-aacdec.c
Go to the documentation of this file.
1 /*
2  * AAC decoder wrapper
3  * Copyright (c) 2012 Martin Storsjo
4  *
5  * This file is part of FFmpeg.
6  *
7  * Permission to use, copy, modify, and/or distribute this software for any
8  * purpose with or without fee is hereby granted, provided that the above
9  * copyright notice and this permission notice appear in all copies.
10  *
11  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
12  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
13  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
14  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
15  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
16  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
17  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
18  */
19 
20 #include <fdk-aac/aacdecoder_lib.h>
21 
23 #include "libavutil/common.h"
24 #include "libavutil/mem.h"
25 #include "libavutil/opt.h"
26 #include "avcodec.h"
27 #include "codec_internal.h"
28 #include "decode.h"
29 
30 #ifdef AACDECODER_LIB_VL0
31 #define FDKDEC_VER_AT_LEAST(vl0, vl1) \
32  ((AACDECODER_LIB_VL0 > vl0) || \
33  (AACDECODER_LIB_VL0 == vl0 && AACDECODER_LIB_VL1 >= vl1))
34 #else
35 #define FDKDEC_VER_AT_LEAST(vl0, vl1) 0
36 #endif
37 
38 #if !FDKDEC_VER_AT_LEAST(2, 5) // < 2.5.10
39 #define AAC_PCM_MAX_OUTPUT_CHANNELS AAC_PCM_OUTPUT_CHANNELS
40 #endif
41 
47 };
48 
49 typedef struct FDKAACDecContext {
50  const AVClass *class;
51  HANDLE_AACDECODER handle;
52  uint8_t *decoder_buffer;
54  uint8_t *anc_buffer;
56  int drc_level;
57  int drc_boost;
58  int drc_heavy;
60  int drc_cut;
63 #if FDKDEC_VER_AT_LEAST(2, 5) // 2.5.10
64  int output_delay_set;
65  int flush_samples;
66  int delay_samples;
67 #endif
70 
71 
72 #define DMX_ANC_BUFFSIZE 128
73 #define DECODER_MAX_CHANNELS 8
74 #define DECODER_BUFFSIZE 2048 * sizeof(INT_PCM)
75 
76 #define OFFSET(x) offsetof(FDKAACDecContext, x)
77 #define AD AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM
78 static const AVOption fdk_aac_dec_options[] = {
79  { "conceal", "Error concealment method", OFFSET(conceal_method), AV_OPT_TYPE_INT, { .i64 = CONCEAL_METHOD_NOISE_SUBSTITUTION }, CONCEAL_METHOD_SPECTRAL_MUTING, CONCEAL_METHOD_NB - 1, AD, .unit = "conceal" },
80  { "spectral", "Spectral muting", 0, AV_OPT_TYPE_CONST, { .i64 = CONCEAL_METHOD_SPECTRAL_MUTING }, INT_MIN, INT_MAX, AD, .unit = "conceal" },
81  { "noise", "Noise Substitution", 0, AV_OPT_TYPE_CONST, { .i64 = CONCEAL_METHOD_NOISE_SUBSTITUTION }, INT_MIN, INT_MAX, AD, .unit = "conceal" },
82  { "energy", "Energy Interpolation", 0, AV_OPT_TYPE_CONST, { .i64 = CONCEAL_METHOD_ENERGY_INTERPOLATION }, INT_MIN, INT_MAX, AD, .unit = "conceal" },
83  { "drc_boost", "Dynamic Range Control: boost, where [0] is none and [127] is max boost",
84  OFFSET(drc_boost), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 127, AD, .unit = NULL },
85  { "drc_cut", "Dynamic Range Control: attenuation factor, where [0] is none and [127] is max compression",
86  OFFSET(drc_cut), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 127, AD, .unit = NULL },
87  { "drc_level", "Dynamic Range Control: reference level, quantized to 0.25dB steps where [0] is 0dB and [127] is -31.75dB, -1 for auto, and -2 for disabled",
88  OFFSET(drc_level), AV_OPT_TYPE_INT, { .i64 = -1}, -2, 127, AD, .unit = NULL },
89  { "drc_heavy", "Dynamic Range Control: heavy compression, where [1] is on (RF mode) and [0] is off",
90  OFFSET(drc_heavy), AV_OPT_TYPE_INT, { .i64 = -1}, -1, 1, AD, .unit = NULL },
91 #if FDKDEC_VER_AT_LEAST(2, 5) // 2.5.10
92  { "level_limit", "Signal level limiting",
93  OFFSET(level_limit), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, AD },
94 #endif
95 #if FDKDEC_VER_AT_LEAST(3, 0) // 3.0.0
96  { "drc_effect","Dynamic Range Control: effect type, where e.g. [0] is none and [6] is general",
97  OFFSET(drc_effect), AV_OPT_TYPE_INT, { .i64 = -1}, -1, 8, AD, .unit = NULL },
98 #endif
99 #if FDKDEC_VER_AT_LEAST(3, 1) // 3.1.0
100  { "album_mode","Dynamic Range Control: album mode, where [0] is off and [1] is on",
101  OFFSET(album_mode), AV_OPT_TYPE_INT, { .i64 = -1}, -1, 1, AD, .unit = NULL },
102 #endif
103  { "downmix", "Request a specific channel layout from the decoder", OFFSET(downmix_layout), AV_OPT_TYPE_CHLAYOUT, {.str = NULL}, .flags = AD },
104  { NULL }
105 };
106 
107 static const AVClass fdk_aac_dec_class = {
108  .class_name = "libfdk-aac decoder",
109  .item_name = av_default_item_name,
110  .option = fdk_aac_dec_options,
111  .version = LIBAVUTIL_VERSION_INT,
112 };
113 
114 static int get_stream_info(AVCodecContext *avctx)
115 {
116  FDKAACDecContext *s = avctx->priv_data;
117  CStreamInfo *info = aacDecoder_GetStreamInfo(s->handle);
118  int channel_counts[0x24] = { 0 };
119  int i, ch_error = 0;
120  uint64_t ch_layout = 0;
121 
122  if (!info) {
123  av_log(avctx, AV_LOG_ERROR, "Unable to get stream info\n");
124  return AVERROR_UNKNOWN;
125  }
126 
127  if (info->sampleRate <= 0) {
128  av_log(avctx, AV_LOG_ERROR, "Stream info not initialized\n");
129  return AVERROR_UNKNOWN;
130  }
131  avctx->sample_rate = info->sampleRate;
132  avctx->frame_size = info->frameSize;
133 #if FDKDEC_VER_AT_LEAST(2, 5) // 2.5.10
134  if (!s->output_delay_set && info->outputDelay) {
135  // Set this only once.
136  s->flush_samples = info->outputDelay;
137  s->delay_samples = info->outputDelay;
138  s->output_delay_set = 1;
139  }
140 #endif
141 
142  for (i = 0; i < info->numChannels; i++) {
143  AUDIO_CHANNEL_TYPE ctype = info->pChannelType[i];
144  if (ctype <= ACT_NONE || ctype >= FF_ARRAY_ELEMS(channel_counts)) {
145  av_log(avctx, AV_LOG_WARNING, "unknown channel type\n");
146  break;
147  }
148  channel_counts[ctype]++;
149  }
150  av_log(avctx, AV_LOG_DEBUG,
151  "%d channels - front:%d side:%d back:%d lfe:%d top:%d\n",
152  info->numChannels,
153  channel_counts[ACT_FRONT], channel_counts[ACT_SIDE],
154  channel_counts[ACT_BACK], channel_counts[ACT_LFE],
155  channel_counts[ACT_FRONT_TOP] + channel_counts[ACT_SIDE_TOP] +
156  channel_counts[ACT_BACK_TOP] + channel_counts[ACT_TOP]);
157 
158  switch (channel_counts[ACT_FRONT]) {
159  case 4:
162  break;
163  case 3:
165  break;
166  case 2:
167  ch_layout |= AV_CH_LAYOUT_STEREO;
168  break;
169  case 1:
170  ch_layout |= AV_CH_FRONT_CENTER;
171  break;
172  default:
173  av_log(avctx, AV_LOG_WARNING,
174  "unsupported number of front channels: %d\n",
175  channel_counts[ACT_FRONT]);
176  ch_error = 1;
177  break;
178  }
179  if (channel_counts[ACT_SIDE] > 0) {
180  if (channel_counts[ACT_SIDE] == 2) {
181  ch_layout |= AV_CH_SIDE_LEFT | AV_CH_SIDE_RIGHT;
182  } else {
183  av_log(avctx, AV_LOG_WARNING,
184  "unsupported number of side channels: %d\n",
185  channel_counts[ACT_SIDE]);
186  ch_error = 1;
187  }
188  }
189  if (channel_counts[ACT_BACK] > 0) {
190  switch (channel_counts[ACT_BACK]) {
191  case 3:
193  break;
194  case 2:
195  ch_layout |= AV_CH_BACK_LEFT | AV_CH_BACK_RIGHT;
196  break;
197  case 1:
198  ch_layout |= AV_CH_BACK_CENTER;
199  break;
200  default:
201  av_log(avctx, AV_LOG_WARNING,
202  "unsupported number of back channels: %d\n",
203  channel_counts[ACT_BACK]);
204  ch_error = 1;
205  break;
206  }
207  }
208  if (channel_counts[ACT_LFE] > 0) {
209  if (channel_counts[ACT_LFE] == 1) {
210  ch_layout |= AV_CH_LOW_FREQUENCY;
211  } else {
212  av_log(avctx, AV_LOG_WARNING,
213  "unsupported number of LFE channels: %d\n",
214  channel_counts[ACT_LFE]);
215  ch_error = 1;
216  }
217  }
218 
220  av_channel_layout_from_mask(&avctx->ch_layout, ch_layout);
221  if (!ch_error && avctx->ch_layout.nb_channels != info->numChannels) {
222  av_log(avctx, AV_LOG_WARNING, "unsupported channel configuration\n");
223  ch_error = 1;
224  }
225  if (ch_error)
227 
228  return 0;
229 }
230 
232 {
233  FDKAACDecContext *s = avctx->priv_data;
234 
235  if (s->handle)
236  aacDecoder_Close(s->handle);
237  av_freep(&s->decoder_buffer);
238  av_freep(&s->anc_buffer);
239 
240  return 0;
241 }
242 
244 {
245  FDKAACDecContext *s = avctx->priv_data;
246  AAC_DECODER_ERROR err;
247 
248  s->handle = aacDecoder_Open(avctx->extradata_size ? TT_MP4_RAW : TT_MP4_ADTS, 1);
249  if (!s->handle) {
250  av_log(avctx, AV_LOG_ERROR, "Error opening decoder\n");
251  return AVERROR_UNKNOWN;
252  }
253 
254  if (avctx->extradata_size) {
255  if ((err = aacDecoder_ConfigRaw(s->handle, &avctx->extradata,
256  &avctx->extradata_size)) != AAC_DEC_OK) {
257  av_log(avctx, AV_LOG_ERROR, "Unable to set extradata\n");
258  return AVERROR_INVALIDDATA;
259  }
260  }
261 
262  if ((err = aacDecoder_SetParam(s->handle, AAC_CONCEAL_METHOD,
263  s->conceal_method)) != AAC_DEC_OK) {
264  av_log(avctx, AV_LOG_ERROR, "Unable to set error concealment method\n");
265  return AVERROR_UNKNOWN;
266  }
267 
268  if (s->downmix_layout.nb_channels > 0 &&
269  s->downmix_layout.order != AV_CHANNEL_ORDER_NATIVE) {
270  int downmix_channels = -1;
271 
272  switch (s->downmix_layout.u.mask) {
273  case AV_CH_LAYOUT_STEREO:
275  downmix_channels = 2;
276  break;
277  case AV_CH_LAYOUT_MONO:
278  downmix_channels = 1;
279  break;
280  default:
281  av_log(avctx, AV_LOG_WARNING, "Invalid downmix option\n");
282  break;
283  }
284 
285  if (downmix_channels != -1) {
286  if (aacDecoder_SetParam(s->handle, AAC_PCM_MAX_OUTPUT_CHANNELS,
287  downmix_channels) != AAC_DEC_OK) {
288  av_log(avctx, AV_LOG_WARNING, "Unable to set output channels in the decoder\n");
289  } else {
290  s->anc_buffer = av_malloc(DMX_ANC_BUFFSIZE);
291  if (!s->anc_buffer) {
292  av_log(avctx, AV_LOG_ERROR, "Unable to allocate ancillary buffer for the decoder\n");
293  return AVERROR(ENOMEM);
294  }
295  if (aacDecoder_AncDataInit(s->handle, s->anc_buffer, DMX_ANC_BUFFSIZE)) {
296  av_log(avctx, AV_LOG_ERROR, "Unable to register downmix ancillary buffer in the decoder\n");
297  return AVERROR_UNKNOWN;
298  }
299  }
300  }
301  }
302 
303  if (s->drc_boost != -1) {
304  if (aacDecoder_SetParam(s->handle, AAC_DRC_BOOST_FACTOR, s->drc_boost) != AAC_DEC_OK) {
305  av_log(avctx, AV_LOG_ERROR, "Unable to set DRC boost factor in the decoder\n");
306  return AVERROR_UNKNOWN;
307  }
308  }
309 
310  if (s->drc_cut != -1) {
311  if (aacDecoder_SetParam(s->handle, AAC_DRC_ATTENUATION_FACTOR, s->drc_cut) != AAC_DEC_OK) {
312  av_log(avctx, AV_LOG_ERROR, "Unable to set DRC attenuation factor in the decoder\n");
313  return AVERROR_UNKNOWN;
314  }
315  }
316 
317  if (s->drc_level != -1) {
318  // This option defaults to -1, i.e. not calling
319  // aacDecoder_SetParam(AAC_DRC_REFERENCE_LEVEL) at all, which defaults
320  // to the level from DRC metadata, if available. The user can set
321  // -drc_level -2, which calls aacDecoder_SetParam(
322  // AAC_DRC_REFERENCE_LEVEL) with a negative value, which then
323  // explicitly disables the feature.
324  if (aacDecoder_SetParam(s->handle, AAC_DRC_REFERENCE_LEVEL, s->drc_level) != AAC_DEC_OK) {
325  av_log(avctx, AV_LOG_ERROR, "Unable to set DRC reference level in the decoder\n");
326  return AVERROR_UNKNOWN;
327  }
328  }
329 
330  if (s->drc_heavy != -1) {
331  if (aacDecoder_SetParam(s->handle, AAC_DRC_HEAVY_COMPRESSION, s->drc_heavy) != AAC_DEC_OK) {
332  av_log(avctx, AV_LOG_ERROR, "Unable to set DRC heavy compression in the decoder\n");
333  return AVERROR_UNKNOWN;
334  }
335  }
336 
337 #if FDKDEC_VER_AT_LEAST(2, 5) // 2.5.10
338  // Setting this parameter to -1 enables the auto behaviour in the library.
339  if (aacDecoder_SetParam(s->handle, AAC_PCM_LIMITER_ENABLE, s->level_limit) != AAC_DEC_OK) {
340  av_log(avctx, AV_LOG_ERROR, "Unable to set in signal level limiting in the decoder\n");
341  return AVERROR_UNKNOWN;
342  }
343 #endif
344 
345 #if FDKDEC_VER_AT_LEAST(3, 0) // 3.0.0
346  if (s->drc_effect != -1) {
347  if (aacDecoder_SetParam(s->handle, AAC_UNIDRC_SET_EFFECT, s->drc_effect) != AAC_DEC_OK) {
348  av_log(avctx, AV_LOG_ERROR, "Unable to set DRC effect type in the decoder\n");
349  return AVERROR_UNKNOWN;
350  }
351  }
352 #endif
353 
354 #if FDKDEC_VER_AT_LEAST(3, 1) // 3.1.0
355  if (s->album_mode != -1) {
356  if (aacDecoder_SetParam(s->handle, AAC_UNIDRC_ALBUM_MODE, s->album_mode) != AAC_DEC_OK) {
357  av_log(avctx, AV_LOG_ERROR, "Unable to set album mode in the decoder\n");
358  return AVERROR_UNKNOWN;
359  }
360  }
361 #endif
362 
363  avctx->sample_fmt = AV_SAMPLE_FMT_S16;
364 
365  s->decoder_buffer_size = DECODER_BUFFSIZE * DECODER_MAX_CHANNELS;
366  s->decoder_buffer = av_malloc(s->decoder_buffer_size);
367  if (!s->decoder_buffer)
368  return AVERROR(ENOMEM);
369 
370  return 0;
371 }
372 
374  int *got_frame_ptr, AVPacket *avpkt)
375 {
376  FDKAACDecContext *s = avctx->priv_data;
377  int ret;
378  AAC_DECODER_ERROR err;
379  UINT valid = avpkt->size;
380  UINT flags = 0;
381  int input_offset = 0;
382 
383  if (avpkt->size) {
384  err = aacDecoder_Fill(s->handle, &avpkt->data, &avpkt->size, &valid);
385  if (err != AAC_DEC_OK) {
386  av_log(avctx, AV_LOG_ERROR, "aacDecoder_Fill() failed: %x\n", err);
387  return AVERROR_INVALIDDATA;
388  }
389  } else {
390 #if FDKDEC_VER_AT_LEAST(2, 5) // 2.5.10
391  /* Handle decoder draining */
392  if (s->flush_samples > 0) {
393  flags |= AACDEC_FLUSH;
394  } else {
395  return AVERROR_EOF;
396  }
397 #else
398  return AVERROR_EOF;
399 #endif
400  }
401 
402  err = aacDecoder_DecodeFrame(s->handle, (INT_PCM *) s->decoder_buffer,
403  s->decoder_buffer_size / sizeof(INT_PCM),
404  flags);
405  if (err == AAC_DEC_NOT_ENOUGH_BITS) {
406  ret = avpkt->size - valid;
407  goto end;
408  }
409  if (err != AAC_DEC_OK) {
410  av_log(avctx, AV_LOG_ERROR,
411  "aacDecoder_DecodeFrame() failed: %x\n", err);
413  goto end;
414  }
415 
416  if ((ret = get_stream_info(avctx)) < 0)
417  goto end;
418  frame->nb_samples = avctx->frame_size;
419 
420 #if FDKDEC_VER_AT_LEAST(2, 5) // 2.5.10
421  if (flags & AACDEC_FLUSH) {
422  // Only return the right amount of samples at the end; if calling the
423  // decoder with AACDEC_FLUSH, it will keep returning frames indefinitely.
424  frame->nb_samples = FFMIN(s->flush_samples, frame->nb_samples);
425  av_log(s, AV_LOG_DEBUG, "Returning %d/%d delayed samples.\n",
426  frame->nb_samples, s->flush_samples);
427  s->flush_samples -= frame->nb_samples;
428  } else {
429  // Trim off samples from the start to compensate for extra decoder
430  // delay. We could also just adjust the pts, but this avoids
431  // including the extra samples in the output altogether.
432  if (s->delay_samples) {
433  int drop_samples = FFMIN(s->delay_samples, frame->nb_samples);
434  av_log(s, AV_LOG_DEBUG, "Dropping %d/%d delayed samples.\n",
435  drop_samples, s->delay_samples);
436  s->delay_samples -= drop_samples;
437  frame->nb_samples -= drop_samples;
438  input_offset = drop_samples * avctx->ch_layout.nb_channels;
439  if (frame->nb_samples <= 0)
440  return 0;
441  }
442  }
443 #endif
444 
445  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
446  goto end;
447 
448  memcpy(frame->extended_data[0], s->decoder_buffer + input_offset,
449  avctx->ch_layout.nb_channels * frame->nb_samples *
451 
452  *got_frame_ptr = 1;
453  ret = avpkt->size - valid;
454 
455 end:
456  return ret;
457 }
458 
460 {
461  FDKAACDecContext *s = avctx->priv_data;
462  AAC_DECODER_ERROR err;
463 
464  if (!s->handle)
465  return;
466 
467  if ((err = aacDecoder_SetParam(s->handle,
468  AAC_TPDEC_CLEAR_BUFFER, 1)) != AAC_DEC_OK)
469  av_log(avctx, AV_LOG_WARNING, "failed to clear buffer when flushing\n");
470 }
471 
473  .p.name = "libfdk_aac",
474  CODEC_LONG_NAME("Fraunhofer FDK AAC"),
475  .p.type = AVMEDIA_TYPE_AUDIO,
476  .p.id = AV_CODEC_ID_AAC,
477  .priv_data_size = sizeof(FDKAACDecContext),
480  .close = fdk_aac_decode_close,
481  .flush = fdk_aac_decode_flush,
482  .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_CHANNEL_CONF
483 #if FDKDEC_VER_AT_LEAST(2, 5) // 2.5.10
485 #endif
486  ,
487  .p.priv_class = &fdk_aac_dec_class,
488  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
489  .p.wrapper_name = "libfdk",
490 };
DECODER_BUFFSIZE
#define DECODER_BUFFSIZE
Definition: libfdk-aacdec.c:74
AVCodecContext::frame_size
int frame_size
Number of samples per channel in an audio frame.
Definition: avcodec.h:1077
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
FF_CODEC_CAP_INIT_CLEANUP
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: codec_internal.h:42
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
opt.h
AVCodecContext::sample_rate
int sample_rate
samples per second
Definition: avcodec.h:1050
ctype
#define ctype
Definition: afir_template.c:47
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:57
AV_CH_LAYOUT_MONO
#define AV_CH_LAYOUT_MONO
Definition: channel_layout.h:212
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:374
AVPacket::data
uint8_t * data
Definition: packet.h:520
AVOption
AVOption.
Definition: opt.h:357
FFCodec
Definition: codec_internal.h:126
AVChannelLayout::order
enum AVChannelOrder order
Channel order used in this layout.
Definition: channel_layout.h:316
AVERROR_UNKNOWN
#define AVERROR_UNKNOWN
Unknown error, typically from an external library.
Definition: error.h:73
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:321
AD
#define AD
Definition: libfdk-aacdec.c:77
DMX_ANC_BUFFSIZE
#define DMX_ANC_BUFFSIZE
Definition: libfdk-aacdec.c:72
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:30
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:130
AVCodecContext::ch_layout
AVChannelLayout ch_layout
Audio channel layout.
Definition: avcodec.h:1065
FDKAACDecContext
Definition: libfdk-aacdec.c:49
AV_CH_BACK_LEFT
#define AV_CH_BACK_LEFT
Definition: channel_layout.h:176
FDKAACDecContext::conceal_method
int conceal_method
Definition: libfdk-aacdec.c:55
get_stream_info
static int get_stream_info(AVCodecContext *avctx)
Definition: libfdk-aacdec.c:114
AV_CH_LAYOUT_STEREO
#define AV_CH_LAYOUT_STEREO
Definition: channel_layout.h:213
AAC_PCM_MAX_OUTPUT_CHANNELS
#define AAC_PCM_MAX_OUTPUT_CHANNELS
Definition: libfdk-aacdec.c:39
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
av_cold
#define av_cold
Definition: attributes.h:90
AV_CH_LOW_FREQUENCY
#define AV_CH_LOW_FREQUENCY
Definition: channel_layout.h:175
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:524
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:286
s
#define s(width, name)
Definition: cbs_vp9.c:198
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
AV_CHANNEL_ORDER_UNSPEC
@ AV_CHANNEL_ORDER_UNSPEC
Only the channel count is specified, without any further information about the channel order.
Definition: channel_layout.h:116
av_channel_layout_from_mask
int av_channel_layout_from_mask(AVChannelLayout *channel_layout, uint64_t mask)
Initialize a native channel layout from a bitmask indicating which channels are present.
Definition: channel_layout.c:247
info
MIPS optimizations info
Definition: mips.txt:2
AV_CH_LAYOUT_STEREO_DOWNMIX
#define AV_CH_LAYOUT_STEREO_DOWNMIX
Definition: channel_layout.h:247
FDKAACDecContext::drc_heavy
int drc_heavy
Definition: libfdk-aacdec.c:58
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
decode.h
OFFSET
#define OFFSET(x)
Definition: libfdk-aacdec.c:76
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:271
FDKAACDecContext::handle
HANDLE_AACDECODER handle
Definition: libfdk-aacdec.c:51
fdk_aac_decode_flush
static av_cold void fdk_aac_decode_flush(AVCodecContext *avctx)
Definition: libfdk-aacdec.c:459
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
NULL
#define NULL
Definition: coverity.c:32
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:237
AV_OPT_TYPE_CHLAYOUT
@ AV_OPT_TYPE_CHLAYOUT
Definition: opt.h:262
AV_CH_FRONT_CENTER
#define AV_CH_FRONT_CENTER
Definition: channel_layout.h:174
FDKAACDecContext::level_limit
int level_limit
Definition: libfdk-aacdec.c:62
AV_CH_FRONT_LEFT_OF_CENTER
#define AV_CH_FRONT_LEFT_OF_CENTER
Definition: channel_layout.h:178
FDKAACDecContext::album_mode
int album_mode
Definition: libfdk-aacdec.c:61
FDKAACDecContext::drc_effect
int drc_effect
Definition: libfdk-aacdec.c:59
AV_CODEC_CAP_CHANNEL_CONF
#define AV_CODEC_CAP_CHANNEL_CONF
Codec should fill in channel configuration and samplerate instead of container.
Definition: codec.h:106
AV_CODEC_ID_AAC
@ AV_CODEC_ID_AAC
Definition: codec_id.h:442
FDKAACDecContext::decoder_buffer_size
int decoder_buffer_size
Definition: libfdk-aacdec.c:53
FDKAACDecContext::anc_buffer
uint8_t * anc_buffer
Definition: libfdk-aacdec.c:54
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1575
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:366
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
AVPacket::size
int size
Definition: packet.h:521
AVChannelLayout
An AVChannelLayout holds information about the channel layout of audio data.
Definition: channel_layout.h:311
codec_internal.h
fdk_aac_dec_options
static const AVOption fdk_aac_dec_options[]
Definition: libfdk-aacdec.c:78
AVCodecContext::sample_fmt
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1057
FDKAACDecContext::drc_cut
int drc_cut
Definition: libfdk-aacdec.c:60
fdk_aac_dec_class
static const AVClass fdk_aac_dec_class
Definition: libfdk-aacdec.c:107
AV_CHANNEL_ORDER_NATIVE
@ AV_CHANNEL_ORDER_NATIVE
The native channel order, i.e.
Definition: channel_layout.h:122
ConcealMethod
ConcealMethod
Definition: libfdk-aacdec.c:42
FDKAACDecContext::decoder_buffer
uint8_t * decoder_buffer
Definition: libfdk-aacdec.c:52
AV_CH_FRONT_RIGHT_OF_CENTER
#define AV_CH_FRONT_RIGHT_OF_CENTER
Definition: channel_layout.h:179
CONCEAL_METHOD_ENERGY_INTERPOLATION
@ CONCEAL_METHOD_ENERGY_INTERPOLATION
Definition: libfdk-aacdec.c:45
FDKAACDecContext::downmix_layout
AVChannelLayout downmix_layout
Definition: libfdk-aacdec.c:68
FDKAACDecContext::drc_level
int drc_level
Definition: libfdk-aacdec.c:56
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
av_get_bytes_per_sample
int av_get_bytes_per_sample(enum AVSampleFormat sample_fmt)
Return number of bytes per sample.
Definition: samplefmt.c:108
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:523
common.h
AV_CH_BACK_CENTER
#define AV_CH_BACK_CENTER
Definition: channel_layout.h:180
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
CONCEAL_METHOD_SPECTRAL_MUTING
@ CONCEAL_METHOD_SPECTRAL_MUTING
Definition: libfdk-aacdec.c:43
AV_SAMPLE_FMT_S16
@ AV_SAMPLE_FMT_S16
signed 16 bits
Definition: samplefmt.h:58
FDKAACDecContext::drc_boost
int drc_boost
Definition: libfdk-aacdec.c:57
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:194
AV_CH_SIDE_RIGHT
#define AV_CH_SIDE_RIGHT
Definition: channel_layout.h:182
CONCEAL_METHOD_NOISE_SUBSTITUTION
@ CONCEAL_METHOD_NOISE_SUBSTITUTION
Definition: libfdk-aacdec.c:44
avcodec.h
ret
ret
Definition: filter_design.txt:187
AVClass::class_name
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:71
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
fdk_aac_decode_close
static av_cold int fdk_aac_decode_close(AVCodecContext *avctx)
Definition: libfdk-aacdec.c:231
ff_libfdk_aac_decoder
const FFCodec ff_libfdk_aac_decoder
Definition: libfdk-aacdec.c:472
AVCodecContext
main external API structure.
Definition: avcodec.h:445
channel_layout.h
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:245
av_channel_layout_uninit
void av_channel_layout_uninit(AVChannelLayout *channel_layout)
Free any allocated data in the channel layout and reset the channel count to 0.
Definition: channel_layout.c:437
AV_CODEC_CAP_DELAY
#define AV_CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
Definition: codec.h:76
mem.h
AVPacket
This structure stores compressed data.
Definition: packet.h:497
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:472
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:261
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:474
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
DECODER_MAX_CHANNELS
#define DECODER_MAX_CHANNELS
Definition: libfdk-aacdec.c:73
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
AV_CH_BACK_RIGHT
#define AV_CH_BACK_RIGHT
Definition: channel_layout.h:177
fdk_aac_decode_frame
static int fdk_aac_decode_frame(AVCodecContext *avctx, AVFrame *frame, int *got_frame_ptr, AVPacket *avpkt)
Definition: libfdk-aacdec.c:373
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:254
CONCEAL_METHOD_NB
@ CONCEAL_METHOD_NB
Definition: libfdk-aacdec.c:46
fdk_aac_decode_init
static av_cold int fdk_aac_decode_init(AVCodecContext *avctx)
Definition: libfdk-aacdec.c:243
AV_CH_SIDE_LEFT
#define AV_CH_SIDE_LEFT
Definition: channel_layout.h:181