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 
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  avctx->profile = info->aot - 1;
134 
135  frame->flags |= AV_FRAME_FLAG_KEY * !!(info->flags & AC_INDEP);
136 #if FDKDEC_VER_AT_LEAST(2, 5) // 2.5.10
137  if (!s->output_delay_set && info->outputDelay) {
138  // Set this only once.
139  s->flush_samples = info->outputDelay;
140  s->delay_samples = info->outputDelay;
141  s->output_delay_set = 1;
142  }
143 #endif
144 
145  for (i = 0; i < info->numChannels; i++) {
146  AUDIO_CHANNEL_TYPE ctype = info->pChannelType[i];
147  if (ctype <= ACT_NONE || ctype >= FF_ARRAY_ELEMS(channel_counts)) {
148  av_log(avctx, AV_LOG_WARNING, "unknown channel type\n");
149  break;
150  }
151  channel_counts[ctype]++;
152  }
153  av_log(avctx, AV_LOG_DEBUG,
154  "%d channels - front:%d side:%d back:%d lfe:%d top:%d\n",
155  info->numChannels,
156  channel_counts[ACT_FRONT], channel_counts[ACT_SIDE],
157  channel_counts[ACT_BACK], channel_counts[ACT_LFE],
158  channel_counts[ACT_FRONT_TOP] + channel_counts[ACT_SIDE_TOP] +
159  channel_counts[ACT_BACK_TOP] + channel_counts[ACT_TOP]);
160 
161  switch (channel_counts[ACT_FRONT]) {
162  case 4:
165  break;
166  case 3:
168  break;
169  case 2:
170  ch_layout |= AV_CH_LAYOUT_STEREO;
171  break;
172  case 1:
173  ch_layout |= AV_CH_FRONT_CENTER;
174  break;
175  default:
176  av_log(avctx, AV_LOG_WARNING,
177  "unsupported number of front channels: %d\n",
178  channel_counts[ACT_FRONT]);
179  ch_error = 1;
180  break;
181  }
182  if (channel_counts[ACT_SIDE] > 0) {
183  if (channel_counts[ACT_SIDE] == 2) {
184  ch_layout |= AV_CH_SIDE_LEFT | AV_CH_SIDE_RIGHT;
185  } else {
186  av_log(avctx, AV_LOG_WARNING,
187  "unsupported number of side channels: %d\n",
188  channel_counts[ACT_SIDE]);
189  ch_error = 1;
190  }
191  }
192  if (channel_counts[ACT_BACK] > 0) {
193  switch (channel_counts[ACT_BACK]) {
194  case 3:
196  break;
197  case 2:
198  ch_layout |= AV_CH_BACK_LEFT | AV_CH_BACK_RIGHT;
199  break;
200  case 1:
201  ch_layout |= AV_CH_BACK_CENTER;
202  break;
203  default:
204  av_log(avctx, AV_LOG_WARNING,
205  "unsupported number of back channels: %d\n",
206  channel_counts[ACT_BACK]);
207  ch_error = 1;
208  break;
209  }
210  }
211  if (channel_counts[ACT_LFE] > 0) {
212  if (channel_counts[ACT_LFE] == 1) {
213  ch_layout |= AV_CH_LOW_FREQUENCY;
214  } else {
215  av_log(avctx, AV_LOG_WARNING,
216  "unsupported number of LFE channels: %d\n",
217  channel_counts[ACT_LFE]);
218  ch_error = 1;
219  }
220  }
221 
223  av_channel_layout_from_mask(&avctx->ch_layout, ch_layout);
224  if (!ch_error && avctx->ch_layout.nb_channels != info->numChannels) {
225  av_log(avctx, AV_LOG_WARNING, "unsupported channel configuration\n");
226  ch_error = 1;
227  }
228  if (ch_error)
230 
231  return 0;
232 }
233 
235 {
236  FDKAACDecContext *s = avctx->priv_data;
237 
238  if (s->handle)
239  aacDecoder_Close(s->handle);
240  av_freep(&s->decoder_buffer);
241  av_freep(&s->anc_buffer);
242 
243  return 0;
244 }
245 
247 {
248  FDKAACDecContext *s = avctx->priv_data;
249  AAC_DECODER_ERROR err;
250 
251  s->handle = aacDecoder_Open(avctx->extradata_size ? TT_MP4_RAW : TT_MP4_ADTS, 1);
252  if (!s->handle) {
253  av_log(avctx, AV_LOG_ERROR, "Error opening decoder\n");
254  return AVERROR_UNKNOWN;
255  }
256 
257  if (avctx->extradata_size) {
258  if ((err = aacDecoder_ConfigRaw(s->handle, &avctx->extradata,
259  &avctx->extradata_size)) != AAC_DEC_OK) {
260  av_log(avctx, AV_LOG_ERROR, "Unable to set extradata\n");
261  return AVERROR_INVALIDDATA;
262  }
263  }
264 
265  if ((err = aacDecoder_SetParam(s->handle, AAC_CONCEAL_METHOD,
266  s->conceal_method)) != AAC_DEC_OK) {
267  av_log(avctx, AV_LOG_ERROR, "Unable to set error concealment method\n");
268  return AVERROR_UNKNOWN;
269  }
270 
271  if (s->downmix_layout.nb_channels > 0 &&
272  s->downmix_layout.order != AV_CHANNEL_ORDER_NATIVE) {
273  int downmix_channels = -1;
274 
275  switch (s->downmix_layout.u.mask) {
276  case AV_CH_LAYOUT_STEREO:
278  downmix_channels = 2;
279  break;
280  case AV_CH_LAYOUT_MONO:
281  downmix_channels = 1;
282  break;
283  default:
284  av_log(avctx, AV_LOG_WARNING, "Invalid downmix option\n");
285  break;
286  }
287 
288  if (downmix_channels != -1) {
289  if (aacDecoder_SetParam(s->handle, AAC_PCM_MAX_OUTPUT_CHANNELS,
290  downmix_channels) != AAC_DEC_OK) {
291  av_log(avctx, AV_LOG_WARNING, "Unable to set output channels in the decoder\n");
292  } else {
293  s->anc_buffer = av_malloc(DMX_ANC_BUFFSIZE);
294  if (!s->anc_buffer) {
295  av_log(avctx, AV_LOG_ERROR, "Unable to allocate ancillary buffer for the decoder\n");
296  return AVERROR(ENOMEM);
297  }
298  if (aacDecoder_AncDataInit(s->handle, s->anc_buffer, DMX_ANC_BUFFSIZE)) {
299  av_log(avctx, AV_LOG_ERROR, "Unable to register downmix ancillary buffer in the decoder\n");
300  return AVERROR_UNKNOWN;
301  }
302  }
303  }
304  }
305 
306  if (s->drc_boost != -1) {
307  if (aacDecoder_SetParam(s->handle, AAC_DRC_BOOST_FACTOR, s->drc_boost) != AAC_DEC_OK) {
308  av_log(avctx, AV_LOG_ERROR, "Unable to set DRC boost factor in the decoder\n");
309  return AVERROR_UNKNOWN;
310  }
311  }
312 
313  if (s->drc_cut != -1) {
314  if (aacDecoder_SetParam(s->handle, AAC_DRC_ATTENUATION_FACTOR, s->drc_cut) != AAC_DEC_OK) {
315  av_log(avctx, AV_LOG_ERROR, "Unable to set DRC attenuation factor in the decoder\n");
316  return AVERROR_UNKNOWN;
317  }
318  }
319 
320  if (s->drc_level != -1) {
321  // This option defaults to -1, i.e. not calling
322  // aacDecoder_SetParam(AAC_DRC_REFERENCE_LEVEL) at all, which defaults
323  // to the level from DRC metadata, if available. The user can set
324  // -drc_level -2, which calls aacDecoder_SetParam(
325  // AAC_DRC_REFERENCE_LEVEL) with a negative value, which then
326  // explicitly disables the feature.
327  if (aacDecoder_SetParam(s->handle, AAC_DRC_REFERENCE_LEVEL, s->drc_level) != AAC_DEC_OK) {
328  av_log(avctx, AV_LOG_ERROR, "Unable to set DRC reference level in the decoder\n");
329  return AVERROR_UNKNOWN;
330  }
331  }
332 
333  if (s->drc_heavy != -1) {
334  if (aacDecoder_SetParam(s->handle, AAC_DRC_HEAVY_COMPRESSION, s->drc_heavy) != AAC_DEC_OK) {
335  av_log(avctx, AV_LOG_ERROR, "Unable to set DRC heavy compression in the decoder\n");
336  return AVERROR_UNKNOWN;
337  }
338  }
339 
340 #if FDKDEC_VER_AT_LEAST(2, 5) // 2.5.10
341  // Setting this parameter to -1 enables the auto behaviour in the library.
342  if (aacDecoder_SetParam(s->handle, AAC_PCM_LIMITER_ENABLE, s->level_limit) != AAC_DEC_OK) {
343  av_log(avctx, AV_LOG_ERROR, "Unable to set in signal level limiting in the decoder\n");
344  return AVERROR_UNKNOWN;
345  }
346 #endif
347 
348 #if FDKDEC_VER_AT_LEAST(3, 0) // 3.0.0
349  if (s->drc_effect != -1) {
350  if (aacDecoder_SetParam(s->handle, AAC_UNIDRC_SET_EFFECT, s->drc_effect) != AAC_DEC_OK) {
351  av_log(avctx, AV_LOG_ERROR, "Unable to set DRC effect type in the decoder\n");
352  return AVERROR_UNKNOWN;
353  }
354  }
355 #endif
356 
357 #if FDKDEC_VER_AT_LEAST(3, 1) // 3.1.0
358  if (s->album_mode != -1) {
359  if (aacDecoder_SetParam(s->handle, AAC_UNIDRC_ALBUM_MODE, s->album_mode) != AAC_DEC_OK) {
360  av_log(avctx, AV_LOG_ERROR, "Unable to set album mode in the decoder\n");
361  return AVERROR_UNKNOWN;
362  }
363  }
364 #endif
365 
366  avctx->sample_fmt = AV_SAMPLE_FMT_S16;
367 
368  s->decoder_buffer_size = DECODER_BUFFSIZE * DECODER_MAX_CHANNELS;
369  s->decoder_buffer = av_malloc(s->decoder_buffer_size);
370  if (!s->decoder_buffer)
371  return AVERROR(ENOMEM);
372 
373  return 0;
374 }
375 
377  int *got_frame_ptr, AVPacket *avpkt)
378 {
379  FDKAACDecContext *s = avctx->priv_data;
380  int ret;
381  AAC_DECODER_ERROR err;
382  UINT valid = avpkt->size;
383  UINT flags = 0;
384  int input_offset = 0;
385 
386  if (avpkt->size) {
387  err = aacDecoder_Fill(s->handle, &avpkt->data, &avpkt->size, &valid);
388  if (err != AAC_DEC_OK) {
389  av_log(avctx, AV_LOG_ERROR, "aacDecoder_Fill() failed: %x\n", err);
390  return AVERROR_INVALIDDATA;
391  }
392  } else {
393 #if FDKDEC_VER_AT_LEAST(2, 5) // 2.5.10
394  /* Handle decoder draining */
395  if (s->flush_samples > 0) {
396  flags |= AACDEC_FLUSH;
397  } else {
398  return AVERROR_EOF;
399  }
400 #else
401  return AVERROR_EOF;
402 #endif
403  }
404 
405  err = aacDecoder_DecodeFrame(s->handle, (INT_PCM *) s->decoder_buffer,
406  s->decoder_buffer_size / sizeof(INT_PCM),
407  flags);
408  if (err == AAC_DEC_NOT_ENOUGH_BITS) {
409  ret = avpkt->size - valid;
410  goto end;
411  }
412  if (err != AAC_DEC_OK) {
413  av_log(avctx, AV_LOG_ERROR,
414  "aacDecoder_DecodeFrame() failed: %x\n", err);
416  goto end;
417  }
418 
419  if ((ret = get_stream_info(avctx, frame)) < 0)
420  goto end;
421  frame->nb_samples = avctx->frame_size;
422 
423 #if FDKDEC_VER_AT_LEAST(2, 5) // 2.5.10
424  if (flags & AACDEC_FLUSH) {
425  // Only return the right amount of samples at the end; if calling the
426  // decoder with AACDEC_FLUSH, it will keep returning frames indefinitely.
427  frame->nb_samples = FFMIN(s->flush_samples, frame->nb_samples);
428  av_log(s, AV_LOG_DEBUG, "Returning %d/%d delayed samples.\n",
429  frame->nb_samples, s->flush_samples);
430  s->flush_samples -= frame->nb_samples;
431  } else {
432  // Trim off samples from the start to compensate for extra decoder
433  // delay. We could also just adjust the pts, but this avoids
434  // including the extra samples in the output altogether.
435  if (s->delay_samples) {
436  int drop_samples = FFMIN(s->delay_samples, frame->nb_samples);
437  av_log(s, AV_LOG_DEBUG, "Dropping %d/%d delayed samples.\n",
438  drop_samples, s->delay_samples);
439  s->delay_samples -= drop_samples;
440  frame->nb_samples -= drop_samples;
441  input_offset = drop_samples * avctx->ch_layout.nb_channels;
442  if (frame->nb_samples <= 0)
443  return 0;
444  }
445  }
446 #endif
447 
448  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
449  goto end;
450 
451  memcpy(frame->extended_data[0], s->decoder_buffer + input_offset,
452  avctx->ch_layout.nb_channels * frame->nb_samples *
454 
455  *got_frame_ptr = 1;
456  ret = avpkt->size - valid;
457 
458 end:
459  return ret;
460 }
461 
463 {
464  FDKAACDecContext *s = avctx->priv_data;
465  AAC_DECODER_ERROR err;
466 
467  if (!s->handle)
468  return;
469 
470  if ((err = aacDecoder_SetParam(s->handle,
471  AAC_TPDEC_CLEAR_BUFFER, 1)) != AAC_DEC_OK)
472  av_log(avctx, AV_LOG_WARNING, "failed to clear buffer when flushing\n");
473 }
474 
476  .p.name = "libfdk_aac",
477  CODEC_LONG_NAME("Fraunhofer FDK AAC"),
478  .p.type = AVMEDIA_TYPE_AUDIO,
479  .p.id = AV_CODEC_ID_AAC,
480  .priv_data_size = sizeof(FDKAACDecContext),
483  .close = fdk_aac_decode_close,
484  .flush = fdk_aac_decode_flush,
485  .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_CHANNEL_CONF
486 #if FDKDEC_VER_AT_LEAST(2, 5) // 2.5.10
488 #endif
489  ,
490  .p.priv_class = &fdk_aac_dec_class,
491  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
492  .p.wrapper_name = "libfdk",
493 };
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:1091
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:215
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:43
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:1064
ctype
#define ctype
Definition: afir_template.c:46
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:217
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:389
AVPacket::data
uint8_t * data
Definition: packet.h:539
AVOption
AVOption.
Definition: opt.h:429
FFCodec
Definition: codec_internal.h:127
AVChannelLayout::order
enum AVChannelOrder order
Channel order used in this layout.
Definition: channel_layout.h:323
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:328
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:131
AVCodecContext::ch_layout
AVChannelLayout ch_layout
Audio channel layout.
Definition: avcodec.h:1079
FDKAACDecContext
Definition: libfdk-aacdec.c:49
AV_CH_BACK_LEFT
#define AV_CH_BACK_LEFT
Definition: channel_layout.h:179
FDKAACDecContext::conceal_method
int conceal_method
Definition: libfdk-aacdec.c:55
AV_CH_LAYOUT_STEREO
#define AV_CH_LAYOUT_STEREO
Definition: channel_layout.h:218
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:209
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
av_cold
#define av_cold
Definition: attributes.h:90
AV_FRAME_FLAG_KEY
#define AV_FRAME_FLAG_KEY
A flag to mark frames that are keyframes.
Definition: frame.h:640
AV_CH_LOW_FREQUENCY
#define AV_CH_LOW_FREQUENCY
Definition: channel_layout.h:178
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:538
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:311
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:119
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:251
info
MIPS optimizations info
Definition: mips.txt:2
AV_CH_LAYOUT_STEREO_DOWNMIX
#define AV_CH_LAYOUT_STEREO_DOWNMIX
Definition: channel_layout.h:254
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:230
decode.h
OFFSET
#define OFFSET(x)
Definition: libfdk-aacdec.c:76
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:296
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:462
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:75
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
Underlying C type is AVChannelLayout.
Definition: opt.h:331
AV_CH_FRONT_CENTER
#define AV_CH_FRONT_CENTER
Definition: channel_layout.h:177
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:181
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:449
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:1697
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:368
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:540
AVChannelLayout
An AVChannelLayout holds information about the channel layout of audio data.
Definition: channel_layout.h:318
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:1071
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:125
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:182
CONCEAL_METHOD_ENERGY_INTERPOLATION
@ CONCEAL_METHOD_ENERGY_INTERPOLATION
Definition: libfdk-aacdec.c:45
FDKAACDecContext::downmix_layout
AVChannelLayout downmix_layout
Definition: libfdk-aacdec.c:68
get_stream_info
static int get_stream_info(AVCodecContext *avctx, AVFrame *frame)
Definition: libfdk-aacdec.c:114
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
Out-of-band global headers that may be used by some codecs.
Definition: avcodec.h:537
common.h
AV_CH_BACK_CENTER
#define AV_CH_BACK_CENTER
Definition: channel_layout.h:183
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:185
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:80
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:234
ff_libfdk_aac_decoder
const FFCodec ff_libfdk_aac_decoder
Definition: libfdk-aacdec.c:475
AVCodecContext
main external API structure.
Definition: avcodec.h:451
channel_layout.h
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Underlying C type is int.
Definition: opt.h:259
AVCodecContext::profile
int profile
profile
Definition: avcodec.h:1658
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:441
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:516
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:478
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Underlying C type is int.
Definition: opt.h:327
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:482
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:180
fdk_aac_decode_frame
static int fdk_aac_decode_frame(AVCodecContext *avctx, AVFrame *frame, int *got_frame_ptr, AVPacket *avpkt)
Definition: libfdk-aacdec.c:376
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Special option type for declaring named constants.
Definition: opt.h:299
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:246
AV_CH_SIDE_LEFT
#define AV_CH_SIDE_LEFT
Definition: channel_layout.h:184