FFmpeg
aacdec.c
Go to the documentation of this file.
1 /*
2  * AAC decoder
3  * Copyright (c) 2005-2006 Oded Shimon ( ods15 ods15 dyndns org )
4  * Copyright (c) 2006-2007 Maxim Gavrilov ( maxim.gavrilov gmail com )
5  * Copyright (c) 2008-2013 Alex Converse <alex.converse@gmail.com>
6  *
7  * AAC LATM decoder
8  * Copyright (c) 2008-2010 Paul Kendall <paul@kcbbs.gen.nz>
9  * Copyright (c) 2010 Janne Grunau <janne-libav@jannau.net>
10  *
11  * This file is part of FFmpeg.
12  *
13  * FFmpeg is free software; you can redistribute it and/or
14  * modify it under the terms of the GNU Lesser General Public
15  * License as published by the Free Software Foundation; either
16  * version 2.1 of the License, or (at your option) any later version.
17  *
18  * FFmpeg is distributed in the hope that it will be useful,
19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
21  * Lesser General Public License for more details.
22  *
23  * You should have received a copy of the GNU Lesser General Public
24  * License along with FFmpeg; if not, write to the Free Software
25  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
26  */
27 
28 /**
29  * @file
30  * AAC decoder
31  * @author Oded Shimon ( ods15 ods15 dyndns org )
32  * @author Maxim Gavrilov ( maxim.gavrilov gmail com )
33  */
34 
35 #define USE_FIXED 0
36 #define TX_TYPE AV_TX_FLOAT_MDCT
37 
38 #include "libavutil/float_dsp.h"
39 #include "libavutil/opt.h"
40 #include "avcodec.h"
41 #include "codec_internal.h"
42 #include "get_bits.h"
43 #include "lpc.h"
44 #include "kbdwin.h"
45 #include "sinewin.h"
46 
47 #include "aac.h"
48 #include "aacdec.h"
49 #include "aactab.h"
50 #include "aacdectab.h"
51 #include "adts_header.h"
52 #include "cbrt_data.h"
53 #include "sbr.h"
54 #include "aacsbr.h"
55 #include "mpeg4audio.h"
56 #include "profiles.h"
57 #include "libavutil/intfloat.h"
58 
59 #include <errno.h>
60 #include <math.h>
61 #include <stdint.h>
62 #include <string.h>
63 
64 #if ARCH_ARM
65 # include "arm/aac.h"
66 #elif ARCH_MIPS
67 # include "mips/aacdec_mips.h"
68 #endif
69 
74 
76 {
77  ps->r0 = 0.0f;
78  ps->r1 = 0.0f;
79  ps->cor0 = 0.0f;
80  ps->cor1 = 0.0f;
81  ps->var0 = 1.0f;
82  ps->var1 = 1.0f;
83 }
84 
85 #ifndef VMUL2
86 static inline float *VMUL2(float *dst, const float *v, unsigned idx,
87  const float *scale)
88 {
89  float s = *scale;
90  *dst++ = v[idx & 15] * s;
91  *dst++ = v[idx>>4 & 15] * s;
92  return dst;
93 }
94 #endif
95 
96 #ifndef VMUL4
97 static inline float *VMUL4(float *dst, const float *v, unsigned idx,
98  const float *scale)
99 {
100  float s = *scale;
101  *dst++ = v[idx & 3] * s;
102  *dst++ = v[idx>>2 & 3] * s;
103  *dst++ = v[idx>>4 & 3] * s;
104  *dst++ = v[idx>>6 & 3] * s;
105  return dst;
106 }
107 #endif
108 
109 #ifndef VMUL2S
110 static inline float *VMUL2S(float *dst, const float *v, unsigned idx,
111  unsigned sign, const float *scale)
112 {
113  union av_intfloat32 s0, s1;
114 
115  s0.f = s1.f = *scale;
116  s0.i ^= sign >> 1 << 31;
117  s1.i ^= sign << 31;
118 
119  *dst++ = v[idx & 15] * s0.f;
120  *dst++ = v[idx>>4 & 15] * s1.f;
121 
122  return dst;
123 }
124 #endif
125 
126 #ifndef VMUL4S
127 static inline float *VMUL4S(float *dst, const float *v, unsigned idx,
128  unsigned sign, const float *scale)
129 {
130  unsigned nz = idx >> 12;
131  union av_intfloat32 s = { .f = *scale };
132  union av_intfloat32 t;
133 
134  t.i = s.i ^ (sign & 1U<<31);
135  *dst++ = v[idx & 3] * t.f;
136 
137  sign <<= nz & 1; nz >>= 1;
138  t.i = s.i ^ (sign & 1U<<31);
139  *dst++ = v[idx>>2 & 3] * t.f;
140 
141  sign <<= nz & 1; nz >>= 1;
142  t.i = s.i ^ (sign & 1U<<31);
143  *dst++ = v[idx>>4 & 3] * t.f;
144 
145  sign <<= nz & 1;
146  t.i = s.i ^ (sign & 1U<<31);
147  *dst++ = v[idx>>6 & 3] * t.f;
148 
149  return dst;
150 }
151 #endif
152 
153 static av_always_inline float flt16_round(float pf)
154 {
155  union av_intfloat32 tmp;
156  tmp.f = pf;
157  tmp.i = (tmp.i + 0x00008000U) & 0xFFFF0000U;
158  return tmp.f;
159 }
160 
161 static av_always_inline float flt16_even(float pf)
162 {
163  union av_intfloat32 tmp;
164  tmp.f = pf;
165  tmp.i = (tmp.i + 0x00007FFFU + (tmp.i & 0x00010000U >> 16)) & 0xFFFF0000U;
166  return tmp.f;
167 }
168 
169 static av_always_inline float flt16_trunc(float pf)
170 {
171  union av_intfloat32 pun;
172  pun.f = pf;
173  pun.i &= 0xFFFF0000U;
174  return pun.f;
175 }
176 
177 static av_always_inline void predict(PredictorState *ps, float *coef,
178  int output_enable)
179 {
180  const float a = 0.953125; // 61.0 / 64
181  const float alpha = 0.90625; // 29.0 / 32
182  float e0, e1;
183  float pv;
184  float k1, k2;
185  float r0 = ps->r0, r1 = ps->r1;
186  float cor0 = ps->cor0, cor1 = ps->cor1;
187  float var0 = ps->var0, var1 = ps->var1;
188 
189  k1 = var0 > 1 ? cor0 * flt16_even(a / var0) : 0;
190  k2 = var1 > 1 ? cor1 * flt16_even(a / var1) : 0;
191 
192  pv = flt16_round(k1 * r0 + k2 * r1);
193  if (output_enable)
194  *coef += pv;
195 
196  e0 = *coef;
197  e1 = e0 - k1 * r0;
198 
199  ps->cor1 = flt16_trunc(alpha * cor1 + r1 * e1);
200  ps->var1 = flt16_trunc(alpha * var1 + 0.5f * (r1 * r1 + e1 * e1));
201  ps->cor0 = flt16_trunc(alpha * cor0 + r0 * e0);
202  ps->var0 = flt16_trunc(alpha * var0 + 0.5f * (r0 * r0 + e0 * e0));
203 
204  ps->r1 = flt16_trunc(a * (r0 - k1 * e0));
205  ps->r0 = flt16_trunc(a * e0);
206 }
207 
208 /**
209  * Apply dependent channel coupling (applied before IMDCT).
210  *
211  * @param index index into coupling gain array
212  */
214  SingleChannelElement *target,
215  ChannelElement *cce, int index)
216 {
217  IndividualChannelStream *ics = &cce->ch[0].ics;
218  const uint16_t *offsets = ics->swb_offset;
219  float *dest = target->coeffs;
220  const float *src = cce->ch[0].coeffs;
221  int g, i, group, k, idx = 0;
222  if (ac->oc[1].m4ac.object_type == AOT_AAC_LTP) {
224  "Dependent coupling is not supported together with LTP\n");
225  return;
226  }
227  for (g = 0; g < ics->num_window_groups; g++) {
228  for (i = 0; i < ics->max_sfb; i++, idx++) {
229  if (cce->ch[0].band_type[idx] != ZERO_BT) {
230  const float gain = cce->coup.gain[index][idx];
231  for (group = 0; group < ics->group_len[g]; group++) {
232  for (k = offsets[i]; k < offsets[i + 1]; k++) {
233  // FIXME: SIMDify
234  dest[group * 128 + k] += gain * src[group * 128 + k];
235  }
236  }
237  }
238  }
239  dest += ics->group_len[g] * 128;
240  src += ics->group_len[g] * 128;
241  }
242 }
243 
244 /**
245  * Apply independent channel coupling (applied after IMDCT).
246  *
247  * @param index index into coupling gain array
248  */
250  SingleChannelElement *target,
251  ChannelElement *cce, int index)
252 {
253  const float gain = cce->coup.gain[index][0];
254  const float *src = cce->ch[0].ret;
255  float *dest = target->ret;
256  const int len = 1024 << (ac->oc[1].m4ac.sbr == 1);
257 
258  ac->fdsp->vector_fmac_scalar(dest, src, gain, len);
259 }
260 
261 #include "aacdec_template.c"
262 
263 #define LOAS_SYNC_WORD 0x2b7 ///< 11 bits LOAS sync word
264 
265 struct LATMContext {
266  AACDecContext aac_ctx; ///< containing AACContext
267  int initialized; ///< initialized after a valid extradata was seen
268 
269  // parser data
270  int audio_mux_version_A; ///< LATM syntax version
271  int frame_length_type; ///< 0/1 variable/fixed frame length
272  int frame_length; ///< frame length for fixed frame length
273 };
274 
275 static inline uint32_t latm_get_value(GetBitContext *b)
276 {
277  int length = get_bits(b, 2);
278 
279  return get_bits_long(b, (length+1)*8);
280 }
281 
283  GetBitContext *gb, int asclen)
284 {
285  AACDecContext *ac = &latmctx->aac_ctx;
286  AVCodecContext *avctx = ac->avctx;
287  MPEG4AudioConfig m4ac = { 0 };
288  GetBitContext gbc;
289  int config_start_bit = get_bits_count(gb);
290  int sync_extension = 0;
291  int bits_consumed, esize, i;
292 
293  if (asclen > 0) {
294  sync_extension = 1;
295  asclen = FFMIN(asclen, get_bits_left(gb));
296  init_get_bits(&gbc, gb->buffer, config_start_bit + asclen);
297  skip_bits_long(&gbc, config_start_bit);
298  } else if (asclen == 0) {
299  gbc = *gb;
300  } else {
301  return AVERROR_INVALIDDATA;
302  }
303 
304  if (get_bits_left(gb) <= 0)
305  return AVERROR_INVALIDDATA;
306 
307  bits_consumed = decode_audio_specific_config_gb(NULL, avctx, &m4ac,
308  &gbc, config_start_bit,
309  sync_extension);
310 
311  if (bits_consumed < config_start_bit)
312  return AVERROR_INVALIDDATA;
313  bits_consumed -= config_start_bit;
314 
315  if (asclen == 0)
316  asclen = bits_consumed;
317 
318  if (!latmctx->initialized ||
319  ac->oc[1].m4ac.sample_rate != m4ac.sample_rate ||
320  ac->oc[1].m4ac.chan_config != m4ac.chan_config) {
321 
322  if (latmctx->initialized) {
323  av_log(avctx, AV_LOG_INFO, "audio config changed (sample_rate=%d, chan_config=%d)\n", m4ac.sample_rate, m4ac.chan_config);
324  } else {
325  av_log(avctx, AV_LOG_DEBUG, "initializing latmctx\n");
326  }
327  latmctx->initialized = 0;
328 
329  esize = (asclen + 7) / 8;
330 
331  if (avctx->extradata_size < esize) {
332  av_free(avctx->extradata);
334  if (!avctx->extradata)
335  return AVERROR(ENOMEM);
336  }
337 
338  avctx->extradata_size = esize;
339  gbc = *gb;
340  for (i = 0; i < esize; i++) {
341  avctx->extradata[i] = get_bits(&gbc, 8);
342  }
343  memset(avctx->extradata+esize, 0, AV_INPUT_BUFFER_PADDING_SIZE);
344  }
345  skip_bits_long(gb, asclen);
346 
347  return 0;
348 }
349 
350 static int read_stream_mux_config(struct LATMContext *latmctx,
351  GetBitContext *gb)
352 {
353  int ret, audio_mux_version = get_bits(gb, 1);
354 
355  latmctx->audio_mux_version_A = 0;
356  if (audio_mux_version)
357  latmctx->audio_mux_version_A = get_bits(gb, 1);
358 
359  if (!latmctx->audio_mux_version_A) {
360 
361  if (audio_mux_version)
362  latm_get_value(gb); // taraFullness
363 
364  skip_bits(gb, 1); // allStreamSameTimeFraming
365  skip_bits(gb, 6); // numSubFrames
366  // numPrograms
367  if (get_bits(gb, 4)) { // numPrograms
368  avpriv_request_sample(latmctx->aac_ctx.avctx, "Multiple programs");
369  return AVERROR_PATCHWELCOME;
370  }
371 
372  // for each program (which there is only one in DVB)
373 
374  // for each layer (which there is only one in DVB)
375  if (get_bits(gb, 3)) { // numLayer
376  avpriv_request_sample(latmctx->aac_ctx.avctx, "Multiple layers");
377  return AVERROR_PATCHWELCOME;
378  }
379 
380  // for all but first stream: use_same_config = get_bits(gb, 1);
381  if (!audio_mux_version) {
382  if ((ret = latm_decode_audio_specific_config(latmctx, gb, 0)) < 0)
383  return ret;
384  } else {
385  int ascLen = latm_get_value(gb);
386  if ((ret = latm_decode_audio_specific_config(latmctx, gb, ascLen)) < 0)
387  return ret;
388  }
389 
390  latmctx->frame_length_type = get_bits(gb, 3);
391  switch (latmctx->frame_length_type) {
392  case 0:
393  skip_bits(gb, 8); // latmBufferFullness
394  break;
395  case 1:
396  latmctx->frame_length = get_bits(gb, 9);
397  break;
398  case 3:
399  case 4:
400  case 5:
401  skip_bits(gb, 6); // CELP frame length table index
402  break;
403  case 6:
404  case 7:
405  skip_bits(gb, 1); // HVXC frame length table index
406  break;
407  }
408 
409  if (get_bits(gb, 1)) { // other data
410  if (audio_mux_version) {
411  latm_get_value(gb); // other_data_bits
412  } else {
413  int esc;
414  do {
415  if (get_bits_left(gb) < 9)
416  return AVERROR_INVALIDDATA;
417  esc = get_bits(gb, 1);
418  skip_bits(gb, 8);
419  } while (esc);
420  }
421  }
422 
423  if (get_bits(gb, 1)) // crc present
424  skip_bits(gb, 8); // config_crc
425  }
426 
427  return 0;
428 }
429 
431 {
432  uint8_t tmp;
433 
434  if (ctx->frame_length_type == 0) {
435  int mux_slot_length = 0;
436  do {
437  if (get_bits_left(gb) < 8)
438  return AVERROR_INVALIDDATA;
439  tmp = get_bits(gb, 8);
440  mux_slot_length += tmp;
441  } while (tmp == 255);
442  return mux_slot_length;
443  } else if (ctx->frame_length_type == 1) {
444  return ctx->frame_length;
445  } else if (ctx->frame_length_type == 3 ||
446  ctx->frame_length_type == 5 ||
447  ctx->frame_length_type == 7) {
448  skip_bits(gb, 2); // mux_slot_length_coded
449  }
450  return 0;
451 }
452 
453 static int read_audio_mux_element(struct LATMContext *latmctx,
454  GetBitContext *gb)
455 {
456  int err;
457  uint8_t use_same_mux = get_bits(gb, 1);
458  if (!use_same_mux) {
459  if ((err = read_stream_mux_config(latmctx, gb)) < 0)
460  return err;
461  } else if (!latmctx->aac_ctx.avctx->extradata) {
462  av_log(latmctx->aac_ctx.avctx, AV_LOG_DEBUG,
463  "no decoder config found\n");
464  return 1;
465  }
466  if (latmctx->audio_mux_version_A == 0) {
467  int mux_slot_length_bytes = read_payload_length_info(latmctx, gb);
468  if (mux_slot_length_bytes < 0 || mux_slot_length_bytes * 8LL > get_bits_left(gb)) {
469  av_log(latmctx->aac_ctx.avctx, AV_LOG_ERROR, "incomplete frame\n");
470  return AVERROR_INVALIDDATA;
471  } else if (mux_slot_length_bytes * 8 + 256 < get_bits_left(gb)) {
472  av_log(latmctx->aac_ctx.avctx, AV_LOG_ERROR,
473  "frame length mismatch %d << %d\n",
474  mux_slot_length_bytes * 8, get_bits_left(gb));
475  return AVERROR_INVALIDDATA;
476  }
477  }
478  return 0;
479 }
480 
481 
483  int *got_frame_ptr, AVPacket *avpkt)
484 {
485  struct LATMContext *latmctx = avctx->priv_data;
486  int muxlength, err;
487  GetBitContext gb;
488 
489  if ((err = init_get_bits8(&gb, avpkt->data, avpkt->size)) < 0)
490  return err;
491 
492  // check for LOAS sync word
493  if (get_bits(&gb, 11) != LOAS_SYNC_WORD)
494  return AVERROR_INVALIDDATA;
495 
496  muxlength = get_bits(&gb, 13) + 3;
497  // not enough data, the parser should have sorted this out
498  if (muxlength > avpkt->size)
499  return AVERROR_INVALIDDATA;
500 
501  if ((err = read_audio_mux_element(latmctx, &gb)))
502  return (err < 0) ? err : avpkt->size;
503 
504  if (!latmctx->initialized) {
505  if (!avctx->extradata) {
506  *got_frame_ptr = 0;
507  return avpkt->size;
508  } else {
510  if ((err = decode_audio_specific_config(
511  &latmctx->aac_ctx, avctx, &latmctx->aac_ctx.oc[1].m4ac,
512  avctx->extradata, avctx->extradata_size*8LL, 1)) < 0) {
514  return err;
515  }
516  latmctx->initialized = 1;
517  }
518  }
519 
520  if (show_bits(&gb, 12) == 0xfff) {
521  av_log(latmctx->aac_ctx.avctx, AV_LOG_ERROR,
522  "ADTS header detected, probably as result of configuration "
523  "misparsing\n");
524  return AVERROR_INVALIDDATA;
525  }
526 
527  switch (latmctx->aac_ctx.oc[1].m4ac.object_type) {
528  case AOT_ER_AAC_LC:
529  case AOT_ER_AAC_LTP:
530  case AOT_ER_AAC_LD:
531  case AOT_ER_AAC_ELD:
532  err = aac_decode_er_frame(avctx, out, got_frame_ptr, &gb);
533  break;
534  default:
535  err = aac_decode_frame_int(avctx, out, got_frame_ptr, &gb, avpkt);
536  }
537  if (err < 0)
538  return err;
539 
540  return muxlength;
541 }
542 
544 {
545  struct LATMContext *latmctx = avctx->priv_data;
546  int ret = aac_decode_init(avctx);
547 
548  if (avctx->extradata_size > 0)
549  latmctx->initialized = !ret;
550 
551  return ret;
552 }
553 
555  .p.name = "aac",
556  CODEC_LONG_NAME("AAC (Advanced Audio Coding)"),
557  .p.type = AVMEDIA_TYPE_AUDIO,
558  .p.id = AV_CODEC_ID_AAC,
559  .priv_data_size = sizeof(AACDecContext),
561  .close = aac_decode_close,
563  .p.sample_fmts = (const enum AVSampleFormat[]) {
565  },
566  .p.capabilities = AV_CODEC_CAP_CHANNEL_CONF | AV_CODEC_CAP_DR1,
567  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
568  CODEC_OLD_CHANNEL_LAYOUTS_ARRAY(ff_aac_channel_layout)
569  .p.ch_layouts = ff_aac_ch_layout,
570  .flush = flush,
571  .p.priv_class = &aac_decoder_class,
572  .p.profiles = NULL_IF_CONFIG_SMALL(ff_aac_profiles),
573 };
574 
575 /*
576  Note: This decoder filter is intended to decode LATM streams transferred
577  in MPEG transport streams which only contain one program.
578  To do a more complex LATM demuxing a separate LATM demuxer should be used.
579 */
581  .p.name = "aac_latm",
582  CODEC_LONG_NAME("AAC LATM (Advanced Audio Coding LATM syntax)"),
583  .p.type = AVMEDIA_TYPE_AUDIO,
584  .p.id = AV_CODEC_ID_AAC_LATM,
585  .priv_data_size = sizeof(struct LATMContext),
587  .close = aac_decode_close,
589  .p.sample_fmts = (const enum AVSampleFormat[]) {
591  },
592  .p.capabilities = AV_CODEC_CAP_CHANNEL_CONF | AV_CODEC_CAP_DR1,
593  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
594  CODEC_OLD_CHANNEL_LAYOUTS_ARRAY(ff_aac_channel_layout)
595  .p.ch_layouts = ff_aac_ch_layout,
596  .flush = flush,
597  .p.profiles = NULL_IF_CONFIG_SMALL(ff_aac_profiles),
598 };
AV_SAMPLE_FMT_FLTP
@ AV_SAMPLE_FMT_FLTP
float, planar
Definition: samplefmt.h:66
skip_bits_long
static void skip_bits_long(GetBitContext *s, int n)
Skips the specified number of bits.
Definition: get_bits.h:278
LATMContext::frame_length_type
int frame_length_type
0/1 variable/fixed frame length
Definition: aacdec.c:271
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
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:694
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
decode_audio_specific_config_gb
static int decode_audio_specific_config_gb(AACDecContext *ac, AVCodecContext *avctx, MPEG4AudioConfig *m4ac, GetBitContext *gb, int get_bit_alignment, int sync_extension)
Decode audio specific configuration; reference: table 1.13.
Definition: aacdec_template.c:990
out
FILE * out
Definition: movenc.c:54
aac_decode_init
static av_cold int aac_decode_init(AVCodecContext *avctx)
Definition: aacdec_template.c:1154
aac_kbd_short_120
static INTFLOAT aac_kbd_short_120[120]
Definition: aacdec.c:73
get_bits_long
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:421
get_bits_count
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:266
PredictorState::var1
AAC_FLOAT var1
Definition: aac.h:95
aacsbr.h
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:340
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:28
PredictorState::var0
AAC_FLOAT var0
Definition: aac.h:94
AVPacket::data
uint8_t * data
Definition: packet.h:522
av_intfloat32::i
uint32_t i
Definition: intfloat.h:28
aacdectab.h
b
#define b
Definition: input.c:41
AOT_ER_AAC_LTP
@ AOT_ER_AAC_LTP
N Error Resilient Long Term Prediction.
Definition: mpeg4audio.h:88
FFCodec
Definition: codec_internal.h:127
ff_aac_profiles
const AVProfile ff_aac_profiles[]
Definition: profiles.c:26
decode_audio_specific_config
static int decode_audio_specific_config(AACDecContext *ac, AVCodecContext *avctx, MPEG4AudioConfig *m4ac, const uint8_t *data, int64_t bit_size, int sync_extension)
Definition: aacdec_template.c:1057
apply_independent_coupling
static void apply_independent_coupling(AACDecContext *ac, SingleChannelElement *target, ChannelElement *cce, int index)
Apply independent channel coupling (applied after IMDCT).
Definition: aacdec.c:249
ff_aac_decoder
const FFCodec ff_aac_decoder
Definition: aacdec.c:554
lpc.h
SingleChannelElement::ret
INTFLOAT * ret
PCM output.
Definition: aacdec.h:142
latm_decode_audio_specific_config
static int latm_decode_audio_specific_config(struct LATMContext *latmctx, GetBitContext *gb, int asclen)
Definition: aacdec.c:282
intfloat.h
ChannelElement::ch
SingleChannelElement ch[2]
Definition: aacdec.h:153
push_output_configuration
static int push_output_configuration(AACDecContext *ac)
Save current output configuration if and only if it has been locked.
Definition: aacdec_template.c:414
init_get_bits
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:514
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:30
sbr.h
MPEG4AudioConfig
Definition: mpeg4audio.h:29
skip_bits
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:381
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:335
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:131
mpeg4audio.h
ChannelElement::coup
ChannelCoupling coup
Definition: aacdec.h:155
latm_decode_init
static av_cold int latm_decode_init(AVCodecContext *avctx)
Definition: aacdec.c:543
read_audio_mux_element
static int read_audio_mux_element(struct LATMContext *latmctx, GetBitContext *gb)
Definition: aacdec.c:453
GetBitContext
Definition: get_bits.h:108
VMUL2
static float * VMUL2(float *dst, const float *v, unsigned idx, const float *scale)
Definition: aacdec.c:86
PredictorState::r0
AAC_FLOAT r0
Definition: aac.h:96
SingleChannelElement::ics
IndividualChannelStream ics
Definition: aacdec.h:132
aac_decode_frame
static int aac_decode_frame(AVCodecContext *avctx, AVFrame *frame, int *got_frame_ptr, AVPacket *avpkt)
Definition: aacdec_template.c:3319
AOT_ER_AAC_LC
@ AOT_ER_AAC_LC
N Error Resilient Low Complexity.
Definition: mpeg4audio.h:87
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
ZERO_BT
@ ZERO_BT
Scalefactors and spectral data are all zero.
Definition: aac.h:70
av_cold
#define av_cold
Definition: attributes.h:90
init_get_bits8
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:545
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:547
AOT_ER_AAC_LD
@ AOT_ER_AAC_LD
N Error Resilient Low Delay.
Definition: mpeg4audio.h:92
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:306
aac_decoder_class
static const AVClass aac_decoder_class
Definition: aacdec_template.c:3451
s
#define s(width, name)
Definition: cbs_vp9.c:198
SingleChannelElement::coeffs
INTFLOAT coeffs[1024]
coefficients for IMDCT, maybe processed
Definition: aacdec.h:137
reset_predict_state
static av_always_inline void reset_predict_state(PredictorState *ps)
Definition: aacdec.c:75
offsets
static const int offsets[]
Definition: hevc_pel.c:34
g
const char * g
Definition: vf_curves.c:127
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
s1
#define s1
Definition: regdef.h:38
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
PredictorState
Predictor State.
Definition: aac.h:91
ctx
AVFormatContext * ctx
Definition: movenc.c:48
get_bits.h
LATMContext::frame_length
int frame_length
frame length for fixed frame length
Definition: aacdec.c:272
kbdwin.h
ff_aac_ch_layout
const AVChannelLayout ff_aac_ch_layout[]
Definition: aacdec_common.c:112
IndividualChannelStream
Individual Channel Stream.
Definition: aacdec.h:84
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:272
aacdec_mips.h
AACDecContext::fdsp
AVFloatDSPContext * fdsp
Definition: aacdec.h:234
GetBitContext::buffer
const uint8_t * buffer
Definition: get_bits.h:109
NULL
#define NULL
Definition: coverity.c:32
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
IndividualChannelStream::num_window_groups
int num_window_groups
Definition: aacdec.h:88
aac_decode_close
static av_cold int aac_decode_close(AVCodecContext *avctx)
Definition: aacdec_template.c:3382
profiles.h
flush
void(* flush)(AVBSFContext *ctx)
Definition: dts2pts.c:367
flt16_trunc
static av_always_inline float flt16_trunc(float pf)
Definition: aacdec.c:169
aac.h
aactab.h
flt16_even
static av_always_inline float flt16_even(float pf)
Definition: aacdec.c:161
LATMContext::initialized
int initialized
initialized after a valid extradata was seen
Definition: aacdec.c:267
av_intfloat32
Definition: intfloat.h:27
PredictorState::r1
AAC_FLOAT r1
Definition: aac.h:97
flt16_round
static av_always_inline float flt16_round(float pf)
Definition: aacdec.c:153
index
int index
Definition: gxfenc.c:89
pop_output_configuration
static void pop_output_configuration(AACDecContext *ac)
Restore the previous output configuration if and only if the current configuration is unlocked.
Definition: aacdec_template.c:430
float_dsp.h
VMUL2S
static float * VMUL2S(float *dst, const float *v, unsigned idx, unsigned sign, const float *scale)
Definition: aacdec.c:110
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:445
VMUL4
static float * VMUL4(float *dst, const float *v, unsigned idx, const float *scale)
Definition: aacdec.c:97
VMUL4S
static float * VMUL4S(float *dst, const float *v, unsigned idx, unsigned sign, const float *scale)
Definition: aacdec.c:127
f
f
Definition: af_crystalizer.c:121
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:365
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:523
scale
static void scale(int *out, const int *in, const int w, const int h, const int shift)
Definition: vvc_intra.c:292
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:106
codec_internal.h
DECLARE_ALIGNED
#define DECLARE_ALIGNED(n, t, v)
Definition: mem_internal.h:109
sine_120
static INTFLOAT sine_120[120]
Definition: aacdec.c:70
sine_960
static INTFLOAT sine_960[960]
Definition: aacdec.c:71
AV_SAMPLE_FMT_NONE
@ AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:56
a
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:41
sinewin.h
SingleChannelElement::band_type
enum BandType band_type[128]
band types
Definition: aacdec.h:134
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:191
cbrt_data.h
aac_kbd_long_960
static INTFLOAT aac_kbd_long_960[960]
Definition: aacdec.c:72
LATMContext
Definition: aacdec.c:265
CODEC_OLD_CHANNEL_LAYOUTS_ARRAY
#define CODEC_OLD_CHANNEL_LAYOUTS_ARRAY(array)
Definition: codec_internal.h:303
SingleChannelElement
Single Channel Element - used for both SCE and LFE elements.
Definition: aacdec.h:131
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:255
aac_decode_er_frame
static int aac_decode_er_frame(AVCodecContext *avctx, AVFrame *frame, int *got_frame_ptr, GetBitContext *gb)
Definition: aacdec_template.c:3037
AVFloatDSPContext::vector_fmac_scalar
void(* vector_fmac_scalar)(float *dst, const float *src, float mul, int len)
Multiply a vector of floats by a scalar float and add to destination vector.
Definition: float_dsp.h:54
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:546
show_bits
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
Definition: get_bits.h:371
aac.h
ChannelElement
channel element - generic struct for SCE/CPE/CCE/LFE
Definition: aacdec.h:148
IndividualChannelStream::swb_offset
const uint16_t * swb_offset
table of offsets to the lowest spectral coefficient of a scalefactor band, sfb, for a particular wind...
Definition: aacdec.h:91
AOT_ER_AAC_ELD
@ AOT_ER_AAC_ELD
N Error Resilient Enhanced Low Delay.
Definition: mpeg4audio.h:108
predict
static av_always_inline void predict(PredictorState *ps, float *coef, int output_enable)
Definition: aacdec.c:177
AVSampleFormat
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:55
av_always_inline
#define av_always_inline
Definition: attributes.h:49
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
AAC_RENAME
#define AAC_RENAME(x)
Definition: aac_defines.h:78
MPEG4AudioConfig::chan_config
int chan_config
Definition: mpeg4audio.h:33
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:194
latm_decode_frame
static int latm_decode_frame(AVCodecContext *avctx, AVFrame *out, int *got_frame_ptr, AVPacket *avpkt)
Definition: aacdec.c:482
len
int len
Definition: vorbis_enc_data.h:426
AACDecContext::oc
OutputConfiguration oc[2]
Definition: aacdec.h:259
apply_dependent_coupling
static void apply_dependent_coupling(AACDecContext *ac, SingleChannelElement *target, ChannelElement *cce, int index)
Apply dependent channel coupling (applied before IMDCT).
Definition: aacdec.c:213
avcodec.h
pv
#define pv
Definition: regdef.h:60
ret
ret
Definition: filter_design.txt:187
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Definition: defs.h:40
MPEG4AudioConfig::object_type
int object_type
Definition: mpeg4audio.h:30
U
#define U(x)
Definition: vpx_arith.h:37
aacdec.h
LATMContext::audio_mux_version_A
int audio_mux_version_A
LATM syntax version.
Definition: aacdec.c:270
AACDecContext
main AAC decoding context
Definition: aacdec.h:186
AVCodecContext
main external API structure.
Definition: avcodec.h:445
AACDecContext::avctx
struct AVCodecContext * avctx
Definition: aacdec.h:188
ff_aac_latm_decoder
const FFCodec ff_aac_latm_decoder
Definition: aacdec.c:580
ChannelCoupling::gain
INTFLOAT gain[16][120]
Definition: aacdec.h:125
MPEG4AudioConfig::sbr
int sbr
-1 implicit, 1 presence
Definition: mpeg4audio.h:34
read_stream_mux_config
static int read_stream_mux_config(struct LATMContext *latmctx, GetBitContext *gb)
Definition: aacdec.c:350
OutputConfiguration::m4ac
MPEG4AudioConfig m4ac
Definition: aacdec.h:160
av_intfloat32::f
float f
Definition: intfloat.h:29
aacdec_template.c
PredictorState::cor1
AAC_FLOAT cor1
Definition: aac.h:93
s0
#define s0
Definition: regdef.h:37
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h:36
adts_header.h
LOAS_SYNC_WORD
#define LOAS_SYNC_WORD
11 bits LOAS sync word
Definition: aacdec.c:263
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
alpha
static const int16_t alpha[]
Definition: ilbcdata.h:55
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:472
AVPacket
This structure stores compressed data.
Definition: packet.h:499
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
latm_get_value
static uint32_t latm_get_value(GetBitContext *b)
Definition: aacdec.c:275
IndividualChannelStream::max_sfb
uint8_t max_sfb
number of scalefactor bands per group
Definition: aacdec.h:85
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AV_CODEC_ID_AAC_LATM
@ AV_CODEC_ID_AAC_LATM
Definition: codec_id.h:492
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
read_payload_length_info
static int read_payload_length_info(struct LATMContext *ctx, GetBitContext *gb)
Definition: aacdec.c:430
aac_decode_frame_int
static int aac_decode_frame_int(AVCodecContext *avctx, AVFrame *frame, int *got_frame_ptr, GetBitContext *gb, const AVPacket *avpkt)
Definition: aacdec_template.c:3109
IndividualChannelStream::group_len
uint8_t group_len[8]
Definition: aacdec.h:89
INTFLOAT
float INTFLOAT
Definition: aac_defines.h:80
AOT_AAC_LTP
@ AOT_AAC_LTP
Y Long Term Prediction.
Definition: mpeg4audio.h:76
LATMContext::aac_ctx
AACDecContext aac_ctx
containing AACContext
Definition: aacdec.c:266
MPEG4AudioConfig::sample_rate
int sample_rate
Definition: mpeg4audio.h:32
PredictorState::cor0
AAC_FLOAT cor0
Definition: aac.h:92