FFmpeg
aacdec.c
Go to the documentation of this file.
1 /*
2  * Common parts of the AAC decoders
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  * AAC decoder fixed-point implementation
12  * Copyright (c) 2013
13  * MIPS Technologies, Inc., California.
14  *
15  * This file is part of FFmpeg.
16  *
17  * FFmpeg is free software; you can redistribute it and/or
18  * modify it under the terms of the GNU Lesser General Public
19  * License as published by the Free Software Foundation; either
20  * version 2.1 of the License, or (at your option) any later version.
21  *
22  * FFmpeg is distributed in the hope that it will be useful,
23  * but WITHOUT ANY WARRANTY; without even the implied warranty of
24  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
25  * Lesser General Public License for more details.
26  *
27  * You should have received a copy of the GNU Lesser General Public
28  * License along with FFmpeg; if not, write to the Free Software
29  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
30  */
31 
32 /* We use several quantization functions here (Q31, Q30),
33  * for which we need this to be defined for them to work as expected. */
34 #define USE_FIXED 1
35 
36 #include "config_components.h"
37 
38 #include <limits.h>
39 #include <stddef.h>
40 
41 #include "aacdec.h"
42 #include "aacdec_tab.h"
43 #include "aacdec_usac.h"
44 
45 #include "libavcodec/aac.h"
46 #include "libavcodec/aac_defines.h"
47 #include "libavcodec/aacsbr.h"
48 #include "libavcodec/aactab.h"
49 #include "libavcodec/adts_header.h"
50 
51 #include "libavcodec/avcodec.h"
52 #include "libavcodec/internal.h"
54 #include "libavcodec/decode.h"
55 #include "libavcodec/profiles.h"
56 
57 #include "libavutil/attributes.h"
58 #include "libavutil/error.h"
59 #include "libavutil/log.h"
60 #include "libavutil/macros.h"
61 #include "libavutil/mem.h"
62 #include "libavutil/opt.h"
63 #include "libavutil/tx.h"
64 #include "libavutil/version.h"
65 
66 /*
67  * supported tools
68  *
69  * Support? Name
70  * N (code in SoC repo) gain control
71  * Y block switching
72  * Y window shapes - standard
73  * N window shapes - Low Delay
74  * Y filterbank - standard
75  * N (code in SoC repo) filterbank - Scalable Sample Rate
76  * Y Temporal Noise Shaping
77  * Y Long Term Prediction
78  * Y intensity stereo
79  * Y channel coupling
80  * Y frequency domain prediction
81  * Y Perceptual Noise Substitution
82  * Y Mid/Side stereo
83  * N Scalable Inverse AAC Quantization
84  * N Frequency Selective Switch
85  * N upsampling filter
86  * Y quantization & coding - AAC
87  * N quantization & coding - TwinVQ
88  * N quantization & coding - BSAC
89  * N AAC Error Resilience tools
90  * N Error Resilience payload syntax
91  * N Error Protection tool
92  * N CELP
93  * N Silence Compression
94  * N HVXC
95  * N HVXC 4kbits/s VR
96  * N Structured Audio tools
97  * N Structured Audio Sample Bank Format
98  * N MIDI
99  * N Harmonic and Individual Lines plus Noise
100  * N Text-To-Speech Interface
101  * Y Spectral Band Replication
102  * Y (not in this code) Layer-1
103  * Y (not in this code) Layer-2
104  * Y (not in this code) Layer-3
105  * N SinuSoidal Coding (Transient, Sinusoid, Noise)
106  * Y Parametric Stereo
107  * N Direct Stream Transfer
108  * Y (not in fixed point code) Enhanced AAC Low Delay (ER AAC ELD)
109  *
110  * Note: - HE AAC v1 comprises LC AAC with Spectral Band Replication.
111  * - HE AAC v2 comprises LC AAC with Spectral Band Replication and
112  Parametric Stereo.
113  */
114 
115 #define overread_err "Input buffer exhausted before END element found\n"
116 
117 static int count_channels(uint8_t (*layout)[3], int tags)
118 {
119  int i, sum = 0;
120  for (i = 0; i < tags; i++) {
121  int syn_ele = layout[i][0];
122  int pos = layout[i][2];
123  sum += (1 + (syn_ele == TYPE_CPE)) *
125  }
126  return sum;
127 }
128 
129 /**
130  * Check for the channel element in the current channel position configuration.
131  * If it exists, make sure the appropriate element is allocated and map the
132  * channel order to match the internal FFmpeg channel layout.
133  *
134  * @param che_pos current channel position configuration
135  * @param type channel element type
136  * @param id channel element id
137  * @param channels count of the number of channels in the configuration
138  *
139  * @return Returns error status. 0 - OK, !0 - error
140  */
142  enum ChannelPosition che_pos,
143  int type, int id, int *channels)
144 {
145  if (*channels >= MAX_CHANNELS)
146  return AVERROR_INVALIDDATA;
147  if (che_pos) {
148  if (!ac->che[type][id]) {
149  int ret = ac->proc.sbr_ctx_alloc_init(ac, &ac->che[type][id], type);
150  if (ret < 0)
151  return ret;
152  }
153  if (type != TYPE_CCE) {
154  if (*channels >= MAX_CHANNELS - (type == TYPE_CPE || (type == TYPE_SCE && ac->oc[1].m4ac.ps == 1))) {
155  av_log(ac->avctx, AV_LOG_ERROR, "Too many channels\n");
156  return AVERROR_INVALIDDATA;
157  }
158  ac->output_element[(*channels)++] = &ac->che[type][id]->ch[0];
159  if (type == TYPE_CPE ||
160  (type == TYPE_SCE && ac->oc[1].m4ac.ps == 1)) {
161  ac->output_element[(*channels)++] = &ac->che[type][id]->ch[1];
162  }
163  }
164  } else {
165  if (ac->che[type][id]) {
166  ac->proc.sbr_ctx_close(ac->che[type][id]);
167  }
168  av_freep(&ac->che[type][id]);
169  memset(ac->output_element, 0, sizeof(ac->output_element));
170  }
171  return 0;
172 }
173 
175 {
176  AACDecContext *ac = avctx->priv_data;
177  int type, id, ch, ret;
178 
179  /* set channel pointers to internal buffers by default */
180  for (type = 0; type < 4; type++) {
181  for (id = 0; id < MAX_ELEM_ID; id++) {
182  ChannelElement *che = ac->che[type][id];
183  if (che) {
184  che->ch[0].output = che->ch[0].ret_buf;
185  che->ch[1].output = che->ch[1].ret_buf;
186  }
187  }
188  }
189 
190  /* get output buffer */
191  av_frame_unref(ac->frame);
192  if (!avctx->ch_layout.nb_channels)
193  return 1;
194 
195  ac->frame->nb_samples = 2048;
196  if ((ret = ff_get_buffer(avctx, ac->frame, 0)) < 0)
197  return ret;
198 
199  /* map output channel pointers to AVFrame data */
200  for (ch = 0; ch < avctx->ch_layout.nb_channels; ch++) {
201  if (ac->output_element[ch])
202  ac->output_element[ch]->output = (void *)ac->frame->extended_data[ch];
203  }
204 
205  return 0;
206 }
207 
209  uint64_t av_position;
210  uint8_t syn_ele;
211  uint8_t elem_id;
212  uint8_t aac_position;
213 };
214 
215 static int assign_pair(struct elem_to_channel e2c_vec[MAX_ELEM_ID],
216  uint8_t (*layout_map)[3], int offset, uint64_t left,
217  uint64_t right, int pos, uint64_t *layout)
218 {
219  if (layout_map[offset][0] == TYPE_CPE) {
220  e2c_vec[offset] = (struct elem_to_channel) {
221  .av_position = left | right,
222  .syn_ele = TYPE_CPE,
223  .elem_id = layout_map[offset][1],
224  .aac_position = pos
225  };
226  if (e2c_vec[offset].av_position != UINT64_MAX)
227  *layout |= e2c_vec[offset].av_position;
228 
229  return 1;
230  } else {
231  e2c_vec[offset] = (struct elem_to_channel) {
232  .av_position = left,
233  .syn_ele = TYPE_SCE,
234  .elem_id = layout_map[offset][1],
235  .aac_position = pos
236  };
237  e2c_vec[offset + 1] = (struct elem_to_channel) {
238  .av_position = right,
239  .syn_ele = TYPE_SCE,
240  .elem_id = layout_map[offset + 1][1],
241  .aac_position = pos
242  };
243  if (left != UINT64_MAX)
244  *layout |= left;
245 
246  if (right != UINT64_MAX)
247  *layout |= right;
248 
249  return 2;
250  }
251 }
252 
253 static int count_paired_channels(uint8_t (*layout_map)[3], int tags, int pos,
254  int current)
255 {
256  int num_pos_channels = 0;
257  int first_cpe = 0;
258  int sce_parity = 0;
259  int i;
260  for (i = current; i < tags; i++) {
261  if (layout_map[i][2] != pos)
262  break;
263  if (layout_map[i][0] == TYPE_CPE) {
264  if (sce_parity) {
265  if (pos == AAC_CHANNEL_FRONT && !first_cpe) {
266  sce_parity = 0;
267  } else {
268  return -1;
269  }
270  }
271  num_pos_channels += 2;
272  first_cpe = 1;
273  } else {
274  num_pos_channels++;
275  sce_parity ^= (pos != AAC_CHANNEL_LFE);
276  }
277  }
278  if (sce_parity &&
279  (pos == AAC_CHANNEL_FRONT && first_cpe))
280  return -1;
281 
282  return num_pos_channels;
283 }
284 
285 static int assign_channels(struct elem_to_channel e2c_vec[MAX_ELEM_ID], uint8_t (*layout_map)[3],
286  uint64_t *layout, int tags, int layer, int pos, int *current)
287 {
288  int i = *current, j = 0;
289  int nb_channels = count_paired_channels(layout_map, tags, pos, i);
290 
291  if (nb_channels < 0 || nb_channels > 5)
292  return 0;
293 
294  if (pos == AAC_CHANNEL_LFE) {
295  while (nb_channels) {
296  if (ff_aac_channel_map[layer][pos - 1][j] == AV_CHAN_NONE)
297  return -1;
298  e2c_vec[i] = (struct elem_to_channel) {
299  .av_position = 1ULL << ff_aac_channel_map[layer][pos - 1][j],
300  .syn_ele = layout_map[i][0],
301  .elem_id = layout_map[i][1],
302  .aac_position = pos
303  };
304  *layout |= e2c_vec[i].av_position;
305  i++;
306  j++;
307  nb_channels--;
308  }
309  *current = i;
310 
311  return 0;
312  }
313 
314  while (nb_channels & 1) {
315  if (ff_aac_channel_map[layer][pos - 1][0] == AV_CHAN_NONE)
316  return -1;
317  if (ff_aac_channel_map[layer][pos - 1][0] == AV_CHAN_UNUSED)
318  break;
319  e2c_vec[i] = (struct elem_to_channel) {
320  .av_position = 1ULL << ff_aac_channel_map[layer][pos - 1][0],
321  .syn_ele = layout_map[i][0],
322  .elem_id = layout_map[i][1],
323  .aac_position = pos
324  };
325  *layout |= e2c_vec[i].av_position;
326  i++;
327  nb_channels--;
328  }
329 
330  j = (pos != AAC_CHANNEL_SIDE) && nb_channels <= 3 ? 3 : 1;
331  while (nb_channels >= 2) {
332  if (ff_aac_channel_map[layer][pos - 1][j] == AV_CHAN_NONE ||
333  ff_aac_channel_map[layer][pos - 1][j+1] == AV_CHAN_NONE)
334  return -1;
335  i += assign_pair(e2c_vec, layout_map, i,
336  1ULL << ff_aac_channel_map[layer][pos - 1][j],
337  1ULL << ff_aac_channel_map[layer][pos - 1][j+1],
338  pos, layout);
339  j += 2;
340  nb_channels -= 2;
341  }
342  while (nb_channels & 1) {
343  if (ff_aac_channel_map[layer][pos - 1][5] == AV_CHAN_NONE)
344  return -1;
345  e2c_vec[i] = (struct elem_to_channel) {
346  .av_position = 1ULL << ff_aac_channel_map[layer][pos - 1][5],
347  .syn_ele = layout_map[i][0],
348  .elem_id = layout_map[i][1],
349  .aac_position = pos
350  };
351  *layout |= e2c_vec[i].av_position;
352  i++;
353  nb_channels--;
354  }
355  if (nb_channels)
356  return -1;
357 
358  *current = i;
359 
360  return 0;
361 }
362 
363 static uint64_t sniff_channel_order(uint8_t (*layout_map)[3], int tags)
364 {
365  int i, n, total_non_cc_elements;
366  struct elem_to_channel e2c_vec[4 * MAX_ELEM_ID] = { { 0 } };
367  uint64_t layout = 0;
368 
369  if (FF_ARRAY_ELEMS(e2c_vec) < tags)
370  return 0;
371 
372  for (n = 0, i = 0; n < 3 && i < tags; n++) {
373  int ret = assign_channels(e2c_vec, layout_map, &layout, tags, n, AAC_CHANNEL_FRONT, &i);
374  if (ret < 0)
375  return 0;
376  ret = assign_channels(e2c_vec, layout_map, &layout, tags, n, AAC_CHANNEL_SIDE, &i);
377  if (ret < 0)
378  return 0;
379  ret = assign_channels(e2c_vec, layout_map, &layout, tags, n, AAC_CHANNEL_BACK, &i);
380  if (ret < 0)
381  return 0;
382  ret = assign_channels(e2c_vec, layout_map, &layout, tags, n, AAC_CHANNEL_LFE, &i);
383  if (ret < 0)
384  return 0;
385  }
386 
387  total_non_cc_elements = n = i;
388 
389  if (layout == AV_CH_LAYOUT_22POINT2) {
390  // For 22.2 reorder the result as needed
391  FFSWAP(struct elem_to_channel, e2c_vec[2], e2c_vec[0]); // FL & FR first (final), FC third
392  FFSWAP(struct elem_to_channel, e2c_vec[2], e2c_vec[1]); // FC second (final), FLc & FRc third
393  FFSWAP(struct elem_to_channel, e2c_vec[6], e2c_vec[2]); // LFE1 third (final), FLc & FRc seventh
394  FFSWAP(struct elem_to_channel, e2c_vec[4], e2c_vec[3]); // BL & BR fourth (final), SiL & SiR fifth
395  FFSWAP(struct elem_to_channel, e2c_vec[6], e2c_vec[4]); // FLc & FRc fifth (final), SiL & SiR seventh
396  FFSWAP(struct elem_to_channel, e2c_vec[7], e2c_vec[6]); // LFE2 seventh (final), SiL & SiR eight (final)
397  FFSWAP(struct elem_to_channel, e2c_vec[9], e2c_vec[8]); // TpFL & TpFR ninth (final), TFC tenth (final)
398  FFSWAP(struct elem_to_channel, e2c_vec[11], e2c_vec[10]); // TC eleventh (final), TpSiL & TpSiR twelth
399  FFSWAP(struct elem_to_channel, e2c_vec[12], e2c_vec[11]); // TpBL & TpBR twelth (final), TpSiL & TpSiR thirteenth (final)
400  } else {
401  // For everything else, utilize the AV channel position define as a
402  // stable sort.
403  do {
404  int next_n = 0;
405  for (i = 1; i < n; i++)
406  if (e2c_vec[i - 1].av_position > e2c_vec[i].av_position) {
407  FFSWAP(struct elem_to_channel, e2c_vec[i - 1], e2c_vec[i]);
408  next_n = i;
409  }
410  n = next_n;
411  } while (n > 0);
412 
413  }
414 
415  for (i = 0; i < total_non_cc_elements; i++) {
416  layout_map[i][0] = e2c_vec[i].syn_ele;
417  layout_map[i][1] = e2c_vec[i].elem_id;
418  layout_map[i][2] = e2c_vec[i].aac_position;
419  }
420 
421  return layout;
422 }
423 
424 /**
425  * Save current output configuration if and only if it has been locked.
426  */
428 {
429  int pushed = 0;
430 
431  if (ac->oc[1].status == OC_LOCKED || ac->oc[0].status == OC_NONE) {
432  ac->oc[0] = ac->oc[1];
433  pushed = 1;
434  }
435  ac->oc[1].status = OC_NONE;
436  return pushed;
437 }
438 
439 /**
440  * Restore the previous output configuration if and only if the current
441  * configuration is unlocked.
442  */
444 {
445  if (ac->oc[1].status != OC_LOCKED && ac->oc[0].status != OC_NONE) {
446  ac->oc[1] = ac->oc[0];
447  ac->avctx->ch_layout = ac->oc[1].ch_layout;
449  ac->oc[1].status, 0);
450  }
451 }
452 
453 /**
454  * Configure output channel order based on the current program
455  * configuration element.
456  *
457  * @return Returns error status. 0 - OK, !0 - error
458  */
460  uint8_t layout_map[MAX_ELEM_ID * 4][3], int tags,
461  enum OCStatus oc_type, int get_new_frame)
462 {
463  AVCodecContext *avctx = ac->avctx;
464  int i, channels = 0, ret;
465  uint64_t layout = 0;
466  uint8_t id_map[TYPE_END][MAX_ELEM_ID] = {{ 0 }};
467  uint8_t type_counts[TYPE_END] = { 0 };
468 
469  if (ac->oc[1].layout_map != layout_map) {
470  memcpy(ac->oc[1].layout_map, layout_map, tags * sizeof(layout_map[0]));
471  ac->oc[1].layout_map_tags = tags;
472  }
473  for (i = 0; i < tags; i++) {
474  int type = layout_map[i][0];
475  int id = layout_map[i][1];
476  id_map[type][id] = type_counts[type]++;
477  if (id_map[type][id] >= MAX_ELEM_ID) {
478  avpriv_request_sample(ac->avctx, "Too large remapped id");
479  return AVERROR_PATCHWELCOME;
480  }
481  }
482  // Try to sniff a reasonable channel order, otherwise output the
483  // channels in the order the PCE declared them.
485  layout = sniff_channel_order(layout_map, tags);
486  for (i = 0; i < tags; i++) {
487  int type = layout_map[i][0];
488  int id = layout_map[i][1];
489  int iid = id_map[type][id];
490  int position = layout_map[i][2];
491  // Allocate or free elements depending on if they are in the
492  // current program configuration.
493  ret = che_configure(ac, position, type, iid, &channels);
494  if (ret < 0)
495  return ret;
496  ac->tag_che_map[type][id] = ac->che[type][iid];
497  }
498  if (ac->oc[1].m4ac.ps == 1 && channels == 2) {
499  if (layout == AV_CH_FRONT_CENTER) {
501  } else {
502  layout = 0;
503  }
504  }
505 
507  if (layout)
509  else {
511  ac->oc[1].ch_layout.nb_channels = channels;
512  }
513 
514  av_channel_layout_copy(&avctx->ch_layout, &ac->oc[1].ch_layout);
515  ac->oc[1].status = oc_type;
516 
517  if (get_new_frame) {
518  if ((ret = frame_configure_elements(ac->avctx)) < 0)
519  return ret;
520  }
521 
522  return 0;
523 }
524 
525 static av_cold void flush(AVCodecContext *avctx)
526 {
527  AACDecContext *ac= avctx->priv_data;
528  int type, i, j;
529 
530  for (type = 3; type >= 0; type--) {
531  for (i = 0; i < MAX_ELEM_ID; i++) {
532  ChannelElement *che = ac->che[type][i];
533  if (che) {
534  for (j = 0; j <= 1; j++) {
535  memset(che->ch[j].saved, 0, sizeof(che->ch[j].saved));
536  }
537  }
538  }
539  }
540 
541 #if CONFIG_AAC_DECODER
542  ff_aac_usac_reset_state(ac, &ac->oc[1]);
543 #endif
544 }
545 
546 /**
547  * Set up channel positions based on a default channel configuration
548  * as specified in table 1.17.
549  *
550  * @return Returns error status. 0 - OK, !0 - error
551  */
553  uint8_t (*layout_map)[3],
554  int *tags,
555  int channel_config)
556 {
557  if (channel_config < 1 || (channel_config > 7 && channel_config < 11) ||
558  channel_config > 14) {
559  av_log(avctx, AV_LOG_ERROR,
560  "invalid default channel configuration (%d)\n",
561  channel_config);
562  return AVERROR_INVALIDDATA;
563  }
564  *tags = ff_tags_per_config[channel_config];
565  memcpy(layout_map, ff_aac_channel_layout_map[channel_config - 1],
566  *tags * sizeof(*layout_map));
567 
568  /*
569  * AAC specification has 7.1(wide) as a default layout for 8-channel streams.
570  * However, at least Nero AAC encoder encodes 7.1 streams using the default
571  * channel config 7, mapping the side channels of the original audio stream
572  * to the second AAC_CHANNEL_FRONT pair in the AAC stream. Similarly, e.g. FAAD
573  * decodes the second AAC_CHANNEL_FRONT pair as side channels, therefore decoding
574  * the incorrect streams as if they were correct (and as the encoder intended).
575  *
576  * As actual intended 7.1(wide) streams are very rare, default to assuming a
577  * 7.1 layout was intended.
578  */
579  if (channel_config == 7 && avctx->strict_std_compliance < FF_COMPLIANCE_STRICT) {
580  layout_map[2][2] = AAC_CHANNEL_BACK;
581 
582  if (!ac || !ac->warned_71_wide++) {
583  av_log(avctx, AV_LOG_INFO, "Assuming an incorrectly encoded 7.1 channel layout"
584  " instead of a spec-compliant 7.1(wide) layout, use -strict %d to decode"
585  " according to the specification instead.\n", FF_COMPLIANCE_STRICT);
586  }
587  }
588 
589  return 0;
590 }
591 
593 {
594  /* For PCE based channel configurations map the channels solely based
595  * on tags. */
596  if (!ac->oc[1].m4ac.chan_config) {
597  return ac->tag_che_map[type][elem_id];
598  }
599  // Allow single CPE stereo files to be signalled with mono configuration.
600  if (!ac->tags_mapped && type == TYPE_CPE &&
601  ac->oc[1].m4ac.chan_config == 1) {
602  uint8_t layout_map[MAX_ELEM_ID*4][3];
603  int layout_map_tags;
605 
606  av_log(ac->avctx, AV_LOG_DEBUG, "mono with CPE\n");
607 
608  if (ff_aac_set_default_channel_config(ac, ac->avctx, layout_map,
609  &layout_map_tags, 2) < 0)
610  return NULL;
611  if (ff_aac_output_configure(ac, layout_map, layout_map_tags,
612  OC_TRIAL_FRAME, 1) < 0)
613  return NULL;
614 
615  ac->oc[1].m4ac.chan_config = 2;
616  ac->oc[1].m4ac.ps = 0;
617  }
618  // And vice-versa
619  if (!ac->tags_mapped && type == TYPE_SCE &&
620  ac->oc[1].m4ac.chan_config == 2) {
621  uint8_t layout_map[MAX_ELEM_ID * 4][3];
622  int layout_map_tags;
624 
625  av_log(ac->avctx, AV_LOG_DEBUG, "stereo with SCE\n");
626 
627  layout_map_tags = 2;
628  layout_map[0][0] = layout_map[1][0] = TYPE_SCE;
629  layout_map[0][2] = layout_map[1][2] = AAC_CHANNEL_FRONT;
630  layout_map[0][1] = 0;
631  layout_map[1][1] = 1;
632  if (ff_aac_output_configure(ac, layout_map, layout_map_tags,
633  OC_TRIAL_FRAME, 1) < 0)
634  return NULL;
635 
636  if (ac->oc[1].m4ac.sbr)
637  ac->oc[1].m4ac.ps = -1;
638  }
639  /* For indexed channel configurations map the channels solely based
640  * on position. */
641  switch (ac->oc[1].m4ac.chan_config) {
642  case 14:
643  if (ac->tags_mapped > 2 && ((type == TYPE_CPE && elem_id < 3) ||
644  (type == TYPE_LFE && elem_id < 1))) {
645  ac->tags_mapped++;
646  return ac->tag_che_map[type][elem_id] = ac->che[type][elem_id];
647  }
648  case 13:
649  if (ac->tags_mapped > 3 && ((type == TYPE_CPE && elem_id < 8) ||
650  (type == TYPE_SCE && elem_id < 6) ||
651  (type == TYPE_LFE && elem_id < 2))) {
652  ac->tags_mapped++;
653  return ac->tag_che_map[type][elem_id] = ac->che[type][elem_id];
654  }
655  case 12:
656  case 7:
657  if (ac->tags_mapped == 3 && type == TYPE_CPE) {
658  ac->tags_mapped++;
659  return ac->tag_che_map[TYPE_CPE][elem_id] = ac->che[TYPE_CPE][2];
660  }
661  case 11:
662  if (ac->tags_mapped == 3 && type == TYPE_SCE) {
663  ac->tags_mapped++;
664  return ac->tag_che_map[TYPE_SCE][elem_id] = ac->che[TYPE_SCE][1];
665  }
666  case 6:
667  /* Some streams incorrectly code 5.1 audio as
668  * SCE[0] CPE[0] CPE[1] SCE[1]
669  * instead of
670  * SCE[0] CPE[0] CPE[1] LFE[0].
671  * If we seem to have encountered such a stream, transfer
672  * the LFE[0] element to the SCE[1]'s mapping */
673  if (ac->tags_mapped == ff_tags_per_config[ac->oc[1].m4ac.chan_config] - 1 && (type == TYPE_LFE || type == TYPE_SCE)) {
674  if (!ac->warned_remapping_once && (type != TYPE_LFE || elem_id != 0)) {
676  "This stream seems to incorrectly report its last channel as %s[%d], mapping to LFE[0]\n",
677  type == TYPE_SCE ? "SCE" : "LFE", elem_id);
678  ac->warned_remapping_once++;
679  }
680  ac->tags_mapped++;
681  return ac->tag_che_map[type][elem_id] = ac->che[TYPE_LFE][0];
682  }
683  case 5:
684  if (ac->tags_mapped == 2 && type == TYPE_CPE) {
685  ac->tags_mapped++;
686  return ac->tag_che_map[TYPE_CPE][elem_id] = ac->che[TYPE_CPE][1];
687  }
688  case 4:
689  /* Some streams incorrectly code 4.0 audio as
690  * SCE[0] CPE[0] LFE[0]
691  * instead of
692  * SCE[0] CPE[0] SCE[1].
693  * If we seem to have encountered such a stream, transfer
694  * the SCE[1] element to the LFE[0]'s mapping */
695  if (ac->tags_mapped == ff_tags_per_config[ac->oc[1].m4ac.chan_config] - 1 && (type == TYPE_LFE || type == TYPE_SCE)) {
696  if (!ac->warned_remapping_once && (type != TYPE_SCE || elem_id != 1)) {
698  "This stream seems to incorrectly report its last channel as %s[%d], mapping to SCE[1]\n",
699  type == TYPE_SCE ? "SCE" : "LFE", elem_id);
700  ac->warned_remapping_once++;
701  }
702  ac->tags_mapped++;
703  return ac->tag_che_map[type][elem_id] = ac->che[TYPE_SCE][1];
704  }
705  if (ac->tags_mapped == 2 &&
706  ac->oc[1].m4ac.chan_config == 4 &&
707  type == TYPE_SCE) {
708  ac->tags_mapped++;
709  return ac->tag_che_map[TYPE_SCE][elem_id] = ac->che[TYPE_SCE][1];
710  }
711  case 3:
712  case 2:
713  if (ac->tags_mapped == (ac->oc[1].m4ac.chan_config != 2) &&
714  type == TYPE_CPE) {
715  ac->tags_mapped++;
716  return ac->tag_che_map[TYPE_CPE][elem_id] = ac->che[TYPE_CPE][0];
717  } else if (ac->tags_mapped == 1 && ac->oc[1].m4ac.chan_config == 2 &&
718  type == TYPE_SCE) {
719  ac->tags_mapped++;
720  return ac->tag_che_map[TYPE_SCE][elem_id] = ac->che[TYPE_SCE][1];
721  }
722  case 1:
723  if (!ac->tags_mapped && type == TYPE_SCE) {
724  ac->tags_mapped++;
725  return ac->tag_che_map[TYPE_SCE][elem_id] = ac->che[TYPE_SCE][0];
726  }
727  default:
728  return NULL;
729  }
730 }
731 
732 /**
733  * Decode an array of 4 bit element IDs, optionally interleaved with a
734  * stereo/mono switching bit.
735  *
736  * @param type speaker type/position for these channels
737  */
738 static void decode_channel_map(uint8_t layout_map[][3],
739  enum ChannelPosition type,
740  GetBitContext *gb, int n)
741 {
742  while (n--) {
744  switch (type) {
745  case AAC_CHANNEL_FRONT:
746  case AAC_CHANNEL_BACK:
747  case AAC_CHANNEL_SIDE:
748  syn_ele = get_bits1(gb);
749  break;
750  case AAC_CHANNEL_CC:
751  skip_bits1(gb);
752  syn_ele = TYPE_CCE;
753  break;
754  case AAC_CHANNEL_LFE:
755  syn_ele = TYPE_LFE;
756  break;
757  default:
758  // AAC_CHANNEL_OFF has no channel map
759  av_assert0(0);
760  }
761  layout_map[0][0] = syn_ele;
762  layout_map[0][1] = get_bits(gb, 4);
763  layout_map[0][2] = type;
764  layout_map++;
765  }
766 }
767 
768 static inline void relative_align_get_bits(GetBitContext *gb,
769  int reference_position) {
770  int n = (reference_position - get_bits_count(gb) & 7);
771  if (n)
772  skip_bits(gb, n);
773 }
774 
775 /**
776  * Decode program configuration element; reference: table 4.2.
777  *
778  * @return Returns error status. 0 - OK, !0 - error
779  */
780 static int decode_pce(AVCodecContext *avctx, MPEG4AudioConfig *m4ac,
781  uint8_t (*layout_map)[3],
782  GetBitContext *gb, int byte_align_ref)
783 {
784  int num_front, num_side, num_back, num_lfe, num_assoc_data, num_cc;
785  int sampling_index;
786  int comment_len;
787  int tags;
788 
789  skip_bits(gb, 2); // object_type
790 
791  sampling_index = get_bits(gb, 4);
792  if (m4ac->sampling_index != sampling_index)
793  av_log(avctx, AV_LOG_WARNING,
794  "Sample rate index in program config element does not "
795  "match the sample rate index configured by the container.\n");
796 
797  num_front = get_bits(gb, 4);
798  num_side = get_bits(gb, 4);
799  num_back = get_bits(gb, 4);
800  num_lfe = get_bits(gb, 2);
801  num_assoc_data = get_bits(gb, 3);
802  num_cc = get_bits(gb, 4);
803 
804  if (get_bits1(gb))
805  skip_bits(gb, 4); // mono_mixdown_tag
806  if (get_bits1(gb))
807  skip_bits(gb, 4); // stereo_mixdown_tag
808 
809  if (get_bits1(gb))
810  skip_bits(gb, 3); // mixdown_coeff_index and pseudo_surround
811 
812  if (get_bits_left(gb) < 5 * (num_front + num_side + num_back + num_cc) + 4 *(num_lfe + num_assoc_data + num_cc)) {
813  av_log(avctx, AV_LOG_ERROR, "decode_pce: " overread_err);
814  return -1;
815  }
816  decode_channel_map(layout_map , AAC_CHANNEL_FRONT, gb, num_front);
817  tags = num_front;
818  decode_channel_map(layout_map + tags, AAC_CHANNEL_SIDE, gb, num_side);
819  tags += num_side;
820  decode_channel_map(layout_map + tags, AAC_CHANNEL_BACK, gb, num_back);
821  tags += num_back;
822  decode_channel_map(layout_map + tags, AAC_CHANNEL_LFE, gb, num_lfe);
823  tags += num_lfe;
824 
825  skip_bits_long(gb, 4 * num_assoc_data);
826 
827  decode_channel_map(layout_map + tags, AAC_CHANNEL_CC, gb, num_cc);
828  tags += num_cc;
829 
830  relative_align_get_bits(gb, byte_align_ref);
831 
832  /* comment field, first byte is length */
833  comment_len = get_bits(gb, 8) * 8;
834  if (get_bits_left(gb) < comment_len) {
835  av_log(avctx, AV_LOG_ERROR, "decode_pce: " overread_err);
836  return AVERROR_INVALIDDATA;
837  }
838  skip_bits_long(gb, comment_len);
839  return tags;
840 }
841 
842 /**
843  * Decode GA "General Audio" specific configuration; reference: table 4.1.
844  *
845  * @param ac pointer to AACDecContext, may be null
846  * @param avctx pointer to AVCCodecContext, used for logging
847  *
848  * @return Returns error status. 0 - OK, !0 - error
849  */
851  GetBitContext *gb,
852  int get_bit_alignment,
853  MPEG4AudioConfig *m4ac,
854  int channel_config)
855 {
856  int extension_flag, ret, ep_config, res_flags;
857  uint8_t layout_map[MAX_ELEM_ID*4][3];
858  int tags = 0;
859 
860  m4ac->frame_length_short = get_bits1(gb);
861  if (m4ac->frame_length_short && m4ac->sbr == 1) {
862  avpriv_report_missing_feature(avctx, "SBR with 960 frame length");
863  if (ac) ac->warned_960_sbr = 1;
864  m4ac->sbr = 0;
865  m4ac->ps = 0;
866  }
867 
868  if (get_bits1(gb)) // dependsOnCoreCoder
869  skip_bits(gb, 14); // coreCoderDelay
870  extension_flag = get_bits1(gb);
871 
872  if (m4ac->object_type == AOT_AAC_SCALABLE ||
874  skip_bits(gb, 3); // layerNr
875 
876  if (channel_config == 0) {
877  skip_bits(gb, 4); // element_instance_tag
878  tags = decode_pce(avctx, m4ac, layout_map, gb, get_bit_alignment);
879  if (tags < 0)
880  return tags;
881  } else {
882  if ((ret = ff_aac_set_default_channel_config(ac, avctx, layout_map,
883  &tags, channel_config)))
884  return ret;
885  }
886 
887  if (count_channels(layout_map, tags) > 1) {
888  m4ac->ps = 0;
889  } else if (m4ac->sbr == 1 && m4ac->ps == -1)
890  m4ac->ps = 1;
891 
892  if (ac && (ret = ff_aac_output_configure(ac, layout_map, tags, OC_GLOBAL_HDR, 0)))
893  return ret;
894 
895  if (extension_flag) {
896  switch (m4ac->object_type) {
897  case AOT_ER_BSAC:
898  skip_bits(gb, 5); // numOfSubFrame
899  skip_bits(gb, 11); // layer_length
900  break;
901  case AOT_ER_AAC_LC:
902  case AOT_ER_AAC_LTP:
903  case AOT_ER_AAC_SCALABLE:
904  case AOT_ER_AAC_LD:
905  res_flags = get_bits(gb, 3);
906  if (res_flags) {
908  "AAC data resilience (flags %x)",
909  res_flags);
910  return AVERROR_PATCHWELCOME;
911  }
912  break;
913  }
914  skip_bits1(gb); // extensionFlag3 (TBD in version 3)
915  }
916  switch (m4ac->object_type) {
917  case AOT_ER_AAC_LC:
918  case AOT_ER_AAC_LTP:
919  case AOT_ER_AAC_SCALABLE:
920  case AOT_ER_AAC_LD:
921  ep_config = get_bits(gb, 2);
922  if (ep_config) {
924  "epConfig %d", ep_config);
925  return AVERROR_PATCHWELCOME;
926  }
927  }
928  return 0;
929 }
930 
932  GetBitContext *gb,
933  MPEG4AudioConfig *m4ac,
934  int channel_config)
935 {
936  int ret, ep_config, res_flags;
937  uint8_t layout_map[MAX_ELEM_ID*4][3];
938  int tags = 0;
939  const int ELDEXT_TERM = 0;
940 
941  m4ac->ps = 0;
942  m4ac->sbr = 0;
943  m4ac->frame_length_short = get_bits1(gb);
944 
945  res_flags = get_bits(gb, 3);
946  if (res_flags) {
948  "AAC data resilience (flags %x)",
949  res_flags);
950  return AVERROR_PATCHWELCOME;
951  }
952 
953  if (get_bits1(gb)) { // ldSbrPresentFlag
955  "Low Delay SBR");
956  return AVERROR_PATCHWELCOME;
957  }
958 
959  while (get_bits(gb, 4) != ELDEXT_TERM) {
960  int len = get_bits(gb, 4);
961  if (len == 15)
962  len += get_bits(gb, 8);
963  if (len == 15 + 255)
964  len += get_bits(gb, 16);
965  if (get_bits_left(gb) < len * 8 + 4) {
967  return AVERROR_INVALIDDATA;
968  }
969  skip_bits_long(gb, 8 * len);
970  }
971 
972  if ((ret = ff_aac_set_default_channel_config(ac, avctx, layout_map,
973  &tags, channel_config)))
974  return ret;
975 
976  if (ac && (ret = ff_aac_output_configure(ac, layout_map, tags, OC_GLOBAL_HDR, 0)))
977  return ret;
978 
979  ep_config = get_bits(gb, 2);
980  if (ep_config) {
982  "epConfig %d", ep_config);
983  return AVERROR_PATCHWELCOME;
984  }
985  return 0;
986 }
987 
988 /**
989  * Decode audio specific configuration; reference: table 1.13.
990  *
991  * @param ac pointer to AACDecContext, may be null
992  * @param avctx pointer to AVCCodecContext, used for logging
993  * @param m4ac pointer to MPEG4AudioConfig, used for parsing
994  * @param gb buffer holding an audio specific config
995  * @param get_bit_alignment relative alignment for byte align operations
996  * @param sync_extension look for an appended sync extension
997  *
998  * @return Returns error status or number of consumed bits. <0 - error
999  */
1001  AVCodecContext *avctx,
1002  OutputConfiguration *oc,
1003  GetBitContext *gb,
1004  int get_bit_alignment,
1005  int sync_extension)
1006 {
1007  int i, ret;
1008  GetBitContext gbc = *gb;
1009  MPEG4AudioConfig *m4ac = &oc->m4ac;
1010  MPEG4AudioConfig m4ac_bak = *m4ac;
1011 
1012  if ((i = ff_mpeg4audio_get_config_gb(m4ac, &gbc, sync_extension, avctx)) < 0) {
1013  *m4ac = m4ac_bak;
1014  return AVERROR_INVALIDDATA;
1015  }
1016 
1017  if (m4ac->sampling_index > 12) {
1018  av_log(avctx, AV_LOG_ERROR,
1019  "invalid sampling rate index %d\n",
1020  m4ac->sampling_index);
1021  *m4ac = m4ac_bak;
1022  return AVERROR_INVALIDDATA;
1023  }
1024  if (m4ac->object_type == AOT_ER_AAC_LD &&
1025  (m4ac->sampling_index < 3 || m4ac->sampling_index > 7)) {
1026  av_log(avctx, AV_LOG_ERROR,
1027  "invalid low delay sampling rate index %d\n",
1028  m4ac->sampling_index);
1029  *m4ac = m4ac_bak;
1030  return AVERROR_INVALIDDATA;
1031  }
1032 
1033  skip_bits_long(gb, i);
1034 
1035  switch (m4ac->object_type) {
1036  case AOT_AAC_MAIN:
1037  case AOT_AAC_LC:
1038  case AOT_AAC_SSR:
1039  case AOT_AAC_LTP:
1040  case AOT_ER_AAC_LC:
1041  case AOT_ER_AAC_LD:
1042  if ((ret = decode_ga_specific_config(ac, avctx, gb, get_bit_alignment,
1043  &oc->m4ac, m4ac->chan_config)) < 0)
1044  return ret;
1045  break;
1046  case AOT_ER_AAC_ELD:
1047  if ((ret = decode_eld_specific_config(ac, avctx, gb,
1048  &oc->m4ac, m4ac->chan_config)) < 0)
1049  return ret;
1050  break;
1051 #if CONFIG_AAC_DECODER
1052  case AOT_USAC:
1053  if ((ret = ff_aac_usac_config_decode(ac, avctx, gb,
1054  oc, m4ac->chan_config)) < 0)
1055  return ret;
1056  break;
1057 #endif
1058  default:
1060  "Audio object type %s%d",
1061  m4ac->sbr == 1 ? "SBR+" : "",
1062  m4ac->object_type);
1063  return AVERROR(ENOSYS);
1064  }
1065 
1066  ff_dlog(avctx,
1067  "AOT %d chan config %d sampling index %d (%d) SBR %d PS %d\n",
1068  m4ac->object_type, m4ac->chan_config, m4ac->sampling_index,
1069  m4ac->sample_rate, m4ac->sbr,
1070  m4ac->ps);
1071 
1072  return get_bits_count(gb);
1073 }
1074 
1076  AVCodecContext *avctx,
1077  OutputConfiguration *oc,
1078  const uint8_t *data, int64_t bit_size,
1079  int sync_extension)
1080 {
1081  int i, ret;
1082  GetBitContext gb;
1083 
1084  if (bit_size < 0 || bit_size > INT_MAX) {
1085  av_log(avctx, AV_LOG_ERROR, "Audio specific config size is invalid\n");
1086  return AVERROR_INVALIDDATA;
1087  }
1088 
1089  ff_dlog(avctx, "audio specific config size %d\n", (int)bit_size >> 3);
1090  for (i = 0; i < bit_size >> 3; i++)
1091  ff_dlog(avctx, "%02x ", data[i]);
1092  ff_dlog(avctx, "\n");
1093 
1094  if ((ret = init_get_bits(&gb, data, bit_size)) < 0)
1095  return ret;
1096 
1097  return decode_audio_specific_config_gb(ac, avctx, oc, &gb, 0,
1098  sync_extension);
1099 }
1100 
1102 {
1103  AACDecContext *ac = avctx->priv_data;
1104 
1105  for (int i = 0; i < 2; i++) {
1106  OutputConfiguration *oc = &ac->oc[i];
1107  AACUSACConfig *usac = &oc->usac;
1108  for (int j = 0; j < usac->nb_elems; j++) {
1109  AACUsacElemConfig *ec = &usac->elems[j];
1110  av_freep(&ec->ext.pl_data);
1111  }
1112  }
1113 
1114  for (int type = 0; type < FF_ARRAY_ELEMS(ac->che); type++) {
1115  for (int i = 0; i < MAX_ELEM_ID; i++) {
1116  if (ac->che[type][i]) {
1117  ac->proc.sbr_ctx_close(ac->che[type][i]);
1118  av_freep(&ac->che[type][i]);
1119  }
1120  }
1121  }
1122 
1123  av_tx_uninit(&ac->mdct96);
1124  av_tx_uninit(&ac->mdct120);
1125  av_tx_uninit(&ac->mdct128);
1126  av_tx_uninit(&ac->mdct480);
1127  av_tx_uninit(&ac->mdct512);
1128  av_tx_uninit(&ac->mdct768);
1129  av_tx_uninit(&ac->mdct960);
1130  av_tx_uninit(&ac->mdct1024);
1131  av_tx_uninit(&ac->mdct_ltp);
1132 
1133  // Compiler will optimize this branch away.
1134  if (ac->is_fixed)
1135  av_freep(&ac->RENAME_FIXED(fdsp));
1136  else
1137  av_freep(&ac->fdsp);
1138 
1139  return 0;
1140 }
1141 
1142 static av_cold int init_dsp(AVCodecContext *avctx)
1143 {
1144  AACDecContext *ac = avctx->priv_data;
1145  int is_fixed = ac->is_fixed, ret;
1146  float scale_fixed, scale_float;
1147  const float *const scalep = is_fixed ? &scale_fixed : &scale_float;
1148  enum AVTXType tx_type = is_fixed ? AV_TX_INT32_MDCT : AV_TX_FLOAT_MDCT;
1149 
1150 #define MDCT_INIT(s, fn, len, sval) \
1151  scale_fixed = (sval) * 128.0f; \
1152  scale_float = (sval) / 32768.0f; \
1153  ret = av_tx_init(&s, &fn, tx_type, 1, len, scalep, 0); \
1154  if (ret < 0) \
1155  return ret
1156 
1157  MDCT_INIT(ac->mdct96, ac->mdct96_fn, 96, 1.0/96);
1158  MDCT_INIT(ac->mdct120, ac->mdct120_fn, 120, 1.0/120);
1159  MDCT_INIT(ac->mdct128, ac->mdct128_fn, 128, 1.0/128);
1160  MDCT_INIT(ac->mdct480, ac->mdct480_fn, 480, 1.0/480);
1161  MDCT_INIT(ac->mdct512, ac->mdct512_fn, 512, 1.0/512);
1162  MDCT_INIT(ac->mdct768, ac->mdct768_fn, 768, 1.0/768);
1163  MDCT_INIT(ac->mdct960, ac->mdct960_fn, 960, 1.0/960);
1164  MDCT_INIT(ac->mdct1024, ac->mdct1024_fn, 1024, 1.0/1024);
1165 #undef MDCT_INIT
1166 
1167  /* LTP forward MDCT */
1168  scale_fixed = -1.0;
1169  scale_float = -32786.0*2 + 36;
1170  ret = av_tx_init(&ac->mdct_ltp, &ac->mdct_ltp_fn, tx_type, 0, 1024, scalep, 0);
1171  if (ret < 0)
1172  return ret;
1173 
1174  return 0;
1175 }
1176 
1178 {
1179  AACDecContext *ac = avctx->priv_data;
1180  int ret;
1181 
1182  if (avctx->sample_rate > 96000)
1183  return AVERROR_INVALIDDATA;
1184 
1186 
1187  ac->avctx = avctx;
1188  ac->oc[1].m4ac.sample_rate = avctx->sample_rate;
1189 
1190  if (avctx->extradata_size > 0) {
1191  if ((ret = decode_audio_specific_config(ac, ac->avctx, &ac->oc[1],
1192  avctx->extradata,
1193  avctx->extradata_size * 8LL,
1194  1)) < 0)
1195  return ret;
1196  } else {
1197  int sr, i;
1198  uint8_t layout_map[MAX_ELEM_ID*4][3];
1199  int layout_map_tags;
1200 
1201  sr = ff_aac_sample_rate_idx(avctx->sample_rate);
1202  ac->oc[1].m4ac.sampling_index = sr;
1203  ac->oc[1].m4ac.channels = avctx->ch_layout.nb_channels;
1204  ac->oc[1].m4ac.sbr = -1;
1205  ac->oc[1].m4ac.ps = -1;
1206 
1207  for (i = 0; i < FF_ARRAY_ELEMS(ff_mpeg4audio_channels); i++)
1209  break;
1211  i = 0;
1212  }
1213  ac->oc[1].m4ac.chan_config = i;
1214 
1215  if (ac->oc[1].m4ac.chan_config) {
1216  int ret = ff_aac_set_default_channel_config(ac, avctx, layout_map,
1217  &layout_map_tags,
1218  ac->oc[1].m4ac.chan_config);
1219  if (!ret)
1220  ff_aac_output_configure(ac, layout_map, layout_map_tags,
1221  OC_GLOBAL_HDR, 0);
1222  else if (avctx->err_recognition & AV_EF_EXPLODE)
1223  return AVERROR_INVALIDDATA;
1224  }
1225  }
1226 
1227  if (avctx->ch_layout.nb_channels > MAX_CHANNELS) {
1228  av_log(avctx, AV_LOG_ERROR, "Too many channels\n");
1229  return AVERROR_INVALIDDATA;
1230  }
1231 
1232  ac->random_state = 0x1f2e3d4c;
1233 
1234  return init_dsp(avctx);
1235 }
1236 
1237 /**
1238  * Skip data_stream_element; reference: table 4.10.
1239  */
1241 {
1242  int byte_align = get_bits1(gb);
1243  int count = get_bits(gb, 8);
1244  if (count == 255)
1245  count += get_bits(gb, 8);
1246  if (byte_align)
1247  align_get_bits(gb);
1248 
1249  if (get_bits_left(gb) < 8 * count) {
1250  av_log(ac->avctx, AV_LOG_ERROR, "skip_data_stream_element: "overread_err);
1251  return AVERROR_INVALIDDATA;
1252  }
1253  skip_bits_long(gb, 8 * count);
1254  return 0;
1255 }
1256 
1258  GetBitContext *gb)
1259 {
1260  int sfb;
1261  if (get_bits1(gb)) {
1262  ics->predictor_reset_group = get_bits(gb, 5);
1263  if (ics->predictor_reset_group == 0 ||
1264  ics->predictor_reset_group > 30) {
1265  av_log(ac->avctx, AV_LOG_ERROR,
1266  "Invalid Predictor Reset Group.\n");
1267  return AVERROR_INVALIDDATA;
1268  }
1269  }
1270  for (sfb = 0; sfb < FFMIN(ics->max_sfb, ff_aac_pred_sfb_max[ac->oc[1].m4ac.sampling_index]); sfb++) {
1271  ics->prediction_used[sfb] = get_bits1(gb);
1272  }
1273  return 0;
1274 }
1275 
1276 /**
1277  * Decode Long Term Prediction data; reference: table 4.xx.
1278  */
1280  GetBitContext *gb, uint8_t max_sfb)
1281 {
1282  int sfb;
1283 
1284  ltp->lag = get_bits(gb, 11);
1285  if (CONFIG_AAC_FIXED_DECODER && ac->is_fixed)
1286  ltp->coef_fixed = Q30(ff_ltp_coef[get_bits(gb, 3)]);
1287  else if (CONFIG_AAC_DECODER)
1288  ltp->coef = ff_ltp_coef[get_bits(gb, 3)];
1289 
1290  for (sfb = 0; sfb < FFMIN(max_sfb, MAX_LTP_LONG_SFB); sfb++)
1291  ltp->used[sfb] = get_bits1(gb);
1292 }
1293 
1294 /**
1295  * Decode Individual Channel Stream info; reference: table 4.6.
1296  */
1298  GetBitContext *gb)
1299 {
1300  const MPEG4AudioConfig *const m4ac = &ac->oc[1].m4ac;
1301  const int aot = m4ac->object_type;
1302  const int sampling_index = m4ac->sampling_index;
1303  int ret_fail = AVERROR_INVALIDDATA;
1304 
1305  if (aot != AOT_ER_AAC_ELD) {
1306  if (get_bits1(gb)) {
1307  av_log(ac->avctx, AV_LOG_ERROR, "Reserved bit set.\n");
1309  return AVERROR_INVALIDDATA;
1310  }
1311  ics->window_sequence[1] = ics->window_sequence[0];
1312  ics->window_sequence[0] = get_bits(gb, 2);
1313  if (aot == AOT_ER_AAC_LD &&
1314  ics->window_sequence[0] != ONLY_LONG_SEQUENCE) {
1315  av_log(ac->avctx, AV_LOG_ERROR,
1316  "AAC LD is only defined for ONLY_LONG_SEQUENCE but "
1317  "window sequence %d found.\n", ics->window_sequence[0]);
1319  return AVERROR_INVALIDDATA;
1320  }
1321  ics->use_kb_window[1] = ics->use_kb_window[0];
1322  ics->use_kb_window[0] = get_bits1(gb);
1323  }
1325  ics->num_window_groups = 1;
1326  ics->group_len[0] = 1;
1327  if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) {
1328  int i;
1329  ics->max_sfb = get_bits(gb, 4);
1330  for (i = 0; i < 7; i++) {
1331  if (get_bits1(gb)) {
1332  ics->group_len[ics->num_window_groups - 1]++;
1333  } else {
1334  ics->num_window_groups++;
1335  ics->group_len[ics->num_window_groups - 1] = 1;
1336  }
1337  }
1338  ics->num_windows = 8;
1339  if (m4ac->frame_length_short) {
1340  ics->swb_offset = ff_swb_offset_120[sampling_index];
1341  ics->num_swb = ff_aac_num_swb_120[sampling_index];
1342  } else {
1343  ics->swb_offset = ff_swb_offset_128[sampling_index];
1344  ics->num_swb = ff_aac_num_swb_128[sampling_index];
1345  }
1346  ics->tns_max_bands = ff_tns_max_bands_128[sampling_index];
1347  ics->predictor_present = 0;
1348  } else {
1349  ics->max_sfb = get_bits(gb, 6);
1350  ics->num_windows = 1;
1351  if (aot == AOT_ER_AAC_LD || aot == AOT_ER_AAC_ELD) {
1352  if (m4ac->frame_length_short) {
1353  ics->swb_offset = ff_swb_offset_480[sampling_index];
1354  ics->num_swb = ff_aac_num_swb_480[sampling_index];
1355  ics->tns_max_bands = ff_tns_max_bands_480[sampling_index];
1356  } else {
1357  ics->swb_offset = ff_swb_offset_512[sampling_index];
1358  ics->num_swb = ff_aac_num_swb_512[sampling_index];
1359  ics->tns_max_bands = ff_tns_max_bands_512[sampling_index];
1360  }
1361  if (!ics->num_swb || !ics->swb_offset) {
1362  ret_fail = AVERROR_BUG;
1363  goto fail;
1364  }
1365  } else {
1366  if (m4ac->frame_length_short) {
1367  ics->num_swb = ff_aac_num_swb_960[sampling_index];
1368  ics->swb_offset = ff_swb_offset_960[sampling_index];
1369  } else {
1370  ics->num_swb = ff_aac_num_swb_1024[sampling_index];
1371  ics->swb_offset = ff_swb_offset_1024[sampling_index];
1372  }
1373  ics->tns_max_bands = ff_tns_max_bands_1024[sampling_index];
1374  }
1375  if (aot != AOT_ER_AAC_ELD) {
1376  ics->predictor_present = get_bits1(gb);
1377  ics->predictor_reset_group = 0;
1378  }
1379  if (ics->predictor_present) {
1380  if (aot == AOT_AAC_MAIN) {
1381  if (decode_prediction(ac, ics, gb)) {
1382  goto fail;
1383  }
1384  } else if (aot == AOT_AAC_LC ||
1385  aot == AOT_ER_AAC_LC) {
1386  av_log(ac->avctx, AV_LOG_ERROR,
1387  "Prediction is not allowed in AAC-LC.\n");
1388  goto fail;
1389  } else {
1390  if (aot == AOT_ER_AAC_LD) {
1391  av_log(ac->avctx, AV_LOG_ERROR,
1392  "LTP in ER AAC LD not yet implemented.\n");
1393  ret_fail = AVERROR_PATCHWELCOME;
1394  goto fail;
1395  }
1396  if ((ics->ltp.present = get_bits(gb, 1)))
1397  decode_ltp(ac, &ics->ltp, gb, ics->max_sfb);
1398  }
1399  }
1400  }
1401 
1402  if (ics->max_sfb > ics->num_swb) {
1403  av_log(ac->avctx, AV_LOG_ERROR,
1404  "Number of scalefactor bands in group (%d) "
1405  "exceeds limit (%d).\n",
1406  ics->max_sfb, ics->num_swb);
1407  goto fail;
1408  }
1409 
1410  return 0;
1411 fail:
1412  ics->max_sfb = 0;
1413  return ret_fail;
1414 }
1415 
1416 /**
1417  * Decode band types (section_data payload); reference: table 4.46.
1418  *
1419  * @param band_type array of the used band type
1420  * @param band_type_run_end array of the last scalefactor band of a band type run
1421  *
1422  * @return Returns error status. 0 - OK, !0 - error
1423  */
1425  GetBitContext *gb)
1426 {
1427  IndividualChannelStream *ics = &sce->ics;
1428  const int bits = (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) ? 3 : 5;
1429 
1430  for (int g = 0; g < ics->num_window_groups; g++) {
1431  int k = 0;
1432  while (k < ics->max_sfb) {
1433  uint8_t sect_end = k;
1434  int sect_len_incr;
1435  int sect_band_type = get_bits(gb, 4);
1436  if (sect_band_type == 12) {
1437  av_log(ac->avctx, AV_LOG_ERROR, "invalid band type\n");
1438  return AVERROR_INVALIDDATA;
1439  }
1440  do {
1441  sect_len_incr = get_bits(gb, bits);
1442  sect_end += sect_len_incr;
1443  if (get_bits_left(gb) < 0) {
1444  av_log(ac->avctx, AV_LOG_ERROR, "decode_band_types: "overread_err);
1445  return AVERROR_INVALIDDATA;
1446  }
1447  if (sect_end > ics->max_sfb) {
1448  av_log(ac->avctx, AV_LOG_ERROR,
1449  "Number of bands (%d) exceeds limit (%d).\n",
1450  sect_end, ics->max_sfb);
1451  return AVERROR_INVALIDDATA;
1452  }
1453  } while (sect_len_incr == (1 << bits) - 1);
1454  for (; k < sect_end; k++)
1455  sce->band_type[g*ics->max_sfb + k] = sect_band_type;
1456  }
1457  }
1458  return 0;
1459 }
1460 
1461 /**
1462  * Decode scalefactors; reference: table 4.47.
1463  *
1464  * @param global_gain first scalefactor value as scalefactors are differentially coded
1465  * @param band_type array of the used band type
1466  * @param band_type_run_end array of the last scalefactor band of a band type run
1467  * @param sf array of scalefactors or intensity stereo positions
1468  *
1469  * @return Returns error status. 0 - OK, !0 - error
1470  */
1472  GetBitContext *gb, unsigned int global_gain)
1473 {
1474  IndividualChannelStream *ics = &sce->ics;
1475  int offset[3] = { global_gain, global_gain - NOISE_OFFSET, 0 };
1476  int clipped_offset;
1477  int noise_flag = 1;
1478 
1479  for (int g = 0; g < ics->num_window_groups; g++) {
1480  for (int sfb = 0; sfb < ics->max_sfb; sfb++) {
1481  switch (sce->band_type[g*ics->max_sfb + sfb]) {
1482  case ZERO_BT:
1483  sce->sfo[g*ics->max_sfb + sfb] = 0;
1484  break;
1485  case INTENSITY_BT: /* fallthrough */
1486  case INTENSITY_BT2:
1488  clipped_offset = av_clip(offset[2], -155, 100);
1489  if (offset[2] != clipped_offset) {
1491  "If you heard an audible artifact, there may be a bug in the decoder. "
1492  "Clipped intensity stereo position (%d -> %d)",
1493  offset[2], clipped_offset);
1494  }
1495  sce->sfo[g*ics->max_sfb + sfb] = clipped_offset - 100;
1496  break;
1497  case NOISE_BT:
1498  if (noise_flag-- > 0)
1499  offset[1] += get_bits(gb, NOISE_PRE_BITS) - NOISE_PRE;
1500  else
1502  clipped_offset = av_clip(offset[1], -100, 155);
1503  if (offset[1] != clipped_offset) {
1505  "If you heard an audible artifact, there may be a bug in the decoder. "
1506  "Clipped noise gain (%d -> %d)",
1507  offset[1], clipped_offset);
1508  }
1509  sce->sfo[g*ics->max_sfb + sfb] = clipped_offset;
1510  break;
1511  default:
1513  if (offset[0] > 255U) {
1514  av_log(ac->avctx, AV_LOG_ERROR,
1515  "Scalefactor (%d) out of range.\n", offset[0]);
1516  return AVERROR_INVALIDDATA;
1517  }
1518  sce->sfo[g*ics->max_sfb + sfb] = offset[0] - 100;
1519  break;
1520  }
1521  }
1522  }
1523 
1524  return 0;
1525 }
1526 
1527 /**
1528  * Decode pulse data; reference: table 4.7.
1529  */
1530 static int decode_pulses(Pulse *pulse, GetBitContext *gb,
1531  const uint16_t *swb_offset, int num_swb)
1532 {
1533  int i, pulse_swb;
1534  pulse->num_pulse = get_bits(gb, 2) + 1;
1535  pulse_swb = get_bits(gb, 6);
1536  if (pulse_swb >= num_swb)
1537  return -1;
1538  pulse->pos[0] = swb_offset[pulse_swb];
1539  pulse->pos[0] += get_bits(gb, 5);
1540  if (pulse->pos[0] >= swb_offset[num_swb])
1541  return -1;
1542  pulse->amp[0] = get_bits(gb, 4);
1543  for (i = 1; i < pulse->num_pulse; i++) {
1544  pulse->pos[i] = get_bits(gb, 5) + pulse->pos[i - 1];
1545  if (pulse->pos[i] >= swb_offset[num_swb])
1546  return -1;
1547  pulse->amp[i] = get_bits(gb, 4);
1548  }
1549  return 0;
1550 }
1551 
1552 /**
1553  * Decode Temporal Noise Shaping data; reference: table 4.48.
1554  *
1555  * @return Returns error status. 0 - OK, !0 - error
1556  */
1558  GetBitContext *gb, const IndividualChannelStream *ics)
1559 {
1560  int tns_max_order = INT32_MAX;
1561  const int is_usac = ac->oc[1].m4ac.object_type == AOT_USAC;
1562  int w, filt, i, coef_len, coef_res, coef_compress;
1563  const int is8 = ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE;
1564 
1565  /* USAC doesn't seem to have a limit */
1566  if (!is_usac)
1567  tns_max_order = is8 ? 7 : ac->oc[1].m4ac.object_type == AOT_AAC_MAIN ? 20 : 12;
1568 
1569  for (w = 0; w < ics->num_windows; w++) {
1570  if ((tns->n_filt[w] = get_bits(gb, 2 - is8))) {
1571  coef_res = get_bits1(gb);
1572 
1573  for (filt = 0; filt < tns->n_filt[w]; filt++) {
1574  int tmp2_idx;
1575  tns->length[w][filt] = get_bits(gb, 6 - 2 * is8);
1576 
1577  if (is_usac)
1578  tns->order[w][filt] = get_bits(gb, 4 - is8);
1579  else
1580  tns->order[w][filt] = get_bits(gb, 5 - (2 * is8));
1581 
1582  if (tns->order[w][filt] > tns_max_order) {
1583  av_log(ac->avctx, AV_LOG_ERROR,
1584  "TNS filter order %d is greater than maximum %d.\n",
1585  tns->order[w][filt], tns_max_order);
1586  tns->order[w][filt] = 0;
1587  return AVERROR_INVALIDDATA;
1588  }
1589  if (tns->order[w][filt]) {
1590  tns->direction[w][filt] = get_bits1(gb);
1591  coef_compress = get_bits1(gb);
1592  coef_len = coef_res + 3 - coef_compress;
1593  tmp2_idx = 2 * coef_compress + coef_res;
1594 
1595  for (i = 0; i < tns->order[w][filt]; i++) {
1596  if (CONFIG_AAC_FIXED_DECODER && ac->is_fixed)
1597  tns->coef_fixed[w][filt][i] = Q31(ff_tns_tmp2_map[tmp2_idx][get_bits(gb, coef_len)]);
1598  else if (CONFIG_AAC_DECODER)
1599  tns->coef[w][filt][i] = ff_tns_tmp2_map[tmp2_idx][get_bits(gb, coef_len)];
1600  }
1601  }
1602  }
1603  }
1604  }
1605  return 0;
1606 }
1607 
1608 /**
1609  * Decode Mid/Side data; reference: table 4.54.
1610  *
1611  * @param ms_present Indicates mid/side stereo presence. [0] mask is all 0s;
1612  * [1] mask is decoded from bitstream; [2] mask is all 1s;
1613  * [3] reserved for scalable AAC
1614  */
1616  int ms_present)
1617 {
1618  int idx;
1619  int max_idx = cpe->ch[0].ics.num_window_groups * cpe->ch[0].ics.max_sfb;
1620  cpe->max_sfb_ste = cpe->ch[0].ics.max_sfb;
1621  if (ms_present == 1) {
1622  for (idx = 0; idx < max_idx; idx++)
1623  cpe->ms_mask[idx] = get_bits1(gb);
1624  } else if (ms_present == 2) {
1625  memset(cpe->ms_mask, 1, max_idx * sizeof(cpe->ms_mask[0]));
1626  }
1627 }
1628 
1630 {
1631  // wd_num, wd_test, aloc_size
1632  static const uint8_t gain_mode[4][3] = {
1633  {1, 0, 5}, // ONLY_LONG_SEQUENCE = 0,
1634  {2, 1, 2}, // LONG_START_SEQUENCE,
1635  {8, 0, 2}, // EIGHT_SHORT_SEQUENCE,
1636  {2, 1, 5}, // LONG_STOP_SEQUENCE
1637  };
1638 
1639  const int mode = sce->ics.window_sequence[0];
1640  uint8_t bd, wd, ad;
1641 
1642  // FIXME: Store the gain control data on |sce| and do something with it.
1643  uint8_t max_band = get_bits(gb, 2);
1644  for (bd = 0; bd < max_band; bd++) {
1645  for (wd = 0; wd < gain_mode[mode][0]; wd++) {
1646  uint8_t adjust_num = get_bits(gb, 3);
1647  for (ad = 0; ad < adjust_num; ad++) {
1648  skip_bits(gb, 4 + ((wd == 0 && gain_mode[mode][1])
1649  ? 4
1650  : gain_mode[mode][2]));
1651  }
1652  }
1653  }
1654 }
1655 
1656 /**
1657  * Decode an individual_channel_stream payload; reference: table 4.44.
1658  *
1659  * @param common_window Channels have independent [0], or shared [1], Individual Channel Stream information.
1660  * @param scale_flag scalable [1] or non-scalable [0] AAC (Unused until scalable AAC is implemented.)
1661  *
1662  * @return Returns error status. 0 - OK, !0 - error
1663  */
1665  GetBitContext *gb, int common_window, int scale_flag)
1666 {
1667  Pulse pulse;
1668  TemporalNoiseShaping *tns = &sce->tns;
1669  IndividualChannelStream *ics = &sce->ics;
1670  int global_gain, eld_syntax, er_syntax, pulse_present = 0;
1671  int ret;
1672 
1673  eld_syntax = ac->oc[1].m4ac.object_type == AOT_ER_AAC_ELD;
1674  er_syntax = ac->oc[1].m4ac.object_type == AOT_ER_AAC_LC ||
1675  ac->oc[1].m4ac.object_type == AOT_ER_AAC_LTP ||
1676  ac->oc[1].m4ac.object_type == AOT_ER_AAC_LD ||
1677  ac->oc[1].m4ac.object_type == AOT_ER_AAC_ELD;
1678 
1679  /* This assignment is to silence a GCC warning about the variable being used
1680  * uninitialized when in fact it always is.
1681  */
1682  pulse.num_pulse = 0;
1683 
1684  global_gain = get_bits(gb, 8);
1685 
1686  if (!common_window && !scale_flag) {
1687  ret = decode_ics_info(ac, ics, gb);
1688  if (ret < 0)
1689  goto fail;
1690  }
1691 
1692  if ((ret = decode_band_types(ac, sce, gb)) < 0)
1693  goto fail;
1694  if ((ret = decode_scalefactors(ac, sce, gb, global_gain)) < 0)
1695  goto fail;
1696 
1697  ac->dsp.dequant_scalefactors(sce);
1698 
1699  pulse_present = 0;
1700  if (!scale_flag) {
1701  if (!eld_syntax && (pulse_present = get_bits1(gb))) {
1702  if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) {
1703  av_log(ac->avctx, AV_LOG_ERROR,
1704  "Pulse tool not allowed in eight short sequence.\n");
1706  goto fail;
1707  }
1708  if (decode_pulses(&pulse, gb, ics->swb_offset, ics->num_swb)) {
1709  av_log(ac->avctx, AV_LOG_ERROR,
1710  "Pulse data corrupt or invalid.\n");
1712  goto fail;
1713  }
1714  }
1715  tns->present = get_bits1(gb);
1716  if (tns->present && !er_syntax) {
1717  ret = ff_aac_decode_tns(ac, tns, gb, ics);
1718  if (ret < 0)
1719  goto fail;
1720  }
1721  if (!eld_syntax && get_bits1(gb)) {
1722  decode_gain_control(sce, gb);
1723  if (!ac->warned_gain_control) {
1724  avpriv_report_missing_feature(ac->avctx, "Gain control");
1725  ac->warned_gain_control = 1;
1726  }
1727  }
1728  // I see no textual basis in the spec for this occurring after SSR gain
1729  // control, but this is what both reference and real implmentations do
1730  if (tns->present && er_syntax) {
1731  ret = ff_aac_decode_tns(ac, tns, gb, ics);
1732  if (ret < 0)
1733  goto fail;
1734  }
1735  }
1736 
1737  ret = ac->proc.decode_spectrum_and_dequant(ac, gb,
1738  pulse_present ? &pulse : NULL,
1739  sce);
1740  if (ret < 0)
1741  goto fail;
1742 
1743  if (ac->oc[1].m4ac.object_type == AOT_AAC_MAIN && !common_window)
1744  ac->dsp.apply_prediction(ac, sce);
1745 
1746  return 0;
1747 fail:
1748  tns->present = 0;
1749  return ret;
1750 }
1751 
1752 /**
1753  * Decode a channel_pair_element; reference: table 4.4.
1754  *
1755  * @return Returns error status. 0 - OK, !0 - error
1756  */
1758 {
1759  int i, ret, common_window, ms_present = 0;
1760  int eld_syntax = ac->oc[1].m4ac.object_type == AOT_ER_AAC_ELD;
1761 
1762  common_window = eld_syntax || get_bits1(gb);
1763  if (common_window) {
1764  if (decode_ics_info(ac, &cpe->ch[0].ics, gb))
1765  return AVERROR_INVALIDDATA;
1766  i = cpe->ch[1].ics.use_kb_window[0];
1767  cpe->ch[1].ics = cpe->ch[0].ics;
1768  cpe->ch[1].ics.use_kb_window[1] = i;
1769  if (cpe->ch[1].ics.predictor_present &&
1770  (ac->oc[1].m4ac.object_type != AOT_AAC_MAIN))
1771  if ((cpe->ch[1].ics.ltp.present = get_bits(gb, 1)))
1772  decode_ltp(ac, &cpe->ch[1].ics.ltp, gb, cpe->ch[1].ics.max_sfb);
1773  ms_present = get_bits(gb, 2);
1774  if (ms_present == 3) {
1775  av_log(ac->avctx, AV_LOG_ERROR, "ms_present = 3 is reserved.\n");
1776  return AVERROR_INVALIDDATA;
1777  } else if (ms_present)
1778  decode_mid_side_stereo(cpe, gb, ms_present);
1779  }
1780  if ((ret = ff_aac_decode_ics(ac, &cpe->ch[0], gb, common_window, 0)))
1781  return ret;
1782  if ((ret = ff_aac_decode_ics(ac, &cpe->ch[1], gb, common_window, 0)))
1783  return ret;
1784 
1785  if (common_window) {
1786  if (ms_present)
1787  ac->dsp.apply_mid_side_stereo(ac, cpe);
1788  if (ac->oc[1].m4ac.object_type == AOT_AAC_MAIN) {
1789  ac->dsp.apply_prediction(ac, &cpe->ch[0]);
1790  ac->dsp.apply_prediction(ac, &cpe->ch[1]);
1791  }
1792  }
1793 
1794  ac->dsp.apply_intensity_stereo(ac, cpe, ms_present);
1795  return 0;
1796 }
1797 
1798 /**
1799  * Parse whether channels are to be excluded from Dynamic Range Compression; reference: table 4.53.
1800  *
1801  * @return Returns number of bytes consumed.
1802  */
1804  GetBitContext *gb)
1805 {
1806  int i;
1807  int num_excl_chan = 0;
1808 
1809  do {
1810  for (i = 0; i < 7; i++)
1811  che_drc->exclude_mask[num_excl_chan++] = get_bits1(gb);
1812  } while (num_excl_chan < MAX_CHANNELS - 7 && get_bits1(gb));
1813 
1814  return num_excl_chan / 7;
1815 }
1816 
1817 /**
1818  * Decode dynamic range information; reference: table 4.52.
1819  *
1820  * @return Returns number of bytes consumed.
1821  */
1823  GetBitContext *gb)
1824 {
1825  int n = 1;
1826  int drc_num_bands = 1;
1827  int i;
1828 
1829  /* pce_tag_present? */
1830  if (get_bits1(gb)) {
1831  che_drc->pce_instance_tag = get_bits(gb, 4);
1832  skip_bits(gb, 4); // tag_reserved_bits
1833  n++;
1834  }
1835 
1836  /* excluded_chns_present? */
1837  if (get_bits1(gb)) {
1838  n += decode_drc_channel_exclusions(che_drc, gb);
1839  }
1840 
1841  /* drc_bands_present? */
1842  if (get_bits1(gb)) {
1843  che_drc->band_incr = get_bits(gb, 4);
1844  che_drc->interpolation_scheme = get_bits(gb, 4);
1845  n++;
1846  drc_num_bands += che_drc->band_incr;
1847  for (i = 0; i < drc_num_bands; i++) {
1848  che_drc->band_top[i] = get_bits(gb, 8);
1849  n++;
1850  }
1851  }
1852 
1853  /* prog_ref_level_present? */
1854  if (get_bits1(gb)) {
1855  che_drc->prog_ref_level = get_bits(gb, 7);
1856  skip_bits1(gb); // prog_ref_level_reserved_bits
1857  n++;
1858  }
1859 
1860  for (i = 0; i < drc_num_bands; i++) {
1861  che_drc->dyn_rng_sgn[i] = get_bits1(gb);
1862  che_drc->dyn_rng_ctl[i] = get_bits(gb, 7);
1863  n++;
1864  }
1865 
1866  return n;
1867 }
1868 
1869 static int decode_fill(AACDecContext *ac, GetBitContext *gb, int len) {
1870  uint8_t buf[256];
1871  int i, major, minor;
1872 
1873  if (len < 13+7*8)
1874  goto unknown;
1875 
1876  get_bits(gb, 13); len -= 13;
1877 
1878  for(i=0; i+1<sizeof(buf) && len>=8; i++, len-=8)
1879  buf[i] = get_bits(gb, 8);
1880 
1881  buf[i] = 0;
1882  if (ac->avctx->debug & FF_DEBUG_PICT_INFO)
1883  av_log(ac->avctx, AV_LOG_DEBUG, "FILL:%s\n", buf);
1884 
1885  if (sscanf(buf, "libfaac %d.%d", &major, &minor) == 2){
1886  ac->avctx->internal->skip_samples = 1024;
1887  }
1888 
1889 unknown:
1890  skip_bits_long(gb, len);
1891 
1892  return 0;
1893 }
1894 
1895 /**
1896  * Decode extension data (incomplete); reference: table 4.51.
1897  *
1898  * @param cnt length of TYPE_FIL syntactic element in bytes
1899  *
1900  * @return Returns number of bytes consumed
1901  */
1903  ChannelElement *che, enum RawDataBlockType elem_type)
1904 {
1905  int crc_flag = 0;
1906  int res = cnt;
1907  int type = get_bits(gb, 4);
1908 
1909  if (ac->avctx->debug & FF_DEBUG_STARTCODE)
1910  av_log(ac->avctx, AV_LOG_DEBUG, "extension type: %d len:%d\n", type, cnt);
1911 
1912  switch (type) { // extension type
1913  case EXT_SBR_DATA_CRC:
1914  crc_flag++;
1915  case EXT_SBR_DATA:
1916  if (!che) {
1917  av_log(ac->avctx, AV_LOG_ERROR, "SBR was found before the first channel element.\n");
1918  return res;
1919  } else if (ac->oc[1].m4ac.frame_length_short) {
1920  if (!ac->warned_960_sbr)
1922  "SBR with 960 frame length");
1923  ac->warned_960_sbr = 1;
1924  skip_bits_long(gb, 8 * cnt - 4);
1925  return res;
1926  } else if (!ac->oc[1].m4ac.sbr) {
1927  av_log(ac->avctx, AV_LOG_ERROR, "SBR signaled to be not-present but was found in the bitstream.\n");
1928  skip_bits_long(gb, 8 * cnt - 4);
1929  return res;
1930  } else if (ac->oc[1].m4ac.sbr == -1 && ac->oc[1].status == OC_LOCKED) {
1931  av_log(ac->avctx, AV_LOG_ERROR, "Implicit SBR was found with a first occurrence after the first frame.\n");
1932  skip_bits_long(gb, 8 * cnt - 4);
1933  return res;
1934  } else if (ac->oc[1].m4ac.ps == -1 && ac->oc[1].status < OC_LOCKED &&
1935  ac->avctx->ch_layout.nb_channels == 1) {
1936  ac->oc[1].m4ac.sbr = 1;
1937  ac->oc[1].m4ac.ps = 1;
1940  ac->oc[1].status, 1);
1941  } else {
1942  ac->oc[1].m4ac.sbr = 1;
1944  }
1945 
1946  ac->proc.sbr_decode_extension(ac, che, gb, crc_flag, cnt, elem_type);
1947 
1948  if (ac->oc[1].m4ac.ps == 1 && !ac->warned_he_aac_mono) {
1949  av_log(ac->avctx, AV_LOG_VERBOSE, "Treating HE-AAC mono as stereo.\n");
1950  ac->warned_he_aac_mono = 1;
1951  }
1952  break;
1953  case EXT_DYNAMIC_RANGE:
1954  res = decode_dynamic_range(&ac->che_drc, gb);
1955  break;
1956  case EXT_FILL:
1957  decode_fill(ac, gb, 8 * cnt - 4);
1958  break;
1959  case EXT_FILL_DATA:
1960  case EXT_DATA_ELEMENT:
1961  default:
1962  skip_bits_long(gb, 8 * cnt - 4);
1963  break;
1964  };
1965  return res;
1966 }
1967 
1968 /**
1969  * channel coupling transformation interface
1970  *
1971  * @param apply_coupling_method pointer to (in)dependent coupling function
1972  */
1974  enum RawDataBlockType type, int elem_id,
1975  enum CouplingPoint coupling_point,
1976  void (*apply_coupling_method)(AACDecContext *ac, SingleChannelElement *target, ChannelElement *cce, int index))
1977 {
1978  int i, c;
1979 
1980  for (i = 0; i < MAX_ELEM_ID; i++) {
1981  ChannelElement *cce = ac->che[TYPE_CCE][i];
1982  int index = 0;
1983 
1984  if (cce && cce->coup.coupling_point == coupling_point) {
1985  ChannelCoupling *coup = &cce->coup;
1986 
1987  for (c = 0; c <= coup->num_coupled; c++) {
1988  if (coup->type[c] == type && coup->id_select[c] == elem_id) {
1989  if (coup->ch_select[c] != 1) {
1990  apply_coupling_method(ac, &cc->ch[0], cce, index);
1991  if (coup->ch_select[c] != 0)
1992  index++;
1993  }
1994  if (coup->ch_select[c] != 2)
1995  apply_coupling_method(ac, &cc->ch[1], cce, index++);
1996  } else
1997  index += 1 + (coup->ch_select[c] == 3);
1998  }
1999  }
2000  }
2001 }
2002 
2003 /**
2004  * Convert spectral data to samples, applying all supported tools as appropriate.
2005  */
2007 {
2008  int i, type;
2010  switch (ac->oc[1].m4ac.object_type) {
2011  case AOT_ER_AAC_LD:
2013  break;
2014  case AOT_ER_AAC_ELD:
2016  break;
2017  default:
2018  if (ac->oc[1].m4ac.frame_length_short)
2020  else
2022  }
2023  for (type = 3; type >= 0; type--) {
2024  for (i = 0; i < MAX_ELEM_ID; i++) {
2025  ChannelElement *che = ac->che[type][i];
2026  if (che && che->present) {
2027  if (type <= TYPE_CPE)
2029  if (ac->oc[1].m4ac.object_type == AOT_AAC_LTP) {
2030  if (che->ch[0].ics.predictor_present) {
2031  if (che->ch[0].ics.ltp.present)
2032  ac->dsp.apply_ltp(ac, &che->ch[0]);
2033  if (che->ch[1].ics.ltp.present && type == TYPE_CPE)
2034  ac->dsp.apply_ltp(ac, &che->ch[1]);
2035  }
2036  }
2037  if (che->ch[0].tns.present)
2038  ac->dsp.apply_tns(che->ch[0].coeffs,
2039  &che->ch[0].tns, &che->ch[0].ics, 1);
2040  if (che->ch[1].tns.present)
2041  ac->dsp.apply_tns(che->ch[1].coeffs,
2042  &che->ch[1].tns, &che->ch[1].ics, 1);
2043  if (type <= TYPE_CPE)
2045  if (type != TYPE_CCE || che->coup.coupling_point == AFTER_IMDCT) {
2046  imdct_and_window(ac, &che->ch[0]);
2047  if (ac->oc[1].m4ac.object_type == AOT_AAC_LTP)
2048  ac->dsp.update_ltp(ac, &che->ch[0]);
2049  if (type == TYPE_CPE) {
2050  imdct_and_window(ac, &che->ch[1]);
2051  if (ac->oc[1].m4ac.object_type == AOT_AAC_LTP)
2052  ac->dsp.update_ltp(ac, &che->ch[1]);
2053  }
2054  if (ac->oc[1].m4ac.sbr > 0) {
2055  ac->proc.sbr_apply(ac, che, type,
2056  che->ch[0].output,
2057  che->ch[1].output);
2058  }
2059  }
2060  if (type <= TYPE_CCE)
2062  ac->dsp.clip_output(ac, che, type, samples);
2063  che->present = 0;
2064  } else if (che) {
2065  av_log(ac->avctx, AV_LOG_VERBOSE, "ChannelElement %d.%d missing \n", type, i);
2066  }
2067  }
2068  }
2069 }
2070 
2072 {
2073  int size;
2074  AACADTSHeaderInfo hdr_info;
2075  uint8_t layout_map[MAX_ELEM_ID*4][3];
2076  int layout_map_tags, ret;
2077 
2078  size = ff_adts_header_parse(gb, &hdr_info);
2079  if (size > 0) {
2080  if (!ac->warned_num_aac_frames && hdr_info.num_aac_frames != 1) {
2081  // This is 2 for "VLB " audio in NSV files.
2082  // See samples/nsv/vlb_audio.
2084  "More than one AAC RDB per ADTS frame");
2085  ac->warned_num_aac_frames = 1;
2086  }
2088  if (hdr_info.chan_config) {
2089  ac->oc[1].m4ac.chan_config = hdr_info.chan_config;
2091  layout_map,
2092  &layout_map_tags,
2093  hdr_info.chan_config)) < 0)
2094  return ret;
2095  if ((ret = ff_aac_output_configure(ac, layout_map, layout_map_tags,
2096  FFMAX(ac->oc[1].status,
2097  OC_TRIAL_FRAME), 0)) < 0)
2098  return ret;
2099  } else {
2100  ac->oc[1].m4ac.chan_config = 0;
2101  /**
2102  * dual mono frames in Japanese DTV can have chan_config 0
2103  * WITHOUT specifying PCE.
2104  * thus, set dual mono as default.
2105  */
2106  if (ac->dmono_mode && ac->oc[0].status == OC_NONE) {
2107  layout_map_tags = 2;
2108  layout_map[0][0] = layout_map[1][0] = TYPE_SCE;
2109  layout_map[0][2] = layout_map[1][2] = AAC_CHANNEL_FRONT;
2110  layout_map[0][1] = 0;
2111  layout_map[1][1] = 1;
2112  if (ff_aac_output_configure(ac, layout_map, layout_map_tags,
2113  OC_TRIAL_FRAME, 0))
2114  return -7;
2115  }
2116  }
2117  ac->oc[1].m4ac.sample_rate = hdr_info.sample_rate;
2118  ac->oc[1].m4ac.sampling_index = hdr_info.sampling_index;
2119  ac->oc[1].m4ac.object_type = hdr_info.object_type;
2120  ac->oc[1].m4ac.frame_length_short = 0;
2121  if (ac->oc[0].status != OC_LOCKED ||
2122  ac->oc[0].m4ac.chan_config != hdr_info.chan_config ||
2123  ac->oc[0].m4ac.sample_rate != hdr_info.sample_rate) {
2124  ac->oc[1].m4ac.sbr = -1;
2125  ac->oc[1].m4ac.ps = -1;
2126  }
2127  if (!hdr_info.crc_absent)
2128  skip_bits(gb, 16);
2129  }
2130  return size;
2131 }
2132 
2134  int *got_frame_ptr, GetBitContext *gb)
2135 {
2136  AACDecContext *ac = avctx->priv_data;
2137  const MPEG4AudioConfig *const m4ac = &ac->oc[1].m4ac;
2138  ChannelElement *che;
2139  int err, i;
2140  int samples = m4ac->frame_length_short ? 960 : 1024;
2141  int chan_config = m4ac->chan_config;
2142  int aot = m4ac->object_type;
2143 
2144  if (aot == AOT_ER_AAC_LD || aot == AOT_ER_AAC_ELD)
2145  samples >>= 1;
2146 
2147  ac->frame = frame;
2148 
2149  if ((err = frame_configure_elements(avctx)) < 0)
2150  return err;
2151 
2152  // The AV_PROFILE_AAC_* defines are all object_type - 1
2153  // This may lead to an undefined profile being signaled
2154  ac->avctx->profile = aot - 1;
2155 
2156  ac->tags_mapped = 0;
2157 
2158  if (chan_config < 0 || (chan_config >= 8 && chan_config < 11) || chan_config >= 13) {
2159  avpriv_request_sample(avctx, "Unknown ER channel configuration %d",
2160  chan_config);
2161  return AVERROR_INVALIDDATA;
2162  }
2163  for (i = 0; i < ff_tags_per_config[chan_config]; i++) {
2164  const int elem_type = ff_aac_channel_layout_map[chan_config-1][i][0];
2165  const int elem_id = ff_aac_channel_layout_map[chan_config-1][i][1];
2166  if (!(che=ff_aac_get_che(ac, elem_type, elem_id))) {
2167  av_log(ac->avctx, AV_LOG_ERROR,
2168  "channel element %d.%d is not allocated\n",
2169  elem_type, elem_id);
2170  return AVERROR_INVALIDDATA;
2171  }
2172  che->present = 1;
2173  if (aot != AOT_ER_AAC_ELD)
2174  skip_bits(gb, 4);
2175  switch (elem_type) {
2176  case TYPE_SCE:
2177  err = ff_aac_decode_ics(ac, &che->ch[0], gb, 0, 0);
2178  break;
2179  case TYPE_CPE:
2180  err = decode_cpe(ac, gb, che);
2181  break;
2182  case TYPE_LFE:
2183  err = ff_aac_decode_ics(ac, &che->ch[0], gb, 0, 0);
2184  break;
2185  }
2186  if (err < 0)
2187  return err;
2188  }
2189 
2191 
2192  if (!ac->frame->data[0] && samples) {
2193  av_log(avctx, AV_LOG_ERROR, "no frame data found\n");
2194  return AVERROR_INVALIDDATA;
2195  }
2196 
2197  ac->frame->nb_samples = samples;
2198  ac->frame->sample_rate = avctx->sample_rate;
2199  *got_frame_ptr = 1;
2200 
2201  skip_bits_long(gb, get_bits_left(gb));
2202  return 0;
2203 }
2204 
2206  GetBitContext *gb, int *got_frame_ptr)
2207 {
2208  int err;
2209  int is_dmono;
2210  int elem_id;
2211  enum RawDataBlockType elem_type, che_prev_type = TYPE_END;
2212  uint8_t che_presence[4][MAX_ELEM_ID] = {{0}};
2213  ChannelElement *che = NULL, *che_prev = NULL;
2214  int samples = 0, multiplier, audio_found = 0, pce_found = 0, sce_count = 0;
2215  AVFrame *frame = ac->frame;
2216 
2217  int payload_alignment = get_bits_count(gb);
2218  // parse
2219  while ((elem_type = get_bits(gb, 3)) != TYPE_END) {
2220  elem_id = get_bits(gb, 4);
2221 
2222  if (avctx->debug & FF_DEBUG_STARTCODE)
2223  av_log(avctx, AV_LOG_DEBUG, "Elem type:%x id:%x\n", elem_type, elem_id);
2224 
2225  if (!avctx->ch_layout.nb_channels && elem_type != TYPE_PCE)
2226  return AVERROR_INVALIDDATA;
2227 
2228  if (elem_type < TYPE_DSE) {
2229  if (che_presence[elem_type][elem_id]) {
2230  int error = che_presence[elem_type][elem_id] > 1;
2231  av_log(ac->avctx, error ? AV_LOG_ERROR : AV_LOG_DEBUG, "channel element %d.%d duplicate\n",
2232  elem_type, elem_id);
2233  if (error)
2234  return AVERROR_INVALIDDATA;
2235  }
2236  che_presence[elem_type][elem_id]++;
2237 
2238  if (!(che=ff_aac_get_che(ac, elem_type, elem_id))) {
2239  av_log(ac->avctx, AV_LOG_ERROR, "channel element %d.%d is not allocated\n",
2240  elem_type, elem_id);
2241  return AVERROR_INVALIDDATA;
2242  }
2243  samples = ac->oc[1].m4ac.frame_length_short ? 960 : 1024;
2244  che->present = 1;
2245  }
2246 
2247  switch (elem_type) {
2248 
2249  case TYPE_SCE:
2250  err = ff_aac_decode_ics(ac, &che->ch[0], gb, 0, 0);
2251  audio_found = 1;
2252  sce_count++;
2253  break;
2254 
2255  case TYPE_CPE:
2256  err = decode_cpe(ac, gb, che);
2257  audio_found = 1;
2258  break;
2259 
2260  case TYPE_CCE:
2261  err = ac->proc.decode_cce(ac, gb, che);
2262  break;
2263 
2264  case TYPE_LFE:
2265  err = ff_aac_decode_ics(ac, &che->ch[0], gb, 0, 0);
2266  audio_found = 1;
2267  break;
2268 
2269  case TYPE_DSE:
2270  err = skip_data_stream_element(ac, gb);
2271  break;
2272 
2273  case TYPE_PCE: {
2274  uint8_t layout_map[MAX_ELEM_ID*4][3] = {{0}};
2275  int tags;
2276 
2277  int pushed = push_output_configuration(ac);
2278  if (pce_found && !pushed)
2279  return AVERROR_INVALIDDATA;
2280 
2281  tags = decode_pce(avctx, &ac->oc[1].m4ac, layout_map, gb,
2282  payload_alignment);
2283  if (tags < 0) {
2284  err = tags;
2285  break;
2286  }
2287  if (pce_found) {
2288  av_log(avctx, AV_LOG_ERROR,
2289  "Not evaluating a further program_config_element as this construct is dubious at best.\n");
2291  } else {
2292  err = ff_aac_output_configure(ac, layout_map, tags, OC_TRIAL_PCE, 1);
2293  if (!err)
2294  ac->oc[1].m4ac.chan_config = 0;
2295  pce_found = 1;
2296  }
2297  break;
2298  }
2299 
2300  case TYPE_FIL:
2301  if (elem_id == 15)
2302  elem_id += get_bits(gb, 8) - 1;
2303  if (get_bits_left(gb) < 8 * elem_id) {
2304  av_log(avctx, AV_LOG_ERROR, "TYPE_FIL: "overread_err);
2305  return AVERROR_INVALIDDATA;
2306  }
2307  err = 0;
2308  while (elem_id > 0) {
2309  int ret = decode_extension_payload(ac, gb, elem_id, che_prev, che_prev_type);
2310  if (ret < 0) {
2311  err = ret;
2312  break;
2313  }
2314  elem_id -= ret;
2315  }
2316  break;
2317 
2318  default:
2319  err = AVERROR_BUG; /* should not happen, but keeps compiler happy */
2320  break;
2321  }
2322 
2323  if (elem_type < TYPE_DSE) {
2324  che_prev = che;
2325  che_prev_type = elem_type;
2326  }
2327 
2328  if (err)
2329  return err;
2330 
2331  if (get_bits_left(gb) < 3) {
2332  av_log(avctx, AV_LOG_ERROR, overread_err);
2333  return AVERROR_INVALIDDATA;
2334  }
2335  }
2336 
2337  if (!avctx->ch_layout.nb_channels)
2338  return 0;
2339 
2340  multiplier = (ac->oc[1].m4ac.sbr == 1) ? ac->oc[1].m4ac.ext_sample_rate > ac->oc[1].m4ac.sample_rate : 0;
2341  samples <<= multiplier;
2342 
2344 
2345  if (ac->oc[1].status && audio_found) {
2346  avctx->sample_rate = ac->oc[1].m4ac.sample_rate << multiplier;
2347  avctx->frame_size = samples;
2348  ac->oc[1].status = OC_LOCKED;
2349  }
2350 
2351  if (!ac->frame->data[0] && samples) {
2352  av_log(avctx, AV_LOG_ERROR, "no frame data found\n");
2353  return AVERROR_INVALIDDATA;
2354  }
2355 
2356  if (samples) {
2357  ac->frame->nb_samples = samples;
2358  ac->frame->sample_rate = avctx->sample_rate;
2359  *got_frame_ptr = 1;
2360  } else {
2361  av_frame_unref(ac->frame);
2362  *got_frame_ptr = 0;
2363  }
2364 
2365  /* for dual-mono audio (SCE + SCE) */
2366  is_dmono = ac->dmono_mode && sce_count == 2 &&
2369  if (is_dmono) {
2370  if (ac->dmono_mode == 1)
2371  frame->data[1] = frame->data[0];
2372  else if (ac->dmono_mode == 2)
2373  frame->data[0] = frame->data[1];
2374  }
2375 
2376  return 0;
2377 }
2378 
2380  int *got_frame_ptr, GetBitContext *gb,
2381  const AVPacket *avpkt)
2382 {
2383  int err;
2384  AACDecContext *ac = avctx->priv_data;
2385 
2386  ac->frame = frame;
2387  *got_frame_ptr = 0;
2388 
2389  if (show_bits(gb, 12) == 0xfff) {
2390  if ((err = parse_adts_frame_header(ac, gb)) < 0) {
2391  av_log(avctx, AV_LOG_ERROR, "Error decoding AAC frame header.\n");
2392  goto fail;
2393  }
2394  if (ac->oc[1].m4ac.sampling_index > 12) {
2395  av_log(ac->avctx, AV_LOG_ERROR, "invalid sampling rate index %d\n", ac->oc[1].m4ac.sampling_index);
2396  err = AVERROR_INVALIDDATA;
2397  goto fail;
2398  }
2399  }
2400 
2401  if ((err = frame_configure_elements(avctx)) < 0)
2402  goto fail;
2403 
2404  // The AV_PROFILE_AAC_* defines are all object_type - 1
2405  // This may lead to an undefined profile being signaled
2406  ac->avctx->profile = ac->oc[1].m4ac.object_type - 1;
2407 
2408  ac->tags_mapped = 0;
2409 
2410  if (ac->oc[1].m4ac.object_type == AOT_USAC) {
2411  if (ac->is_fixed) {
2413  "AAC USAC fixed-point decoding");
2414  return AVERROR_PATCHWELCOME;
2415  }
2416 #if CONFIG_AAC_DECODER
2417  err = ff_aac_usac_decode_frame(avctx, ac, gb, got_frame_ptr);
2418  if (err < 0)
2419  goto fail;
2420 #endif
2421  } else {
2422  err = decode_frame_ga(avctx, ac, gb, got_frame_ptr);
2423  if (err < 0)
2424  goto fail;
2425  }
2426 
2427  return err;
2428 
2429 fail:
2431  return err;
2432 }
2433 
2435  int *got_frame_ptr, AVPacket *avpkt)
2436 {
2437  AACDecContext *ac = avctx->priv_data;
2438  const uint8_t *buf = avpkt->data;
2439  int buf_size = avpkt->size;
2440  GetBitContext gb;
2441  int buf_consumed;
2442  int buf_offset;
2443  int err;
2444  size_t new_extradata_size;
2445  const uint8_t *new_extradata = av_packet_get_side_data(avpkt,
2447  &new_extradata_size);
2448  size_t jp_dualmono_size;
2449  const uint8_t *jp_dualmono = av_packet_get_side_data(avpkt,
2451  &jp_dualmono_size);
2452 
2453  if (new_extradata) {
2454  /* discard previous configuration */
2455  ac->oc[1].status = OC_NONE;
2456  err = decode_audio_specific_config(ac, ac->avctx, &ac->oc[1],
2457  new_extradata,
2458  new_extradata_size * 8LL, 1);
2459  if (err < 0) {
2460  return err;
2461  }
2462  }
2463 
2464  ac->dmono_mode = 0;
2465  if (jp_dualmono && jp_dualmono_size > 0)
2466  ac->dmono_mode = 1 + *jp_dualmono;
2467  if (ac->force_dmono_mode >= 0)
2468  ac->dmono_mode = ac->force_dmono_mode;
2469 
2470  if (INT_MAX / 8 <= buf_size)
2471  return AVERROR_INVALIDDATA;
2472 
2473  if ((err = init_get_bits8(&gb, buf, buf_size)) < 0)
2474  return err;
2475 
2476  switch (ac->oc[1].m4ac.object_type) {
2477  case AOT_ER_AAC_LC:
2478  case AOT_ER_AAC_LTP:
2479  case AOT_ER_AAC_LD:
2480  case AOT_ER_AAC_ELD:
2481  err = aac_decode_er_frame(avctx, frame, got_frame_ptr, &gb);
2482  break;
2483  default:
2484  err = aac_decode_frame_int(avctx, frame, got_frame_ptr, &gb, avpkt);
2485  }
2486  if (err < 0)
2487  return err;
2488 
2489  buf_consumed = (get_bits_count(&gb) + 7) >> 3;
2490  for (buf_offset = buf_consumed; buf_offset < buf_size; buf_offset++)
2491  if (buf[buf_offset])
2492  break;
2493 
2494  return buf_size > buf_offset ? buf_consumed : buf_size;
2495 }
2496 
2497 #if CONFIG_AAC_LATM_DECODER
2498 #include "aacdec_latm.h"
2499 #endif
2500 
2501 #define AACDEC_FLAGS AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM
2502 #define OFF(field) offsetof(AACDecContext, field)
2503 static const AVOption options[] = {
2504  /**
2505  * AVOptions for Japanese DTV specific extensions (ADTS only)
2506  */
2507  {"dual_mono_mode", "Select the channel to decode for dual mono",
2508  OFF(force_dmono_mode), AV_OPT_TYPE_INT, {.i64=-1}, -1, 2,
2509  AACDEC_FLAGS, .unit = "dual_mono_mode"},
2510 
2511  {"auto", "autoselection", 0, AV_OPT_TYPE_CONST, {.i64=-1}, INT_MIN, INT_MAX, AACDEC_FLAGS, .unit = "dual_mono_mode"},
2512  {"main", "Select Main/Left channel", 0, AV_OPT_TYPE_CONST, {.i64= 1}, INT_MIN, INT_MAX, AACDEC_FLAGS, .unit = "dual_mono_mode"},
2513  {"sub" , "Select Sub/Right channel", 0, AV_OPT_TYPE_CONST, {.i64= 2}, INT_MIN, INT_MAX, AACDEC_FLAGS, .unit = "dual_mono_mode"},
2514  {"both", "Select both channels", 0, AV_OPT_TYPE_CONST, {.i64= 0}, INT_MIN, INT_MAX, AACDEC_FLAGS, .unit = "dual_mono_mode"},
2515 
2516  { "channel_order", "Order in which the channels are to be exported",
2517  OFF(output_channel_order), AV_OPT_TYPE_INT,
2518  { .i64 = CHANNEL_ORDER_DEFAULT }, 0, 1, AACDEC_FLAGS, .unit = "channel_order" },
2519  { "default", "normal libavcodec channel order", 0, AV_OPT_TYPE_CONST,
2520  { .i64 = CHANNEL_ORDER_DEFAULT }, .flags = AACDEC_FLAGS, .unit = "channel_order" },
2521  { "coded", "order in which the channels are coded in the bitstream",
2522  0, AV_OPT_TYPE_CONST, { .i64 = CHANNEL_ORDER_CODED }, .flags = AACDEC_FLAGS, .unit = "channel_order" },
2523 
2524  {NULL},
2525 };
2526 
2527 static const AVClass decoder_class = {
2528  .class_name = "AAC decoder",
2529  .item_name = av_default_item_name,
2530  .option = options,
2531  .version = LIBAVUTIL_VERSION_INT,
2532 };
2533 
2534 #if CONFIG_AAC_DECODER
2535 const FFCodec ff_aac_decoder = {
2536  .p.name = "aac",
2537  CODEC_LONG_NAME("AAC (Advanced Audio Coding)"),
2538  .p.type = AVMEDIA_TYPE_AUDIO,
2539  .p.id = AV_CODEC_ID_AAC,
2540  .p.priv_class = &decoder_class,
2541  .priv_data_size = sizeof(AACDecContext),
2543  .close = decode_close,
2545  .p.sample_fmts = (const enum AVSampleFormat[]) {
2547  },
2548  .p.capabilities = AV_CODEC_CAP_CHANNEL_CONF | AV_CODEC_CAP_DR1,
2549  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
2550  .p.ch_layouts = ff_aac_ch_layout,
2551  .flush = flush,
2552  .p.profiles = NULL_IF_CONFIG_SMALL(ff_aac_profiles),
2553 };
2554 #endif
2555 
2556 #if CONFIG_AAC_FIXED_DECODER
2557 const FFCodec ff_aac_fixed_decoder = {
2558  .p.name = "aac_fixed",
2559  CODEC_LONG_NAME("AAC (Advanced Audio Coding)"),
2560  .p.type = AVMEDIA_TYPE_AUDIO,
2561  .p.id = AV_CODEC_ID_AAC,
2562  .p.priv_class = &decoder_class,
2563  .priv_data_size = sizeof(AACDecContext),
2565  .close = decode_close,
2567  .p.sample_fmts = (const enum AVSampleFormat[]) {
2569  },
2570  .p.capabilities = AV_CODEC_CAP_CHANNEL_CONF | AV_CODEC_CAP_DR1,
2571  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
2572  .p.ch_layouts = ff_aac_ch_layout,
2573  .p.profiles = NULL_IF_CONFIG_SMALL(ff_aac_profiles),
2574  .flush = flush,
2575 };
2576 #endif
error
static void error(const char *err)
Definition: target_bsf_fuzzer.c:32
ChannelCoupling::type
enum RawDataBlockType type[8]
Type of channel element to be coupled - SCE or CPE.
Definition: aacdec.h:199
CouplingPoint
CouplingPoint
The point during decoding at which channel coupling is applied.
Definition: aacdec.h:68
MAX_ELEM_ID
#define MAX_ELEM_ID
Definition: aac.h:34
AVCodecContext::frame_size
int frame_size
Number of samples per channel in an audio frame.
Definition: avcodec.h:1083
AAC_CHANNEL_BACK
@ AAC_CHANNEL_BACK
Definition: aac.h:80
AV_SAMPLE_FMT_FLTP
@ AV_SAMPLE_FMT_FLTP
float, planar
Definition: samplefmt.h:66
decode_close
static av_cold int decode_close(AVCodecContext *avctx)
Definition: aacdec.c:1101
decode_frame_ga
static int decode_frame_ga(AVCodecContext *avctx, AACDecContext *ac, GetBitContext *gb, int *got_frame_ptr)
Definition: aacdec.c:2205
AACDecProc::decode_spectrum_and_dequant
int(* decode_spectrum_and_dequant)(AACDecContext *ac, GetBitContext *gb, const Pulse *pulse, SingleChannelElement *sce)
Definition: aacdec.h:396
skip_bits_long
static void skip_bits_long(GetBitContext *s, int n)
Skips the specified number of bits.
Definition: get_bits.h:278
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:215
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.c:443
AACDecContext::mdct960_fn
av_tx_fn mdct960_fn
Definition: aacdec.h:499
ff_tns_max_bands_128
const uint8_t ff_tns_max_bands_128[]
Definition: aactab.c:2000
AV_EF_EXPLODE
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: defs.h:51
av_clip
#define av_clip
Definition: common.h:100
BETWEEN_TNS_AND_IMDCT
@ BETWEEN_TNS_AND_IMDCT
Definition: aacdec.h:70
FF_CODEC_CAP_INIT_CLEANUP
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: codec_internal.h:43
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:695
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
AACDecDSP::apply_intensity_stereo
void(* apply_intensity_stereo)(AACDecContext *ac, ChannelElement *cpe, int ms_present)
Definition: aacdec.h:418
AACUSACConfig
Definition: aacdec.h:351
assign_channels
static int assign_channels(struct elem_to_channel e2c_vec[MAX_ELEM_ID], uint8_t(*layout_map)[3], uint64_t *layout, int tags, int layer, int pos, int *current)
Definition: aacdec.c:285
TYPE_FIL
@ TYPE_FIL
Definition: aac.h:46
EXT_FILL
@ EXT_FILL
Definition: aac.h:51
AV_CHANNEL_LAYOUT_STEREO
#define AV_CHANNEL_LAYOUT_STEREO
Definition: channel_layout.h:387
AVCodecContext::sample_rate
int sample_rate
samples per second
Definition: avcodec.h:1056
AACDecContext::mdct1024_fn
av_tx_fn mdct1024_fn
Definition: aacdec.h:500
decode_scalefactors
static int decode_scalefactors(AACDecContext *ac, SingleChannelElement *sce, GetBitContext *gb, unsigned int global_gain)
Decode scalefactors; reference: table 4.47.
Definition: aacdec.c:1471
AACDecContext::warned_he_aac_mono
int warned_he_aac_mono
Definition: aacdec.h:532
AACDecContext::mdct96
AVTXContext * mdct96
Definition: aacdec.h:483
AV_PKT_DATA_NEW_EXTRADATA
@ AV_PKT_DATA_NEW_EXTRADATA
The AV_PKT_DATA_NEW_EXTRADATA is used to notify the codec or the format that the extradata buffer was...
Definition: packet.h:56
ff_aac_usac_config_decode
int ff_aac_usac_config_decode(AACDecContext *ac, AVCodecContext *avctx, GetBitContext *gb, OutputConfiguration *oc, int channel_config)
Definition: aacdec_usac.c:333
AVCodecInternal::skip_samples
int skip_samples
Number of audio samples to skip at the start of the next decoded frame.
Definition: internal.h:125
AACDecProc::sbr_ctx_alloc_init
int(* sbr_ctx_alloc_init)(AACDecContext *ac, ChannelElement **che, int id_aac)
Definition: aacdec.h:403
AVCodecContext::err_recognition
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
Definition: avcodec.h:1430
Pulse::num_pulse
int num_pulse
Definition: aac.h:100
ff_ltp_coef
const float ff_ltp_coef[8]
Definition: aactab.c:110
int64_t
long long int64_t
Definition: coverity.c:34
decode_audio_specific_config
static int decode_audio_specific_config(AACDecContext *ac, AVCodecContext *avctx, OutputConfiguration *oc, const uint8_t *data, int64_t bit_size, int sync_extension)
Definition: aacdec.c:1075
get_bits_count
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:266
LongTermPrediction::used
int8_t used[MAX_LTP_LONG_SFB]
Definition: aacdec.h:121
AACDecContext::mdct768
AVTXContext * mdct768
Definition: aacdec.h:488
OC_TRIAL_PCE
@ OC_TRIAL_PCE
Output configuration under trial specified by an inband PCE.
Definition: aacdec.h:54
aacsbr.h
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:389
LongTermPrediction::coef
float coef
Definition: aacenc.h:84
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.c:2379
decode_drc_channel_exclusions
static int decode_drc_channel_exclusions(DynamicRangeControl *che_drc, GetBitContext *gb)
Parse whether channels are to be excluded from Dynamic Range Compression; reference: table 4....
Definition: aacdec.c:1803
w
uint8_t w
Definition: llviddspenc.c:38
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:539
ff_aac_num_swb_960
const uint8_t ff_aac_num_swb_960[]
Definition: aactab.c:153
AVOption
AVOption.
Definition: opt.h:429
AACDecContext::mdct960
AVTXContext * mdct960
Definition: aacdec.h:489
AOT_ER_AAC_LTP
@ AOT_ER_AAC_LTP
N Error Resilient Long Term Prediction.
Definition: mpeg4audio.h:90
TYPE_PCE
@ TYPE_PCE
Definition: aac.h:45
AV_SAMPLE_FMT_S32P
@ AV_SAMPLE_FMT_S32P
signed 32 bits, planar
Definition: samplefmt.h:65
data
const char data[16]
Definition: mxf.c:149
aacdec_usac.h
FF_COMPLIANCE_STRICT
#define FF_COMPLIANCE_STRICT
Strictly conform to all the things in the spec no matter what consequences.
Definition: defs.h:59
TemporalNoiseShaping::present
int present
Definition: aacdec.h:185
FFCodec
Definition: codec_internal.h:127
parse_adts_frame_header
static int parse_adts_frame_header(AACDecContext *ac, GetBitContext *gb)
Definition: aacdec.c:2071
ff_aac_profiles
const AVProfile ff_aac_profiles[]
Definition: profiles.c:27
ff_aac_num_swb_120
const uint8_t ff_aac_num_swb_120[]
Definition: aactab.c:173
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:225
AACDecContext::tag_che_map
ChannelElement * tag_che_map[4][MAX_ELEM_ID]
Definition: aacdec.h:465
AACDecDSP::apply_tns
void(* apply_tns)(void *_coef_param, TemporalNoiseShaping *tns, IndividualChannelStream *ics, int decode)
Definition: aacdec.h:421
AVChannelLayout::order
enum AVChannelOrder order
Channel order used in this layout.
Definition: channel_layout.h:316
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
ff_aac_num_swb_480
const uint8_t ff_aac_num_swb_480[]
Definition: aactab.c:165
AACDecContext::warned_remapping_once
int warned_remapping_once
Definition: aacdec.h:467
AACDecContext::proc
AACDecProc proc
Definition: aacdec.h:453
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:321
AACDecContext::mdct512_fn
av_tx_fn mdct512_fn
Definition: aacdec.h:497
AACDecDSP::apply_prediction
void(* apply_prediction)(AACDecContext *ac, SingleChannelElement *sce)
Definition: aacdec.h:427
ChannelElement::ch
SingleChannelElement ch[2]
Definition: aacdec.h:266
ff_aac_sample_rate_idx
static int ff_aac_sample_rate_idx(int rate)
Definition: aac.h:106
EXT_DYNAMIC_RANGE
@ EXT_DYNAMIC_RANGE
Definition: aac.h:54
ff_swb_offset_128
const uint16_t *const ff_swb_offset_128[]
Definition: aactab.c:1950
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_tx_init
av_cold int av_tx_init(AVTXContext **ctx, av_tx_fn *tx, enum AVTXType type, int inv, int len, const void *scale, uint64_t flags)
Initialize a transform context with the given configuration (i)MDCTs with an odd length are currently...
Definition: tx.c:903
ff_aac_decode_ics
int ff_aac_decode_ics(AACDecContext *ac, SingleChannelElement *sce, GetBitContext *gb, int common_window, int scale_flag)
Decode an individual_channel_stream payload; reference: table 4.44.
Definition: aacdec.c:1664
ChannelElement::present
int present
Definition: aacdec.h:261
FF_DEBUG_PICT_INFO
#define FF_DEBUG_PICT_INFO
Definition: avcodec.h:1407
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:410
ff_tns_max_bands_1024
const uint8_t ff_tns_max_bands_1024[]
Definition: aactab.c:1984
ff_aac_decode_init_float
int ff_aac_decode_init_float(AVCodecContext *avctx)
Definition: aacdec_float.c:164
AACDecContext::dmono_mode
int dmono_mode
0->not dmono, 1->use first channel, 2->use second channel
Definition: aacdec.h:522
MPEG4AudioConfig
Definition: mpeg4audio.h:29
skip_bits
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:381
DynamicRangeControl
Dynamic Range Control - decoded from the bitstream but not processed further.
Definition: aacdec.h:379
IndividualChannelStream::num_swb
int num_swb
number of scalefactor window bands
Definition: aacdec.h:171
options
static const AVOption options[]
Definition: aacdec.c:2503
ff_aac_decode_init_fixed
int ff_aac_decode_init_fixed(AVCodecContext *avctx)
Dequantization-related.
Definition: aacdec_fixed.c:87
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:335
ChannelCoupling::coupling_point
enum CouplingPoint coupling_point
The point during decoding at which coupling is applied.
Definition: aacdec.h:197
SingleChannelElement::coeffs
float coeffs[1024]
coefficients for IMDCT, maybe processed
Definition: aacenc.h:139
ff_aac_num_swb_512
const uint8_t ff_aac_num_swb_512[]
Definition: aactab.c:161
AACDecContext::force_dmono_mode
int force_dmono_mode
0->not dmono, 1->use first channel, 2->use second channel
Definition: aacdec.h:521
AACDecContext::warned_960_sbr
int warned_960_sbr
Definition: aacdec.h:529
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:131
AACDecContext::mdct480
AVTXContext * mdct480
Definition: aacdec.h:486
AVCodecContext::ch_layout
AVChannelLayout ch_layout
Audio channel layout.
Definition: avcodec.h:1071
macros.h
fail
#define fail()
Definition: checkasm.h:188
ChannelElement::coup
ChannelCoupling coup
Definition: aacdec.h:268
ChannelCoupling::id_select
int id_select[8]
element id
Definition: aacdec.h:200
SingleChannelElement::ret_buf
float ret_buf[2048]
PCM output buffer.
Definition: aacenc.h:140
ff_adts_header_parse
int ff_adts_header_parse(GetBitContext *gbc, AACADTSHeaderInfo *hdr)
Parse the ADTS frame header to the end of the variable header, which is the first 54 bits.
Definition: adts_header.c:30
AACDecContext::warned_71_wide
unsigned warned_71_wide
Definition: aacdec.h:530
TYPE_CPE
@ TYPE_CPE
Definition: aac.h:41
GetBitContext
Definition: get_bits.h:108
AV_EF_BITSTREAM
#define AV_EF_BITSTREAM
detect bitstream specification deviations
Definition: defs.h:49
AACDecContext::tags_mapped
int tags_mapped
Definition: aacdec.h:466
Pulse::amp
int amp[4]
Definition: aac.h:103
Pulse::pos
int pos[4]
Definition: aac.h:102
AACDecProc::sbr_apply
void(* sbr_apply)(AACDecContext *ac, ChannelElement *che, int id_aac, void *L, void *R)
Definition: aacdec.h:406
OutputConfiguration::status
enum OCStatus status
Definition: aacdec.h:372
type
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf type
Definition: writing_filters.txt:86
AACDecContext::che_drc
DynamicRangeControl che_drc
Definition: aacdec.h:458
MAX_LTP_LONG_SFB
#define MAX_LTP_LONG_SFB
Definition: aac.h:37
SingleChannelElement::ics
IndividualChannelStream ics
Definition: aacdec.h:211
AACDecContext::mdct480_fn
av_tx_fn mdct480_fn
Definition: aacdec.h:496
AACUSACConfig::elems
AACUsacElemConfig elems[64]
Definition: aacdec.h:356
decode_cpe
static int decode_cpe(AACDecContext *ac, GetBitContext *gb, ChannelElement *cpe)
Decode a channel_pair_element; reference: table 4.4.
Definition: aacdec.c:1757
decode_pulses
static int decode_pulses(Pulse *pulse, GetBitContext *gb, const uint16_t *swb_offset, int num_swb)
Decode pulse data; reference: table 4.7.
Definition: aacdec.c:1530
AACUsacElemConfig
Definition: aacdec.h:297
AOT_ER_AAC_LC
@ AOT_ER_AAC_LC
N Error Resilient Low Complexity.
Definition: mpeg4audio.h:88
AACADTSHeaderInfo::chan_config
uint8_t chan_config
Definition: adts_header.h:42
decode_fill
static int decode_fill(AACDecContext *ac, GetBitContext *gb, int len)
Definition: aacdec.c:1869
AACUsacElemConfig::ext
struct AACUsacElemConfig::@26 ext
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:209
ZERO_BT
@ ZERO_BT
Scalefactors and spectral data are all zero.
Definition: aac.h:67
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
AACDecDSP::dequant_scalefactors
void(* dequant_scalefactors)(SingleChannelElement *sce)
Definition: aacdec.h:415
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
DynamicRangeControl::exclude_mask
int exclude_mask[MAX_CHANNELS]
Channels to be excluded from DRC processing.
Definition: aacdec.h:383
AV_CH_LAYOUT_22POINT2
#define AV_CH_LAYOUT_22POINT2
Definition: channel_layout.h:248
ff_aac_decode_init
av_cold int ff_aac_decode_init(AVCodecContext *avctx)
Definition: aacdec.c:1177
OC_GLOBAL_HDR
@ OC_GLOBAL_HDR
Output configuration set in a global header but not yet locked.
Definition: aacdec.h:56
AACDecContext::mdct_ltp
AVTXContext * mdct_ltp
Definition: aacdec.h:491
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:530
NOISE_BT
@ NOISE_BT
Spectral data are scaled white noise not coded in the bitstream.
Definition: aac.h:71
AV_TX_FLOAT_MDCT
@ AV_TX_FLOAT_MDCT
Standard MDCT with a sample data type of float, double or int32_t, respecively.
Definition: tx.h:68
AOT_ER_AAC_LD
@ AOT_ER_AAC_LD
N Error Resilient Low Delay.
Definition: mpeg4audio.h:94
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:311
AACDecDSP::apply_mid_side_stereo
void(* apply_mid_side_stereo)(AACDecContext *ac, ChannelElement *cpe)
Definition: aacdec.h:417
ff_swb_offset_960
const uint16_t *const ff_swb_offset_960[]
Definition: aactab.c:1918
ChannelCoupling::num_coupled
int num_coupled
number of target elements
Definition: aacdec.h:198
AV_TX_INT32_MDCT
@ AV_TX_INT32_MDCT
Definition: tx.h:70
g
const char * g
Definition: vf_curves.c:128
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
EIGHT_SHORT_SEQUENCE
@ EIGHT_SHORT_SEQUENCE
Definition: aac.h:62
AV_CHANNEL_ORDER_UNSPEC
@ AV_CHANNEL_ORDER_UNSPEC
Only the channel count is specified, without any further information about the channel order.
Definition: channel_layout.h:116
TemporalNoiseShaping::direction
int direction[8][4]
Definition: aacdec.h:188
av_channel_layout_from_mask
int av_channel_layout_from_mask(AVChannelLayout *channel_layout, uint64_t mask)
Initialize a native channel layout from a bitmask indicating which channels are present.
Definition: channel_layout.c:247
AACUsacElemConfig::pl_data
uint8_t * pl_data
Definition: aacdec.h:347
INTENSITY_BT2
@ INTENSITY_BT2
Scalefactor data are intensity stereo positions (out of phase).
Definition: aac.h:72
bits
uint8_t bits
Definition: vp3data.h:128
AACDecProc::decode_cce
int(* decode_cce)(AACDecContext *ac, GetBitContext *gb, ChannelElement *che)
Definition: aacdec.h:401
TYPE_DSE
@ TYPE_DSE
Definition: aac.h:44
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
elem_to_channel::av_position
uint64_t av_position
Definition: aacdec.c:209
ff_aac_get_che
ChannelElement * ff_aac_get_che(AACDecContext *ac, int type, int elem_id)
Definition: aacdec.c:592
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:230
flush
static av_cold void flush(AVCodecContext *avctx)
Definition: aacdec.c:525
ChannelPosition
ChannelPosition
Definition: aac.h:76
AACDecDSP::imdct_and_windowing_ld
void(* imdct_and_windowing_ld)(AACDecContext *ac, SingleChannelElement *sce)
Definition: aacdec.h:439
channels
channels
Definition: aptx.h:31
decode.h
limits.h
LongTermPrediction::present
int8_t present
Definition: aacdec.h:118
IndividualChannelStream
Individual Channel Stream.
Definition: aacdec.h:162
AACDecContext::che
ChannelElement * che[4][MAX_ELEM_ID]
Definition: aacdec.h:464
SCALE_DIFF_ZERO
#define SCALE_DIFF_ZERO
codebook index corresponding to zero scalefactor indices difference
Definition: aac.h:91
NOISE_PRE
#define NOISE_PRE
preamble for NOISE_BT, put in bitstream with the first noise band
Definition: aac.h:95
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:296
AACDecContext::fdsp
AVFloatDSPContext * fdsp
Definition: aacdec.h:504
ff_aac_usac_decode_frame
int ff_aac_usac_decode_frame(AVCodecContext *avctx, AACDecContext *ac, GetBitContext *gb, int *got_frame_ptr)
Definition: aacdec_usac.c:1658
AACDecContext::warned_num_aac_frames
int warned_num_aac_frames
Definition: aacdec.h:528
AACADTSHeaderInfo::num_aac_frames
uint8_t num_aac_frames
Definition: adts_header.h:43
INTENSITY_BT
@ INTENSITY_BT
Scalefactor data are intensity stereo positions (in phase).
Definition: aac.h:73
elem_to_channel::syn_ele
uint8_t syn_ele
Definition: aacdec.c:210
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
decode_extension_payload
static int decode_extension_payload(AACDecContext *ac, GetBitContext *gb, int cnt, ChannelElement *che, enum RawDataBlockType elem_type)
Decode extension data (incomplete); reference: table 4.51.
Definition: aacdec.c:1902
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:75
AACDecContext::mdct96_fn
av_tx_fn mdct96_fn
Definition: aacdec.h:493
NULL
#define NULL
Definition: coverity.c:32
spectral_to_sample
static void spectral_to_sample(AACDecContext *ac, int samples)
Convert spectral data to samples, applying all supported tools as appropriate.
Definition: aacdec.c:2006
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
AACDecProc::sbr_decode_extension
int(* sbr_decode_extension)(AACDecContext *ac, ChannelElement *che, GetBitContext *gb, int crc, int cnt, int id_aac)
Definition: aacdec.h:404
IndividualChannelStream::use_kb_window
uint8_t use_kb_window[2]
If set, use Kaiser-Bessel window, otherwise use a sine window.
Definition: aacdec.h:165
ff_aac_num_swb_128
const uint8_t ff_aac_num_swb_128[]
Definition: aactab.c:169
AVCodecContext::internal
struct AVCodecInternal * internal
Private context used for internal data.
Definition: avcodec.h:486
IndividualChannelStream::num_window_groups
int num_window_groups
Definition: aacdec.h:166
AAC_CHANNEL_SIDE
@ AAC_CHANNEL_SIDE
Definition: aac.h:79
BEFORE_TNS
@ BEFORE_TNS
Definition: aacdec.h:69
AACADTSHeaderInfo::sampling_index
uint8_t sampling_index
Definition: adts_header.h:41
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:237
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:388
ff_aac_ch_layout
const AVChannelLayout ff_aac_ch_layout[]
Definition: aacdec_tab.c:96
profiles.h
MPEG4AudioConfig::sampling_index
int sampling_index
Definition: mpeg4audio.h:31
ff_aac_fixed_decoder
const FFCodec ff_aac_fixed_decoder
AOT_USAC
@ AOT_USAC
Y Unified Speech and Audio Coding.
Definition: mpeg4audio.h:113
ChannelElement::ms_mask
uint8_t ms_mask[128]
Set if mid/side stereo is used for each scalefactor window band.
Definition: aacdec.h:264
aac.h
aactab.h
IndividualChannelStream::predictor_present
int predictor_present
Definition: aacdec.h:174
DynamicRangeControl::band_top
int band_top[17]
Indicates the top of the i-th DRC band in units of 4 spectral lines.
Definition: aacdec.h:386
ff_swb_offset_480
const uint16_t *const ff_swb_offset_480[]
Definition: aactab.c:1942
AAC_CHANNEL_FRONT
@ AAC_CHANNEL_FRONT
Definition: aac.h:78
sniff_channel_order
static uint64_t sniff_channel_order(uint8_t(*layout_map)[3], int tags)
Definition: aacdec.c:363
aac_decode_er_frame
static int aac_decode_er_frame(AVCodecContext *avctx, AVFrame *frame, int *got_frame_ptr, GetBitContext *gb)
Definition: aacdec.c:2133
AV_CH_FRONT_CENTER
#define AV_CH_FRONT_CENTER
Definition: channel_layout.h:174
count_channels
static int count_channels(uint8_t(*layout)[3], int tags)
Definition: aacdec.c:117
AOT_AAC_MAIN
@ AOT_AAC_MAIN
Y Main.
Definition: mpeg4audio.h:73
decode_mid_side_stereo
static void decode_mid_side_stereo(ChannelElement *cpe, GetBitContext *gb, int ms_present)
Decode Mid/Side data; reference: table 4.54.
Definition: aacdec.c:1615
get_vlc2
static av_always_inline int get_vlc2(GetBitContext *s, const VLCElem *table, int bits, int max_depth)
Parse a vlc code.
Definition: get_bits.h:652
AAC_CHANNEL_OFF
@ AAC_CHANNEL_OFF
Definition: aac.h:77
AACDecContext::mdct120
AVTXContext * mdct120
Definition: aacdec.h:484
OC_LOCKED
@ OC_LOCKED
Output configuration locked in place.
Definition: aacdec.h:57
index
int index
Definition: gxfenc.c:90
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
IndividualChannelStream::prev_num_window_groups
int prev_num_window_groups
Previous frame's number of window groups.
Definition: aacdec.h:167
aac_decode_frame
static int aac_decode_frame(AVCodecContext *avctx, AVFrame *frame, int *got_frame_ptr, AVPacket *avpkt)
Definition: aacdec.c:2434
error.h
ff_tns_max_bands_512
const uint8_t ff_tns_max_bands_512[]
Definition: aactab.c:1992
OutputConfiguration::layout_map_tags
int layout_map_tags
Definition: aacdec.h:370
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:447
OutputConfiguration::layout_map
uint8_t layout_map[MAX_ELEM_ID *4][3]
Definition: aacdec.h:369
ff_dlog
#define ff_dlog(a,...)
Definition: tableprint_vlc.h:28
AACDecDSP::update_ltp
void(* update_ltp)(AACDecContext *ac, SingleChannelElement *sce)
Definition: aacdec.h:425
AACDecDSP::apply_independent_coupling
void(* apply_independent_coupling)(AACDecContext *ac, SingleChannelElement *target, ChannelElement *cce, int index)
Definition: aacdec.h:432
frame_configure_elements
static int frame_configure_elements(AVCodecContext *avctx)
Definition: aacdec.c:174
ff_aac_pred_sfb_max
const uint8_t ff_aac_pred_sfb_max[]
Definition: aactab.c:181
IndividualChannelStream::window_sequence
enum WindowSequence window_sequence[2]
Definition: aacdec.h:164
AACDecContext::dsp
AACDecDSP dsp
Definition: aacdec.h:452
AACDecDSP::clip_output
void(* clip_output)(AACDecContext *ac, ChannelElement *che, int type, int samples)
Definition: aacdec.h:442
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1692
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:368
AOT_ER_AAC_SCALABLE
@ AOT_ER_AAC_SCALABLE
N Error Resilient Scalable.
Definition: mpeg4audio.h:91
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
OC_NONE
@ OC_NONE
Output unconfigured.
Definition: aacdec.h:53
AACDecDSP::apply_dependent_coupling
void(* apply_dependent_coupling)(AACDecContext *ac, SingleChannelElement *target, ChannelElement *cce, int index)
Definition: aacdec.h:429
ff_swb_offset_1024
const uint16_t *const ff_swb_offset_1024[]
Definition: aactab.c:1910
AOT_AAC_SCALABLE
@ AOT_AAC_SCALABLE
N Scalable.
Definition: mpeg4audio.h:78
AVPacket::size
int size
Definition: packet.h:540
skip_data_stream_element
static int skip_data_stream_element(AACDecContext *ac, GetBitContext *gb)
Skip data_stream_element; reference: table 4.10.
Definition: aacdec.c:1240
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:94
AVChannelLayout
An AVChannelLayout holds information about the channel layout of audio data.
Definition: channel_layout.h:311
codec_internal.h
ONLY_LONG_SEQUENCE
@ ONLY_LONG_SEQUENCE
Definition: aac.h:60
TYPE_END
@ TYPE_END
Definition: aac.h:47
AACDecContext::mdct1024
AVTXContext * mdct1024
Definition: aacdec.h:490
AVTXType
AVTXType
Definition: tx.h:39
AVFrame::sample_rate
int sample_rate
Sample rate of the audio data.
Definition: frame.h:588
AACDecDSP::imdct_and_windowing
void(* imdct_and_windowing)(AACDecContext *ac, SingleChannelElement *sce)
Definition: aacdec.h:436
ChannelElement::max_sfb_ste
uint8_t max_sfb_ste
(USAC) Maximum of both max_sfb values
Definition: aacdec.h:263
OCStatus
OCStatus
Output configuration status.
Definition: aacdec.h:52
AV_SAMPLE_FMT_NONE
@ AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:56
size
int size
Definition: twinvq_data.h:10344
SingleChannelElement::sfo
int sfo[128]
scalefactor offsets
Definition: aacdec.h:215
ff_tags_per_config
const int8_t ff_tags_per_config[16]
Definition: aacdec_tab.c:38
DynamicRangeControl::prog_ref_level
int prog_ref_level
A reference level for the long-term program audio level for all channels combined.
Definition: aacdec.h:387
avpriv_report_missing_feature
void avpriv_report_missing_feature(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
AACDecContext::output_element
SingleChannelElement * output_element[MAX_CHANNELS]
Points to each SingleChannelElement.
Definition: aacdec.h:513
ff_mpeg4audio_get_config_gb
int ff_mpeg4audio_get_config_gb(MPEG4AudioConfig *c, GetBitContext *gb, int sync_extension, void *logctx)
Parse MPEG-4 systems extradata from a potentially unaligned GetBitContext to retrieve audio configura...
Definition: mpeg4audio.c:92
AACDecContext::output_channel_order
enum AACOutputChannelOrder output_channel_order
Definition: aacdec.h:525
decode_dynamic_range
static int decode_dynamic_range(DynamicRangeControl *che_drc, GetBitContext *gb)
Decode dynamic range information; reference: table 4.52.
Definition: aacdec.c:1822
OutputConfiguration
Definition: aacdec.h:367
elem_to_channel::elem_id
uint8_t elem_id
Definition: aacdec.c:211
ff_tns_max_bands_480
const uint8_t ff_tns_max_bands_480[]
Definition: aactab.c:1996
elem_to_channel
Definition: aacdec.c:208
ff_swb_offset_512
const uint16_t *const ff_swb_offset_512[]
Definition: aactab.c:1934
offset
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
Definition: writing_filters.txt:86
attributes.h
decoder_class
static const AVClass decoder_class
Definition: aacdec.c:2527
skip_bits1
static void skip_bits1(GetBitContext *s)
Definition: get_bits.h:413
AACADTSHeaderInfo::object_type
uint8_t object_type
Definition: adts_header.h:40
SingleChannelElement::band_type
enum BandType band_type[128]
band types
Definition: aacdec.h:214
MAX_CHANNELS
#define MAX_CHANNELS
Definition: aac.h:33
AV_CHAN_UNUSED
@ AV_CHAN_UNUSED
Channel is empty can be safely skipped.
Definition: channel_layout.h:88
AACDecContext::mdct128
AVTXContext * mdct128
Definition: aacdec.h:485
DynamicRangeControl::dyn_rng_ctl
int dyn_rng_ctl[17]
DRC magnitude information.
Definition: aacdec.h:382
decode_ga_specific_config
static int decode_ga_specific_config(AACDecContext *ac, AVCodecContext *avctx, GetBitContext *gb, int get_bit_alignment, MPEG4AudioConfig *m4ac, int channel_config)
Decode GA "General Audio" specific configuration; reference: table 4.1.
Definition: aacdec.c:850
AACDecDSP::apply_ltp
void(* apply_ltp)(AACDecContext *ac, SingleChannelElement *sce)
Definition: aacdec.h:424
SingleChannelElement::output
float * output
PCM output.
Definition: aacdec.h:227
MPEG4AudioConfig::channels
int channels
Definition: mpeg4audio.h:39
av_tx_uninit
av_cold void av_tx_uninit(AVTXContext **ctx)
Frees a context and sets *ctx to NULL, does nothing when *ctx == NULL.
Definition: tx.c:295
decode_eld_specific_config
static int decode_eld_specific_config(AACDecContext *ac, AVCodecContext *avctx, GetBitContext *gb, MPEG4AudioConfig *m4ac, int channel_config)
Definition: aacdec.c:931
av_channel_layout_compare
int av_channel_layout_compare(const AVChannelLayout *chl, const AVChannelLayout *chl1)
Check whether two channel layouts are semantically the same, i.e.
Definition: channel_layout.c:804
EXT_FILL_DATA
@ EXT_FILL_DATA
Definition: aac.h:52
decode_prediction
static int decode_prediction(AACDecContext *ac, IndividualChannelStream *ics, GetBitContext *gb)
Definition: aacdec.c:1257
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:220
AOT_AAC_SSR
@ AOT_AAC_SSR
N (code in SoC repo) Scalable Sample Rate.
Definition: mpeg4audio.h:75
AACDecContext::mdct768_fn
av_tx_fn mdct768_fn
Definition: aacdec.h:498
MDCT_INIT
#define MDCT_INIT(s, fn, len, sval)
AACDecDSP::imdct_and_windowing_960
void(* imdct_and_windowing_960)(AACDecContext *ac, SingleChannelElement *sce)
Definition: aacdec.h:438
layout
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 layout
Definition: filter_design.txt:18
decode_audio_specific_config_gb
static int decode_audio_specific_config_gb(AACDecContext *ac, AVCodecContext *avctx, OutputConfiguration *oc, GetBitContext *gb, int get_bit_alignment, int sync_extension)
Decode audio specific configuration; reference: table 1.13.
Definition: aacdec.c:1000
ff_tns_tmp2_map
const float *const ff_tns_tmp2_map[4]
Definition: aactab.c:142
CHANNEL_ORDER_CODED
@ CHANNEL_ORDER_CODED
Definition: aacdec.h:62
AVFrame::nb_samples
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:469
RawDataBlockType
RawDataBlockType
Definition: aac.h:39
log.h
SingleChannelElement
Single Channel Element - used for both SCE and LFE elements.
Definition: aacdec.h:210
AACDecContext::is_fixed
int is_fixed
Definition: aacdec.h:534
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
IndividualChannelStream::num_windows
int num_windows
Definition: aacdec.h:172
OutputConfiguration::usac
AACUSACConfig usac
Definition: aacdec.h:373
AACDecContext::warned_gain_control
int warned_gain_control
Definition: aacdec.h:531
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:529
show_bits
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
Definition: get_bits.h:371
av_packet_get_side_data
uint8_t * av_packet_get_side_data(const AVPacket *pkt, enum AVPacketSideDataType type, size_t *size)
Get side information from packet.
Definition: packet.c:252
ff_aac_channel_layout_map
const uint8_t ff_aac_channel_layout_map[16][16][3]
Definition: aacdec_tab.c:40
push_output_configuration
static int push_output_configuration(AACDecContext *ac)
Save current output configuration if and only if it has been locked.
Definition: aacdec.c:427
AACDecContext::random_state
int random_state
Definition: aacdec.h:506
relative_align_get_bits
static void relative_align_get_bits(GetBitContext *gb, int reference_position)
Definition: aacdec.c:768
AACDEC_FLAGS
#define AACDEC_FLAGS
Definition: aacdec.c:2501
AVFrame::extended_data
uint8_t ** extended_data
pointers to the data planes/channels.
Definition: frame.h:450
ChannelElement
channel element - generic struct for SCE/CPE/CCE/LFE
Definition: aacdec.h:260
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:170
AOT_ER_AAC_ELD
@ AOT_ER_AAC_ELD
N Error Resilient Enhanced Low Delay.
Definition: mpeg4audio.h:110
assign_pair
static int assign_pair(struct elem_to_channel e2c_vec[MAX_ELEM_ID], uint8_t(*layout_map)[3], int offset, uint64_t left, uint64_t right, int pos, uint64_t *layout)
Definition: aacdec.c:215
AVSampleFormat
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:55
NOISE_PRE_BITS
#define NOISE_PRE_BITS
length of preamble
Definition: aac.h:96
FF_DEBUG_STARTCODE
#define FF_DEBUG_STARTCODE
Definition: avcodec.h:1414
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
AV_CH_FRONT_LEFT
#define AV_CH_FRONT_LEFT
Definition: channel_layout.h:172
TYPE_LFE
@ TYPE_LFE
Definition: aac.h:43
av_frame_unref
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:610
LongTermPrediction::lag
int16_t lag
Definition: aacdec.h:119
ff_aac_decoder
const FFCodec ff_aac_decoder
MPEG4AudioConfig::chan_config
int chan_config
Definition: mpeg4audio.h:33
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:194
TemporalNoiseShaping::order
int order[8][4]
Definition: aacdec.h:189
TYPE_SCE
@ TYPE_SCE
Definition: aac.h:40
decode_ics_info
static int decode_ics_info(AACDecContext *ac, IndividualChannelStream *ics, GetBitContext *gb)
Decode Individual Channel Stream info; reference: table 4.6.
Definition: aacdec.c:1297
len
int len
Definition: vorbis_enc_data.h:426
filt
static const int8_t filt[NUMTAPS *2]
Definition: af_earwax.c:40
che_configure
static av_cold int che_configure(AACDecContext *ac, enum ChannelPosition che_pos, int type, int id, int *channels)
Check for the channel element in the current channel position configuration.
Definition: aacdec.c:141
AACDecContext::oc
OutputConfiguration oc[2]
Definition: aacdec.h:527
MPEG4AudioConfig::ext_sample_rate
int ext_sample_rate
Definition: mpeg4audio.h:37
IndividualChannelStream::tns_max_bands
int tns_max_bands
Definition: aacdec.h:173
TemporalNoiseShaping::length
int length[8][4]
Definition: aacdec.h:187
AACDecDSP::imdct_and_windowing_eld
void(* imdct_and_windowing_eld)(AACDecContext *ac, SingleChannelElement *sce)
Definition: aacdec.h:440
AACUSACConfig::nb_elems
int nb_elems
Definition: aacdec.h:357
AACADTSHeaderInfo::sample_rate
uint32_t sample_rate
Definition: adts_header.h:36
avcodec.h
ff_swb_offset_120
const uint16_t *const ff_swb_offset_120[]
Definition: aactab.c:1960
AAC_CHANNEL_LFE
@ AAC_CHANNEL_LFE
Definition: aac.h:81
version.h
AOT_ER_BSAC
@ AOT_ER_BSAC
N Error Resilient Bit-Sliced Arithmetic Coding.
Definition: mpeg4audio.h:93
DynamicRangeControl::pce_instance_tag
int pce_instance_tag
Indicates with which program the DRC info is associated.
Definition: aacdec.h:380
decode_ltp
static void decode_ltp(AACDecContext *ac, LongTermPrediction *ltp, GetBitContext *gb, uint8_t max_sfb)
Decode Long Term Prediction data; reference: table 4.xx.
Definition: aacdec.c:1279
ret
ret
Definition: filter_design.txt:187
AV_PKT_DATA_JP_DUALMONO
@ AV_PKT_DATA_JP_DUALMONO
An AV_PKT_DATA_JP_DUALMONO side data packet indicates that the packet may contain "dual mono" audio s...
Definition: packet.h:163
elem_to_channel::aac_position
uint8_t aac_position
Definition: aacdec.c:212
ff_aac_num_swb_1024
const uint8_t ff_aac_num_swb_1024[]
Definition: aactab.c:149
FFSWAP
#define FFSWAP(type, a, b)
Definition: macros.h:52
AVClass::class_name
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:80
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
AACDecContext::frame
struct AVFrame * frame
Definition: aacdec.h:455
AVCodecContext::strict_std_compliance
int strict_std_compliance
strictly follow the standard (MPEG-4, ...).
Definition: avcodec.h:1389
align_get_bits
static const uint8_t * align_get_bits(GetBitContext *s)
Definition: get_bits.h:561
pos
unsigned int pos
Definition: spdifenc.c:414
count_paired_channels
static int count_paired_channels(uint8_t(*layout_map)[3], int tags, int pos, int current)
Definition: aacdec.c:253
TemporalNoiseShaping::coef
float coef[8][4][TNS_MAX_ORDER]
Definition: aacenc.h:121
CHANNEL_ORDER_DEFAULT
@ CHANNEL_ORDER_DEFAULT
Definition: aacdec.h:61
ChannelCoupling::ch_select
int ch_select[8]
[0] shared list of gains; [1] list of gains for right channel; [2] list of gains for left channel; [3...
Definition: aacdec.h:201
id
enum AVCodecID id
Definition: dts2pts.c:367
left
Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2] ... the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so ...,+,-,+,-,+,+,-,+,-,+,... hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32 - hcoeff[1] - hcoeff[2] - ... a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2} an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||......... intra?||||:Block01 :yes no||||:Block02 :....... ..........||||:Block03 ::y DC ::ref index:||||:Block04 ::cb DC ::motion x :||||......... :cr DC ::motion y :||||....... ..........|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------ ------------ ------------|||Y subbands||Cb subbands||Cr subbands||||--- ---||--- ---||--- ---|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------ ------------ ------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction ------------|\ Dequantization ------------------- \||Reference frames|\ IDWT|------- -------|Motion \|||Frame 0||Frame 1||Compensation . OBMC v -------|------- -------|--------------. \------> Frame n output Frame Frame<----------------------------------/|...|------------------- Range Coder:============Binary Range Coder:------------------- The implemented range coder is an adapted version based upon "Range encoding: an algorithm for removing redundancy from a digitised message." by G. N. N. Martin. The symbols encoded by the Snow range coder are bits(0|1). The associated probabilities are not fix but change depending on the symbol mix seen so far. bit seen|new state ---------+----------------------------------------------- 0|256 - state_transition_table[256 - old_state];1|state_transition_table[old_state];state_transition_table={ 0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:------------------------- FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1. the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled left
Definition: snow.txt:386
MPEG4AudioConfig::object_type
int object_type
Definition: mpeg4audio.h:30
SingleChannelElement::tns
TemporalNoiseShaping tns
Definition: aacdec.h:213
U
#define U(x)
Definition: vpx_arith.h:37
overread_err
#define overread_err
Definition: aacdec.c:115
aacdec.h
imdct_and_window
static void imdct_and_window(TwinVQContext *tctx, enum TwinVQFrameType ftype, int wtype, float *in, float *prev, int ch)
Definition: twinvq.c:329
AACDecContext
main AAC decoding context
Definition: aacdec.h:448
AACADTSHeaderInfo::crc_absent
uint8_t crc_absent
Definition: adts_header.h:39
AV_CHAN_NONE
@ AV_CHAN_NONE
Invalid channel index.
Definition: channel_layout.h:49
init_dsp
static av_cold int init_dsp(AVCodecContext *avctx)
Definition: aacdec.c:1142
EXT_SBR_DATA_CRC
@ EXT_SBR_DATA_CRC
Definition: aac.h:56
AVCodecContext
main external API structure.
Definition: avcodec.h:451
EXT_SBR_DATA
@ EXT_SBR_DATA
Definition: aac.h:55
LongTermPrediction
Long Term Prediction.
Definition: aacdec.h:117
AV_PROFILE_AAC_HE_V2
#define AV_PROFILE_AAC_HE_V2
Definition: defs.h:73
AACDecContext::avctx
struct AVCodecContext * avctx
Definition: aacdec.h:450
MPEG4AudioConfig::ps
int ps
-1 implicit, 1 presence
Definition: mpeg4audio.h:40
aacdec_latm.h
NOISE_OFFSET
#define NOISE_OFFSET
subtracted from global gain, used as offset for the preamble
Definition: aac.h:97
aacdec_tab.h
IndividualChannelStream::prediction_used
uint8_t prediction_used[41]
Definition: aacdec.h:177
mode
mode
Definition: ebur128.h:83
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Underlying C type is int.
Definition: opt.h:259
AVCodecContext::profile
int profile
profile
Definition: avcodec.h:1650
TemporalNoiseShaping
Temporal Noise Shaping.
Definition: aacdec.h:184
ff_mpeg4audio_channels
const uint8_t ff_mpeg4audio_channels[15]
Definition: mpeg4audio.c:59
av_channel_layout_uninit
void av_channel_layout_uninit(AVChannelLayout *channel_layout)
Free any allocated data in the channel layout and reset the channel count to 0.
Definition: channel_layout.c:437
MPEG4AudioConfig::sbr
int sbr
-1 implicit, 1 presence
Definition: mpeg4audio.h:34
samples
Filter the word “frame” indicates either a video frame or a group of audio samples
Definition: filter_design.txt:8
ff_aac_decode_tns
int ff_aac_decode_tns(AACDecContext *ac, TemporalNoiseShaping *tns, GetBitContext *gb, const IndividualChannelStream *ics)
Decode Temporal Noise Shaping data; reference: table 4.48.
Definition: aacdec.c:1557
Q31
#define Q31(x)
Definition: aac_defines.h:111
DynamicRangeControl::band_incr
int band_incr
Number of DRC bands greater than 1 having DRC info.
Definition: aacdec.h:384
AACDecContext::mdct_ltp_fn
av_tx_fn mdct_ltp_fn
Definition: aacdec.h:501
ff_aac_usac_reset_state
int ff_aac_usac_reset_state(AACDecContext *ac, OutputConfiguration *oc)
Definition: aacdec_usac.c:274
decode_gain_control
static void decode_gain_control(SingleChannelElement *sce, GetBitContext *gb)
Definition: aacdec.c:1629
AVCodecContext::debug
int debug
debug
Definition: avcodec.h:1406
AV_CH_FRONT_RIGHT
#define AV_CH_FRONT_RIGHT
Definition: channel_layout.h:173
av_channel_layout_copy
int av_channel_layout_copy(AVChannelLayout *dst, const AVChannelLayout *src)
Make a copy of a channel layout.
Definition: channel_layout.c:444
OutputConfiguration::m4ac
MPEG4AudioConfig m4ac
Definition: aacdec.h:368
TYPE_CCE
@ TYPE_CCE
Definition: aac.h:42
apply_channel_coupling
static void apply_channel_coupling(AACDecContext *ac, ChannelElement *cc, enum RawDataBlockType type, int elem_id, enum CouplingPoint coupling_point, void(*apply_coupling_method)(AACDecContext *ac, SingleChannelElement *target, ChannelElement *cce, int index))
channel coupling transformation interface
Definition: aacdec.c:1973
mem.h
OutputConfiguration::ch_layout
AVChannelLayout ch_layout
Definition: aacdec.h:371
ff_aacdec_common_init_once
av_cold void ff_aacdec_common_init_once(void)
Definition: aacdec_tab.c:304
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h:36
adts_header.h
MPEG4AudioConfig::frame_length_short
int frame_length_short
Definition: mpeg4audio.h:41
AV_PROFILE_AAC_HE
#define AV_PROFILE_AAC_HE
Definition: defs.h:72
ff_aac_channel_map
const int16_t ff_aac_channel_map[3][4][6]
Definition: aacdec_tab.c:75
DynamicRangeControl::dyn_rng_sgn
int dyn_rng_sgn[17]
DRC sign information; 0 - positive, 1 - negative.
Definition: aacdec.h:381
AVPacket
This structure stores compressed data.
Definition: packet.h:516
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:478
ff_vlc_scalefactors
VLCElem ff_vlc_scalefactors[352]
Definition: aacdec_tab.c:111
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
ChannelCoupling
coupling parameters
Definition: aacdec.h:196
EXT_DATA_ELEMENT
@ EXT_DATA_ELEMENT
Definition: aac.h:53
aac_defines.h
AVERROR_BUG
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
Definition: error.h:52
IndividualChannelStream::max_sfb
uint8_t max_sfb
number of scalefactor bands per group
Definition: aacdec.h:163
decode_channel_map
static void decode_channel_map(uint8_t layout_map[][3], enum ChannelPosition type, GetBitContext *gb, int n)
Decode an array of 4 bit element IDs, optionally interleaved with a stereo/mono switching bit.
Definition: aacdec.c:738
Pulse
Definition: aac.h:99
AAC_CHANNEL_CC
@ AAC_CHANNEL_CC
Definition: aac.h:82
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
OFF
#define OFF(field)
Definition: aacdec.c:2502
AACDecContext::mdct512
AVTXContext * mdct512
Definition: aacdec.h:487
DynamicRangeControl::interpolation_scheme
int interpolation_scheme
Indicates the interpolation scheme used in the SBR QMF domain.
Definition: aacdec.h:385
AFTER_IMDCT
@ AFTER_IMDCT
Definition: aacdec.h:71
ff_aac_set_default_channel_config
int ff_aac_set_default_channel_config(AACDecContext *ac, AVCodecContext *avctx, uint8_t(*layout_map)[3], int *tags, int channel_config)
Set up channel positions based on a default channel configuration as specified in table 1....
Definition: aacdec.c:552
IndividualChannelStream::ltp
LongTermPrediction ltp
Definition: aacdec.h:169
IndividualChannelStream::group_len
uint8_t group_len[8]
Definition: aacdec.h:168
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Special option type for declaring named constants.
Definition: opt.h:299
decode_band_types
static int decode_band_types(AACDecContext *ac, SingleChannelElement *sce, GetBitContext *gb)
Decode band types (section_data payload); reference: table 4.46.
Definition: aacdec.c:1424
decode_pce
static int decode_pce(AVCodecContext *avctx, MPEG4AudioConfig *m4ac, uint8_t(*layout_map)[3], GetBitContext *gb, int byte_align_ref)
Decode program configuration element; reference: table 4.2.
Definition: aacdec.c:780
AOT_AAC_LC
@ AOT_AAC_LC
Y Low Complexity.
Definition: mpeg4audio.h:74
TemporalNoiseShaping::n_filt
int n_filt[8]
Definition: aacdec.h:186
AOT_AAC_LTP
@ AOT_AAC_LTP
Y Long Term Prediction.
Definition: mpeg4audio.h:76
OC_TRIAL_FRAME
@ OC_TRIAL_FRAME
Output configuration under trial specified by a frame header.
Definition: aacdec.h:55
Q30
#define Q30(x)
Definition: aac_defines.h:110
ff_aac_output_configure
int ff_aac_output_configure(AACDecContext *ac, uint8_t layout_map[MAX_ELEM_ID *4][3], int tags, enum OCStatus oc_type, int get_new_frame)
Configure output channel order based on the current program configuration element.
Definition: aacdec.c:459
AACDecProc::sbr_ctx_close
void(* sbr_ctx_close)(ChannelElement *che)
Definition: aacdec.h:408
AACADTSHeaderInfo
Definition: adts_header.h:35
IndividualChannelStream::predictor_reset_group
int predictor_reset_group
Definition: aacdec.h:176
tx.h
AACDecContext::mdct120_fn
av_tx_fn mdct120_fn
Definition: aacdec.h:494
MPEG4AudioConfig::sample_rate
int sample_rate
Definition: mpeg4audio.h:32
AACDecContext::mdct128_fn
av_tx_fn mdct128_fn
Definition: aacdec.h:495