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 FFT_FLOAT 1
36 #define USE_FIXED 0
37 
38 #include "libavutil/float_dsp.h"
39 #include "libavutil/opt.h"
40 #include "avcodec.h"
41 #include "internal.h"
42 #include "get_bits.h"
43 #include "fft.h"
44 #include "mdct15.h"
45 #include "lpc.h"
46 #include "kbdwin.h"
47 #include "sinewin.h"
48 
49 #include "aac.h"
50 #include "aactab.h"
51 #include "aacdectab.h"
52 #include "adts_header.h"
53 #include "cbrt_data.h"
54 #include "sbr.h"
55 #include "aacsbr.h"
56 #include "mpeg4audio.h"
57 #include "profiles.h"
58 #include "libavutil/intfloat.h"
59 
60 #include <errno.h>
61 #include <math.h>
62 #include <stdint.h>
63 #include <string.h>
64 
65 #if ARCH_ARM
66 # include "arm/aac.h"
67 #elif ARCH_MIPS
68 # include "mips/aacdec_mips.h"
69 #endif
70 
75 
77 {
78  ps->r0 = 0.0f;
79  ps->r1 = 0.0f;
80  ps->cor0 = 0.0f;
81  ps->cor1 = 0.0f;
82  ps->var0 = 1.0f;
83  ps->var1 = 1.0f;
84 }
85 
86 #ifndef VMUL2
87 static inline float *VMUL2(float *dst, const float *v, unsigned idx,
88  const float *scale)
89 {
90  float s = *scale;
91  *dst++ = v[idx & 15] * s;
92  *dst++ = v[idx>>4 & 15] * s;
93  return dst;
94 }
95 #endif
96 
97 #ifndef VMUL4
98 static inline float *VMUL4(float *dst, const float *v, unsigned idx,
99  const float *scale)
100 {
101  float s = *scale;
102  *dst++ = v[idx & 3] * s;
103  *dst++ = v[idx>>2 & 3] * s;
104  *dst++ = v[idx>>4 & 3] * s;
105  *dst++ = v[idx>>6 & 3] * s;
106  return dst;
107 }
108 #endif
109 
110 #ifndef VMUL2S
111 static inline float *VMUL2S(float *dst, const float *v, unsigned idx,
112  unsigned sign, const float *scale)
113 {
114  union av_intfloat32 s0, s1;
115 
116  s0.f = s1.f = *scale;
117  s0.i ^= sign >> 1 << 31;
118  s1.i ^= sign << 31;
119 
120  *dst++ = v[idx & 15] * s0.f;
121  *dst++ = v[idx>>4 & 15] * s1.f;
122 
123  return dst;
124 }
125 #endif
126 
127 #ifndef VMUL4S
128 static inline float *VMUL4S(float *dst, const float *v, unsigned idx,
129  unsigned sign, const float *scale)
130 {
131  unsigned nz = idx >> 12;
132  union av_intfloat32 s = { .f = *scale };
133  union av_intfloat32 t;
134 
135  t.i = s.i ^ (sign & 1U<<31);
136  *dst++ = v[idx & 3] * t.f;
137 
138  sign <<= nz & 1; nz >>= 1;
139  t.i = s.i ^ (sign & 1U<<31);
140  *dst++ = v[idx>>2 & 3] * t.f;
141 
142  sign <<= nz & 1; nz >>= 1;
143  t.i = s.i ^ (sign & 1U<<31);
144  *dst++ = v[idx>>4 & 3] * t.f;
145 
146  sign <<= nz & 1;
147  t.i = s.i ^ (sign & 1U<<31);
148  *dst++ = v[idx>>6 & 3] * t.f;
149 
150  return dst;
151 }
152 #endif
153 
154 static av_always_inline float flt16_round(float pf)
155 {
156  union av_intfloat32 tmp;
157  tmp.f = pf;
158  tmp.i = (tmp.i + 0x00008000U) & 0xFFFF0000U;
159  return tmp.f;
160 }
161 
162 static av_always_inline float flt16_even(float pf)
163 {
164  union av_intfloat32 tmp;
165  tmp.f = pf;
166  tmp.i = (tmp.i + 0x00007FFFU + (tmp.i & 0x00010000U >> 16)) & 0xFFFF0000U;
167  return tmp.f;
168 }
169 
170 static av_always_inline float flt16_trunc(float pf)
171 {
172  union av_intfloat32 pun;
173  pun.f = pf;
174  pun.i &= 0xFFFF0000U;
175  return pun.f;
176 }
177 
178 static av_always_inline void predict(PredictorState *ps, float *coef,
179  int output_enable)
180 {
181  const float a = 0.953125; // 61.0 / 64
182  const float alpha = 0.90625; // 29.0 / 32
183  float e0, e1;
184  float pv;
185  float k1, k2;
186  float r0 = ps->r0, r1 = ps->r1;
187  float cor0 = ps->cor0, cor1 = ps->cor1;
188  float var0 = ps->var0, var1 = ps->var1;
189 
190  k1 = var0 > 1 ? cor0 * flt16_even(a / var0) : 0;
191  k2 = var1 > 1 ? cor1 * flt16_even(a / var1) : 0;
192 
193  pv = flt16_round(k1 * r0 + k2 * r1);
194  if (output_enable)
195  *coef += pv;
196 
197  e0 = *coef;
198  e1 = e0 - k1 * r0;
199 
200  ps->cor1 = flt16_trunc(alpha * cor1 + r1 * e1);
201  ps->var1 = flt16_trunc(alpha * var1 + 0.5f * (r1 * r1 + e1 * e1));
202  ps->cor0 = flt16_trunc(alpha * cor0 + r0 * e0);
203  ps->var0 = flt16_trunc(alpha * var0 + 0.5f * (r0 * r0 + e0 * e0));
204 
205  ps->r1 = flt16_trunc(a * (r0 - k1 * e0));
206  ps->r0 = flt16_trunc(a * e0);
207 }
208 
209 /**
210  * Apply dependent channel coupling (applied before IMDCT).
211  *
212  * @param index index into coupling gain array
213  */
215  SingleChannelElement *target,
216  ChannelElement *cce, int index)
217 {
218  IndividualChannelStream *ics = &cce->ch[0].ics;
219  const uint16_t *offsets = ics->swb_offset;
220  float *dest = target->coeffs;
221  const float *src = cce->ch[0].coeffs;
222  int g, i, group, k, idx = 0;
223  if (ac->oc[1].m4ac.object_type == AOT_AAC_LTP) {
225  "Dependent coupling is not supported together with LTP\n");
226  return;
227  }
228  for (g = 0; g < ics->num_window_groups; g++) {
229  for (i = 0; i < ics->max_sfb; i++, idx++) {
230  if (cce->ch[0].band_type[idx] != ZERO_BT) {
231  const float gain = cce->coup.gain[index][idx];
232  for (group = 0; group < ics->group_len[g]; group++) {
233  for (k = offsets[i]; k < offsets[i + 1]; k++) {
234  // FIXME: SIMDify
235  dest[group * 128 + k] += gain * src[group * 128 + k];
236  }
237  }
238  }
239  }
240  dest += ics->group_len[g] * 128;
241  src += ics->group_len[g] * 128;
242  }
243 }
244 
245 /**
246  * Apply independent channel coupling (applied after IMDCT).
247  *
248  * @param index index into coupling gain array
249  */
251  SingleChannelElement *target,
252  ChannelElement *cce, int index)
253 {
254  const float gain = cce->coup.gain[index][0];
255  const float *src = cce->ch[0].ret;
256  float *dest = target->ret;
257  const int len = 1024 << (ac->oc[1].m4ac.sbr == 1);
258 
259  ac->fdsp->vector_fmac_scalar(dest, src, gain, len);
260 }
261 
262 #include "aacdec_template.c"
263 
264 #define LOAS_SYNC_WORD 0x2b7 ///< 11 bits LOAS sync word
265 
266 struct LATMContext {
267  AACContext aac_ctx; ///< containing AACContext
268  int initialized; ///< initialized after a valid extradata was seen
269 
270  // parser data
271  int audio_mux_version_A; ///< LATM syntax version
272  int frame_length_type; ///< 0/1 variable/fixed frame length
273  int frame_length; ///< frame length for fixed frame length
274 };
275 
276 static inline uint32_t latm_get_value(GetBitContext *b)
277 {
278  int length = get_bits(b, 2);
279 
280  return get_bits_long(b, (length+1)*8);
281 }
282 
284  GetBitContext *gb, int asclen)
285 {
286  AACContext *ac = &latmctx->aac_ctx;
287  AVCodecContext *avctx = ac->avctx;
288  MPEG4AudioConfig m4ac = { 0 };
289  GetBitContext gbc;
290  int config_start_bit = get_bits_count(gb);
291  int sync_extension = 0;
292  int bits_consumed, esize, i;
293 
294  if (asclen > 0) {
295  sync_extension = 1;
296  asclen = FFMIN(asclen, get_bits_left(gb));
297  init_get_bits(&gbc, gb->buffer, config_start_bit + asclen);
298  skip_bits_long(&gbc, config_start_bit);
299  } else if (asclen == 0) {
300  gbc = *gb;
301  } else {
302  return AVERROR_INVALIDDATA;
303  }
304 
305  if (get_bits_left(gb) <= 0)
306  return AVERROR_INVALIDDATA;
307 
308  bits_consumed = decode_audio_specific_config_gb(NULL, avctx, &m4ac,
309  &gbc, config_start_bit,
310  sync_extension);
311 
312  if (bits_consumed < config_start_bit)
313  return AVERROR_INVALIDDATA;
314  bits_consumed -= config_start_bit;
315 
316  if (asclen == 0)
317  asclen = bits_consumed;
318 
319  if (!latmctx->initialized ||
320  ac->oc[1].m4ac.sample_rate != m4ac.sample_rate ||
321  ac->oc[1].m4ac.chan_config != m4ac.chan_config) {
322 
323  if (latmctx->initialized) {
324  av_log(avctx, AV_LOG_INFO, "audio config changed (sample_rate=%d, chan_config=%d)\n", m4ac.sample_rate, m4ac.chan_config);
325  } else {
326  av_log(avctx, AV_LOG_DEBUG, "initializing latmctx\n");
327  }
328  latmctx->initialized = 0;
329 
330  esize = (asclen + 7) / 8;
331 
332  if (avctx->extradata_size < esize) {
333  av_free(avctx->extradata);
335  if (!avctx->extradata)
336  return AVERROR(ENOMEM);
337  }
338 
339  avctx->extradata_size = esize;
340  gbc = *gb;
341  for (i = 0; i < esize; i++) {
342  avctx->extradata[i] = get_bits(&gbc, 8);
343  }
344  memset(avctx->extradata+esize, 0, AV_INPUT_BUFFER_PADDING_SIZE);
345  }
346  skip_bits_long(gb, asclen);
347 
348  return 0;
349 }
350 
351 static int read_stream_mux_config(struct LATMContext *latmctx,
352  GetBitContext *gb)
353 {
354  int ret, audio_mux_version = get_bits(gb, 1);
355 
356  latmctx->audio_mux_version_A = 0;
357  if (audio_mux_version)
358  latmctx->audio_mux_version_A = get_bits(gb, 1);
359 
360  if (!latmctx->audio_mux_version_A) {
361 
362  if (audio_mux_version)
363  latm_get_value(gb); // taraFullness
364 
365  skip_bits(gb, 1); // allStreamSameTimeFraming
366  skip_bits(gb, 6); // numSubFrames
367  // numPrograms
368  if (get_bits(gb, 4)) { // numPrograms
369  avpriv_request_sample(latmctx->aac_ctx.avctx, "Multiple programs");
370  return AVERROR_PATCHWELCOME;
371  }
372 
373  // for each program (which there is only one in DVB)
374 
375  // for each layer (which there is only one in DVB)
376  if (get_bits(gb, 3)) { // numLayer
377  avpriv_request_sample(latmctx->aac_ctx.avctx, "Multiple layers");
378  return AVERROR_PATCHWELCOME;
379  }
380 
381  // for all but first stream: use_same_config = get_bits(gb, 1);
382  if (!audio_mux_version) {
383  if ((ret = latm_decode_audio_specific_config(latmctx, gb, 0)) < 0)
384  return ret;
385  } else {
386  int ascLen = latm_get_value(gb);
387  if ((ret = latm_decode_audio_specific_config(latmctx, gb, ascLen)) < 0)
388  return ret;
389  }
390 
391  latmctx->frame_length_type = get_bits(gb, 3);
392  switch (latmctx->frame_length_type) {
393  case 0:
394  skip_bits(gb, 8); // latmBufferFullness
395  break;
396  case 1:
397  latmctx->frame_length = get_bits(gb, 9);
398  break;
399  case 3:
400  case 4:
401  case 5:
402  skip_bits(gb, 6); // CELP frame length table index
403  break;
404  case 6:
405  case 7:
406  skip_bits(gb, 1); // HVXC frame length table index
407  break;
408  }
409 
410  if (get_bits(gb, 1)) { // other data
411  if (audio_mux_version) {
412  latm_get_value(gb); // other_data_bits
413  } else {
414  int esc;
415  do {
416  if (get_bits_left(gb) < 9)
417  return AVERROR_INVALIDDATA;
418  esc = get_bits(gb, 1);
419  skip_bits(gb, 8);
420  } while (esc);
421  }
422  }
423 
424  if (get_bits(gb, 1)) // crc present
425  skip_bits(gb, 8); // config_crc
426  }
427 
428  return 0;
429 }
430 
432 {
433  uint8_t tmp;
434 
435  if (ctx->frame_length_type == 0) {
436  int mux_slot_length = 0;
437  do {
438  if (get_bits_left(gb) < 8)
439  return AVERROR_INVALIDDATA;
440  tmp = get_bits(gb, 8);
441  mux_slot_length += tmp;
442  } while (tmp == 255);
443  return mux_slot_length;
444  } else if (ctx->frame_length_type == 1) {
445  return ctx->frame_length;
446  } else if (ctx->frame_length_type == 3 ||
447  ctx->frame_length_type == 5 ||
448  ctx->frame_length_type == 7) {
449  skip_bits(gb, 2); // mux_slot_length_coded
450  }
451  return 0;
452 }
453 
454 static int read_audio_mux_element(struct LATMContext *latmctx,
455  GetBitContext *gb)
456 {
457  int err;
458  uint8_t use_same_mux = get_bits(gb, 1);
459  if (!use_same_mux) {
460  if ((err = read_stream_mux_config(latmctx, gb)) < 0)
461  return err;
462  } else if (!latmctx->aac_ctx.avctx->extradata) {
463  av_log(latmctx->aac_ctx.avctx, AV_LOG_DEBUG,
464  "no decoder config found\n");
465  return 1;
466  }
467  if (latmctx->audio_mux_version_A == 0) {
468  int mux_slot_length_bytes = read_payload_length_info(latmctx, gb);
469  if (mux_slot_length_bytes < 0 || mux_slot_length_bytes * 8LL > get_bits_left(gb)) {
470  av_log(latmctx->aac_ctx.avctx, AV_LOG_ERROR, "incomplete frame\n");
471  return AVERROR_INVALIDDATA;
472  } else if (mux_slot_length_bytes * 8 + 256 < get_bits_left(gb)) {
473  av_log(latmctx->aac_ctx.avctx, AV_LOG_ERROR,
474  "frame length mismatch %d << %d\n",
475  mux_slot_length_bytes * 8, get_bits_left(gb));
476  return AVERROR_INVALIDDATA;
477  }
478  }
479  return 0;
480 }
481 
482 
483 static int latm_decode_frame(AVCodecContext *avctx, void *out,
484  int *got_frame_ptr, AVPacket *avpkt)
485 {
486  struct LATMContext *latmctx = avctx->priv_data;
487  int muxlength, err;
488  GetBitContext gb;
489 
490  if ((err = init_get_bits8(&gb, avpkt->data, avpkt->size)) < 0)
491  return err;
492 
493  // check for LOAS sync word
494  if (get_bits(&gb, 11) != LOAS_SYNC_WORD)
495  return AVERROR_INVALIDDATA;
496 
497  muxlength = get_bits(&gb, 13) + 3;
498  // not enough data, the parser should have sorted this out
499  if (muxlength > avpkt->size)
500  return AVERROR_INVALIDDATA;
501 
502  if ((err = read_audio_mux_element(latmctx, &gb)))
503  return (err < 0) ? err : avpkt->size;
504 
505  if (!latmctx->initialized) {
506  if (!avctx->extradata) {
507  *got_frame_ptr = 0;
508  return avpkt->size;
509  } else {
511  if ((err = decode_audio_specific_config(
512  &latmctx->aac_ctx, avctx, &latmctx->aac_ctx.oc[1].m4ac,
513  avctx->extradata, avctx->extradata_size*8LL, 1)) < 0) {
515  return err;
516  }
517  latmctx->initialized = 1;
518  }
519  }
520 
521  if (show_bits(&gb, 12) == 0xfff) {
522  av_log(latmctx->aac_ctx.avctx, AV_LOG_ERROR,
523  "ADTS header detected, probably as result of configuration "
524  "misparsing\n");
525  return AVERROR_INVALIDDATA;
526  }
527 
528  switch (latmctx->aac_ctx.oc[1].m4ac.object_type) {
529  case AOT_ER_AAC_LC:
530  case AOT_ER_AAC_LTP:
531  case AOT_ER_AAC_LD:
532  case AOT_ER_AAC_ELD:
533  err = aac_decode_er_frame(avctx, out, got_frame_ptr, &gb);
534  break;
535  default:
536  err = aac_decode_frame_int(avctx, out, got_frame_ptr, &gb, avpkt);
537  }
538  if (err < 0)
539  return err;
540 
541  return muxlength;
542 }
543 
545 {
546  struct LATMContext *latmctx = avctx->priv_data;
547  int ret = aac_decode_init(avctx);
548 
549  if (avctx->extradata_size > 0)
550  latmctx->initialized = !ret;
551 
552  return ret;
553 }
554 
556  .name = "aac",
557  .long_name = NULL_IF_CONFIG_SMALL("AAC (Advanced Audio Coding)"),
558  .type = AVMEDIA_TYPE_AUDIO,
559  .id = AV_CODEC_ID_AAC,
560  .priv_data_size = sizeof(AACContext),
562  .close = aac_decode_close,
564  .sample_fmts = (const enum AVSampleFormat[]) {
566  },
569  .channel_layouts = aac_channel_layout,
570  .flush = flush,
571  .priv_class = &aac_decoder_class,
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  .name = "aac_latm",
582  .long_name = NULL_IF_CONFIG_SMALL("AAC LATM (Advanced Audio Coding LATM syntax)"),
583  .type = AVMEDIA_TYPE_AUDIO,
584  .id = AV_CODEC_ID_AAC_LATM,
585  .priv_data_size = sizeof(struct LATMContext),
587  .close = aac_decode_close,
588  .decode = latm_decode_frame,
589  .sample_fmts = (const enum AVSampleFormat[]) {
591  },
594  .channel_layouts = aac_channel_layout,
595  .flush = flush,
597 };
aac_channel_layout
static const uint64_t aac_channel_layout[16]
Definition: aacdectab.h:75
AVCodec
AVCodec.
Definition: codec.h:197
AV_SAMPLE_FMT_FLTP
@ AV_SAMPLE_FMT_FLTP
float, planar
Definition: samplefmt.h:69
skip_bits_long
static void skip_bits_long(GetBitContext *s, int n)
Skips the specified number of bits.
Definition: get_bits.h:292
LATMContext::frame_length_type
int frame_length_type
0/1 variable/fixed frame length
Definition: aacdec.c:272
FF_CODEC_CAP_INIT_THREADSAFE
#define FF_CODEC_CAP_INIT_THREADSAFE
The codec does not modify any global variables in the init function, allowing to call the init functi...
Definition: internal.h:42
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:850
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
out
FILE * out
Definition: movenc.c:54
aac_decode_frame
static int aac_decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)
Definition: aacdec_template.c:3436
sample_fmts
static enum AVSampleFormat sample_fmts[]
Definition: adpcmenc.c:948
aac_decode_init
static av_cold int aac_decode_init(AVCodecContext *avctx)
Definition: aacdec_template.c:1260
aac_kbd_short_120
static INTFLOAT aac_kbd_short_120[120]
Definition: aacdec.c:74
get_bits_long
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:547
get_bits_count
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:220
PredictorState::var1
AAC_FLOAT var1
Definition: aac.h:140
aacsbr.h
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:26
PredictorState::var0
AAC_FLOAT var0
Definition: aac.h:139
index
fg index
Definition: ffmpeg_filter.c:168
apply_dependent_coupling
static void apply_dependent_coupling(AACContext *ac, SingleChannelElement *target, ChannelElement *cce, int index)
Apply dependent channel coupling (applied before IMDCT).
Definition: aacdec.c:214
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:373
av_intfloat32::i
uint32_t i
Definition: intfloat.h:28
LATMContext::aac_ctx
AACContext aac_ctx
containing AACContext
Definition: aacdec.c:267
aacdectab.h
b
#define b
Definition: input.c:40
AOT_ER_AAC_LTP
@ AOT_ER_AAC_LTP
N Error Resilient Long Term Prediction.
Definition: mpeg4audio.h:92
mdct15.h
ff_aac_profiles
const AVProfile ff_aac_profiles[]
Definition: profiles.c:26
lpc.h
pop_output_configuration
static void pop_output_configuration(AACContext *ac)
Restore the previous output configuration if and only if the current configuration is unlocked.
Definition: aacdec_template.c:517
SingleChannelElement::ret
INTFLOAT * ret
PCM output.
Definition: aac.h:270
latm_decode_audio_specific_config
static int latm_decode_audio_specific_config(struct LATMContext *latmctx, GetBitContext *gb, int asclen)
Definition: aacdec.c:283
intfloat.h
init_get_bits
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:660
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:31
sbr.h
MPEG4AudioConfig
Definition: mpeg4audio.h:33
skip_bits
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:468
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:380
mpeg4audio.h
U
#define U(x)
Definition: vp56_arith.h:37
ChannelElement::coup
ChannelCoupling coup
Definition: aac.h:287
latm_decode_init
static av_cold int latm_decode_init(AVCodecContext *avctx)
Definition: aacdec.c:544
read_audio_mux_element
static int read_audio_mux_element(struct LATMContext *latmctx, GetBitContext *gb)
Definition: aacdec.c:454
GetBitContext
Definition: get_bits.h:62
VMUL2
static float * VMUL2(float *dst, const float *v, unsigned idx, const float *scale)
Definition: aacdec.c:87
PredictorState::r0
AAC_FLOAT r0
Definition: aac.h:141
SingleChannelElement::ics
IndividualChannelStream ics
Definition: aac.h:250
AOT_ER_AAC_LC
@ AOT_ER_AAC_LC
N Error Resilient Low Complexity.
Definition: mpeg4audio.h:91
ff_aac_decoder
const AVCodec ff_aac_decoder
Definition: aacdec.c:555
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:84
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:678
decode
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:481
AOT_ER_AAC_LD
@ AOT_ER_AAC_LD
N Error Resilient Low Delay.
Definition: mpeg4audio.h:96
aac_decoder_class
static const AVClass aac_decoder_class
Definition: aacdec_template.c:3559
s
#define s(width, name)
Definition: cbs_vp9.c:257
SingleChannelElement::coeffs
INTFLOAT coeffs[1024]
coefficients for IMDCT, maybe processed
Definition: aac.h:263
reset_predict_state
static av_always_inline void reset_predict_state(PredictorState *ps)
Definition: aacdec.c:76
offsets
static const int offsets[]
Definition: hevc_pel.c:34
g
const char * g
Definition: vf_curves.c:117
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
s1
#define s1
Definition: regdef.h:38
IndividualChannelStream::group_len
uint8_t group_len[8]
Definition: aac.h:180
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:136
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:273
AACContext::fdsp
AVFloatDSPContext * fdsp
Definition: aac.h:334
aac_decode_er_frame
static int aac_decode_er_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, GetBitContext *gb)
Definition: aacdec_template.c:3152
kbdwin.h
IndividualChannelStream
Individual Channel Stream.
Definition: aac.h:175
f
#define f(width, name)
Definition: cbs_vp9.c:255
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: aac.h:182
aacdec_mips.h
GetBitContext::buffer
const uint8_t * buffer
Definition: get_bits.h:63
flush
static void flush(AVCodecContext *avctx)
Definition: aacdec_template.c:593
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: aac.h:179
aac_decode_close
static av_cold int aac_decode_close(AVCodecContext *avctx)
Definition: aacdec_template.c:3499
profiles.h
src
#define src
Definition: vp8dsp.c:255
flt16_trunc
static av_always_inline float flt16_trunc(float pf)
Definition: aacdec.c:170
aac.h
aactab.h
flt16_even
static av_always_inline float flt16_even(float pf)
Definition: aacdec.c:162
LATMContext::initialized
int initialized
initialized after a valid extradata was seen
Definition: aacdec.c:268
av_intfloat32
Definition: intfloat.h:27
PredictorState::r1
AAC_FLOAT r1
Definition: aac.h:142
decode_audio_specific_config
static int decode_audio_specific_config(AACContext *ac, AVCodecContext *avctx, MPEG4AudioConfig *m4ac, const uint8_t *data, int64_t bit_size, int sync_extension)
Definition: aacdec_template.c:1138
flt16_round
static av_always_inline float flt16_round(float pf)
Definition: aacdec.c:154
float_dsp.h
VMUL2S
static float * VMUL2S(float *dst, const float *v, unsigned idx, unsigned sign, const float *scale)
Definition: aacdec.c:111
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:104
AV_CODEC_ID_AAC
@ AV_CODEC_ID_AAC
Definition: codec_id.h:424
VMUL4
static float * VMUL4(float *dst, const float *v, unsigned idx, const float *scale)
Definition: aacdec.c:98
VMUL4S
static float * VMUL4S(float *dst, const float *v, unsigned idx, unsigned sign, const float *scale)
Definition: aacdec.c:128
decode_audio_specific_config_gb
static int decode_audio_specific_config_gb(AACContext *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:1071
AACContext::avctx
AVCodecContext * avctx
Definition: aac.h:296
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
ChannelElement::ch
SingleChannelElement ch[2]
Definition: aac.h:285
AVPacket::size
int size
Definition: packet.h:374
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:117
sine_120
static INTFLOAT sine_120[120]
Definition: aacdec.c:71
sine_960
static INTFLOAT sine_960[960]
Definition: aacdec.c:72
AV_SAMPLE_FMT_NONE
@ AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:59
push_output_configuration
static int push_output_configuration(AACContext *ac)
Save current output configuration if and only if it has been locked.
Definition: aacdec_template.c:502
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
ff_aac_latm_decoder
const AVCodec ff_aac_latm_decoder
Definition: aacdec.c:580
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:73
DECLARE_ALIGNED
#define DECLARE_ALIGNED(n, t, v)
Definition: mem.h:116
LATMContext
Definition: aacdec.c:266
i
int i
Definition: input.c:406
SingleChannelElement
Single Channel Element - used for both SCE and LFE elements.
Definition: aac.h:249
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:480
show_bits
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
Definition: get_bits.h:447
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: internal.h:50
aac.h
ChannelElement
channel element - generic struct for SCE/CPE/CCE/LFE
Definition: aac.h:276
AOT_ER_AAC_ELD
@ AOT_ER_AAC_ELD
N Error Resilient Enhanced Low Delay.
Definition: mpeg4audio.h:112
apply_independent_coupling
static void apply_independent_coupling(AACContext *ac, SingleChannelElement *target, ChannelElement *cce, int index)
Apply independent channel coupling (applied after IMDCT).
Definition: aacdec.c:250
predict
static av_always_inline void predict(PredictorState *ps, float *coef, int output_enable)
Definition: aacdec.c:178
AVSampleFormat
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
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:83
MPEG4AudioConfig::chan_config
int chan_config
Definition: mpeg4audio.h:37
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:204
AACContext::oc
OutputConfiguration oc[2]
Definition: aac.h:357
len
int len
Definition: vorbis_enc_data.h:426
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:34
LATMContext::audio_mux_version_A
int audio_mux_version_A
LATM syntax version.
Definition: aacdec.c:271
fft.h
AVCodecContext
main external API structure.
Definition: avcodec.h:379
ChannelCoupling::gain
INTFLOAT gain[16][120]
Definition: aac.h:243
MPEG4AudioConfig::sbr
int sbr
-1 implicit, 1 presence
Definition: mpeg4audio.h:38
read_stream_mux_config
static int read_stream_mux_config(struct LATMContext *latmctx, GetBitContext *gb)
Definition: aacdec.c:351
OutputConfiguration::m4ac
MPEG4AudioConfig m4ac
Definition: aac.h:125
av_intfloat32::f
float f
Definition: intfloat.h:29
aacdec_template.c
PredictorState::cor1
AAC_FLOAT cor1
Definition: aac.h:138
s0
#define s0
Definition: regdef.h:37
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h:37
adts_header.h
LOAS_SYNC_WORD
#define LOAS_SYNC_WORD
11 bits LOAS sync word
Definition: aacdec.c:264
av_free
#define av_free(p)
Definition: tableprint_vlc.h:34
alpha
static const int16_t alpha[]
Definition: ilbcdata.h:55
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:406
AVPacket
This structure stores compressed data.
Definition: packet.h:350
latm_get_value
static uint32_t latm_get_value(GetBitContext *b)
Definition: aacdec.c:276
AACContext
main AAC context
Definition: aac.h:294
IndividualChannelStream::max_sfb
uint8_t max_sfb
number of scalefactor bands per group
Definition: aac.h:176
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
AV_CODEC_ID_AAC_LATM
@ AV_CODEC_ID_AAC_LATM
Definition: codec_id.h:471
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
aac_decode_frame_int
static int aac_decode_frame_int(AVCodecContext *avctx, void *data, int *got_frame_ptr, GetBitContext *gb, const AVPacket *avpkt)
Definition: aacdec_template.c:3224
read_payload_length_info
static int read_payload_length_info(struct LATMContext *ctx, GetBitContext *gb)
Definition: aacdec.c:431
SingleChannelElement::band_type
enum BandType band_type[128]
band types
Definition: aac.h:253
INTFLOAT
float INTFLOAT
Definition: aac_defines.h:86
AOT_AAC_LTP
@ AOT_AAC_LTP
Y Long Term Prediction.
Definition: mpeg4audio.h:80
latm_decode_frame
static int latm_decode_frame(AVCodecContext *avctx, void *out, int *got_frame_ptr, AVPacket *avpkt)
Definition: aacdec.c:483
MPEG4AudioConfig::sample_rate
int sample_rate
Definition: mpeg4audio.h:36
PredictorState::cor0
AAC_FLOAT cor0
Definition: aac.h:137