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