FFmpeg
aacdec_template.c
Go to the documentation of this file.
1 /*
2  * AAC decoder
3  * Copyright (c) 2005-2006 Oded Shimon ( ods15 ods15 dyndns org )
4  * Copyright (c) 2006-2007 Maxim Gavrilov ( maxim.gavrilov gmail com )
5  * Copyright (c) 2008-2013 Alex Converse <alex.converse@gmail.com>
6  *
7  * AAC LATM decoder
8  * Copyright (c) 2008-2010 Paul Kendall <paul@kcbbs.gen.nz>
9  * Copyright (c) 2010 Janne Grunau <janne-libav@jannau.net>
10  *
11  * 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 /**
33  * @file
34  * AAC decoder
35  * @author Oded Shimon ( ods15 ods15 dyndns org )
36  * @author Maxim Gavrilov ( maxim.gavrilov gmail com )
37  *
38  * AAC decoder fixed-point implementation
39  * @author Stanislav Ocovaj ( stanislav.ocovaj imgtec com )
40  * @author Nedeljko Babic ( nedeljko.babic imgtec com )
41  */
42 
43 /*
44  * supported tools
45  *
46  * Support? Name
47  * N (code in SoC repo) gain control
48  * Y block switching
49  * Y window shapes - standard
50  * N window shapes - Low Delay
51  * Y filterbank - standard
52  * N (code in SoC repo) filterbank - Scalable Sample Rate
53  * Y Temporal Noise Shaping
54  * Y Long Term Prediction
55  * Y intensity stereo
56  * Y channel coupling
57  * Y frequency domain prediction
58  * Y Perceptual Noise Substitution
59  * Y Mid/Side stereo
60  * N Scalable Inverse AAC Quantization
61  * N Frequency Selective Switch
62  * N upsampling filter
63  * Y quantization & coding - AAC
64  * N quantization & coding - TwinVQ
65  * N quantization & coding - BSAC
66  * N AAC Error Resilience tools
67  * N Error Resilience payload syntax
68  * N Error Protection tool
69  * N CELP
70  * N Silence Compression
71  * N HVXC
72  * N HVXC 4kbits/s VR
73  * N Structured Audio tools
74  * N Structured Audio Sample Bank Format
75  * N MIDI
76  * N Harmonic and Individual Lines plus Noise
77  * N Text-To-Speech Interface
78  * Y Spectral Band Replication
79  * Y (not in this code) Layer-1
80  * Y (not in this code) Layer-2
81  * Y (not in this code) Layer-3
82  * N SinuSoidal Coding (Transient, Sinusoid, Noise)
83  * Y Parametric Stereo
84  * N Direct Stream Transfer
85  * Y (not in fixed point code) Enhanced AAC Low Delay (ER AAC ELD)
86  *
87  * Note: - HE AAC v1 comprises LC AAC with Spectral Band Replication.
88  * - HE AAC v2 comprises LC AAC with Spectral Band Replication and
89  Parametric Stereo.
90  */
91 
92 #include "libavutil/thread.h"
93 
94 static VLC vlc_scalefactors;
95 static VLC vlc_spectral[11];
96 
97 static int output_configure(AACContext *ac,
98  uint8_t layout_map[MAX_ELEM_ID*4][3], int tags,
99  enum OCStatus oc_type, int get_new_frame);
100 
101 #define overread_err "Input buffer exhausted before END element found\n"
102 
103 static int count_channels(uint8_t (*layout)[3], int tags)
104 {
105  int i, sum = 0;
106  for (i = 0; i < tags; i++) {
107  int syn_ele = layout[i][0];
108  int pos = layout[i][2];
109  sum += (1 + (syn_ele == TYPE_CPE)) *
110  (pos != AAC_CHANNEL_OFF && pos != AAC_CHANNEL_CC);
111  }
112  return sum;
113 }
114 
115 /**
116  * Check for the channel element in the current channel position configuration.
117  * If it exists, make sure the appropriate element is allocated and map the
118  * channel order to match the internal FFmpeg channel layout.
119  *
120  * @param che_pos current channel position configuration
121  * @param type channel element type
122  * @param id channel element id
123  * @param channels count of the number of channels in the configuration
124  *
125  * @return Returns error status. 0 - OK, !0 - error
126  */
127 static av_cold int che_configure(AACContext *ac,
128  enum ChannelPosition che_pos,
129  int type, int id, int *channels)
130 {
131  if (*channels >= MAX_CHANNELS)
132  return AVERROR_INVALIDDATA;
133  if (che_pos) {
134  if (!ac->che[type][id]) {
135  if (!(ac->che[type][id] = av_mallocz(sizeof(ChannelElement))))
136  return AVERROR(ENOMEM);
137  AAC_RENAME(ff_aac_sbr_ctx_init)(ac, &ac->che[type][id]->sbr, type);
138  }
139  if (type != TYPE_CCE) {
140  if (*channels >= MAX_CHANNELS - (type == TYPE_CPE || (type == TYPE_SCE && ac->oc[1].m4ac.ps == 1))) {
141  av_log(ac->avctx, AV_LOG_ERROR, "Too many channels\n");
142  return AVERROR_INVALIDDATA;
143  }
144  ac->output_element[(*channels)++] = &ac->che[type][id]->ch[0];
145  if (type == TYPE_CPE ||
146  (type == TYPE_SCE && ac->oc[1].m4ac.ps == 1)) {
147  ac->output_element[(*channels)++] = &ac->che[type][id]->ch[1];
148  }
149  }
150  } else {
151  if (ac->che[type][id])
152  AAC_RENAME(ff_aac_sbr_ctx_close)(&ac->che[type][id]->sbr);
153  av_freep(&ac->che[type][id]);
154  }
155  return 0;
156 }
157 
158 static int frame_configure_elements(AVCodecContext *avctx)
159 {
160  AACContext *ac = avctx->priv_data;
161  int type, id, ch, ret;
162 
163  /* set channel pointers to internal buffers by default */
164  for (type = 0; type < 4; type++) {
165  for (id = 0; id < MAX_ELEM_ID; id++) {
166  ChannelElement *che = ac->che[type][id];
167  if (che) {
168  che->ch[0].ret = che->ch[0].ret_buf;
169  che->ch[1].ret = che->ch[1].ret_buf;
170  }
171  }
172  }
173 
174  /* get output buffer */
175  av_frame_unref(ac->frame);
176  if (!avctx->channels)
177  return 1;
178 
179  ac->frame->nb_samples = 2048;
180  if ((ret = ff_get_buffer(avctx, ac->frame, 0)) < 0)
181  return ret;
182 
183  /* map output channel pointers to AVFrame data */
184  for (ch = 0; ch < avctx->channels; ch++) {
185  if (ac->output_element[ch])
186  ac->output_element[ch]->ret = (INTFLOAT *)ac->frame->extended_data[ch];
187  }
188 
189  return 0;
190 }
191 
192 struct elem_to_channel {
193  uint64_t av_position;
194  uint8_t syn_ele;
195  uint8_t elem_id;
196  uint8_t aac_position;
197 };
198 
199 static int assign_pair(struct elem_to_channel e2c_vec[MAX_ELEM_ID],
200  uint8_t (*layout_map)[3], int offset, uint64_t left,
201  uint64_t right, int pos, uint64_t *layout)
202 {
203  if (layout_map[offset][0] == TYPE_CPE) {
204  e2c_vec[offset] = (struct elem_to_channel) {
205  .av_position = left | right,
206  .syn_ele = TYPE_CPE,
207  .elem_id = layout_map[offset][1],
208  .aac_position = pos
209  };
210  if (e2c_vec[offset].av_position != UINT64_MAX)
211  *layout |= e2c_vec[offset].av_position;
212 
213  return 1;
214  } else {
215  e2c_vec[offset] = (struct elem_to_channel) {
216  .av_position = left,
217  .syn_ele = TYPE_SCE,
218  .elem_id = layout_map[offset][1],
219  .aac_position = pos
220  };
221  e2c_vec[offset + 1] = (struct elem_to_channel) {
222  .av_position = right,
223  .syn_ele = TYPE_SCE,
224  .elem_id = layout_map[offset + 1][1],
225  .aac_position = pos
226  };
227  if (left != UINT64_MAX)
228  *layout |= left;
229 
230  if (right != UINT64_MAX)
231  *layout |= right;
232 
233  return 2;
234  }
235 }
236 
237 static int count_paired_channels(uint8_t (*layout_map)[3], int tags, int pos,
238  int *current)
239 {
240  int num_pos_channels = 0;
241  int first_cpe = 0;
242  int sce_parity = 0;
243  int i;
244  for (i = *current; i < tags; i++) {
245  if (layout_map[i][2] != pos)
246  break;
247  if (layout_map[i][0] == TYPE_CPE) {
248  if (sce_parity) {
249  if (pos == AAC_CHANNEL_FRONT && !first_cpe) {
250  sce_parity = 0;
251  } else {
252  return -1;
253  }
254  }
255  num_pos_channels += 2;
256  first_cpe = 1;
257  } else {
258  num_pos_channels++;
259  sce_parity ^= 1;
260  }
261  }
262  if (sce_parity &&
263  ((pos == AAC_CHANNEL_FRONT && first_cpe) || pos == AAC_CHANNEL_SIDE))
264  return -1;
265  *current = i;
266  return num_pos_channels;
267 }
268 
269 #define PREFIX_FOR_22POINT2 (AV_CH_LAYOUT_7POINT1_WIDE_BACK|AV_CH_BACK_CENTER|AV_CH_SIDE_LEFT|AV_CH_SIDE_RIGHT|AV_CH_LOW_FREQUENCY_2)
270 static uint64_t sniff_channel_order(uint8_t (*layout_map)[3], int tags)
271 {
272  int i, n, total_non_cc_elements;
273  struct elem_to_channel e2c_vec[4 * MAX_ELEM_ID] = { { 0 } };
274  int num_front_channels, num_side_channels, num_back_channels;
275  uint64_t layout = 0;
276 
277  if (FF_ARRAY_ELEMS(e2c_vec) < tags)
278  return 0;
279 
280  i = 0;
281  num_front_channels =
282  count_paired_channels(layout_map, tags, AAC_CHANNEL_FRONT, &i);
283  if (num_front_channels < 0)
284  return 0;
285  num_side_channels =
286  count_paired_channels(layout_map, tags, AAC_CHANNEL_SIDE, &i);
287  if (num_side_channels < 0)
288  return 0;
289  num_back_channels =
290  count_paired_channels(layout_map, tags, AAC_CHANNEL_BACK, &i);
291  if (num_back_channels < 0)
292  return 0;
293 
294  if (num_side_channels == 0 && num_back_channels >= 4) {
295  num_side_channels = 2;
296  num_back_channels -= 2;
297  }
298 
299  i = 0;
300  if (num_front_channels & 1) {
301  e2c_vec[i] = (struct elem_to_channel) {
302  .av_position = AV_CH_FRONT_CENTER,
303  .syn_ele = TYPE_SCE,
304  .elem_id = layout_map[i][1],
305  .aac_position = AAC_CHANNEL_FRONT
306  };
307  layout |= e2c_vec[i].av_position;
308  i++;
309  num_front_channels--;
310  }
311  if (num_front_channels >= 4) {
312  i += assign_pair(e2c_vec, layout_map, i,
313  AV_CH_FRONT_LEFT_OF_CENTER,
314  AV_CH_FRONT_RIGHT_OF_CENTER,
315  AAC_CHANNEL_FRONT, &layout);
316  num_front_channels -= 2;
317  }
318  if (num_front_channels >= 2) {
319  i += assign_pair(e2c_vec, layout_map, i,
320  AV_CH_FRONT_LEFT,
321  AV_CH_FRONT_RIGHT,
322  AAC_CHANNEL_FRONT, &layout);
323  num_front_channels -= 2;
324  }
325  while (num_front_channels >= 2) {
326  i += assign_pair(e2c_vec, layout_map, i,
327  UINT64_MAX,
328  UINT64_MAX,
329  AAC_CHANNEL_FRONT, &layout);
330  num_front_channels -= 2;
331  }
332 
333  if (num_side_channels >= 2) {
334  i += assign_pair(e2c_vec, layout_map, i,
335  AV_CH_SIDE_LEFT,
336  AV_CH_SIDE_RIGHT,
337  AAC_CHANNEL_FRONT, &layout);
338  num_side_channels -= 2;
339  }
340  while (num_side_channels >= 2) {
341  i += assign_pair(e2c_vec, layout_map, i,
342  UINT64_MAX,
343  UINT64_MAX,
344  AAC_CHANNEL_SIDE, &layout);
345  num_side_channels -= 2;
346  }
347 
348  while (num_back_channels >= 4) {
349  i += assign_pair(e2c_vec, layout_map, i,
350  UINT64_MAX,
351  UINT64_MAX,
352  AAC_CHANNEL_BACK, &layout);
353  num_back_channels -= 2;
354  }
355  if (num_back_channels >= 2) {
356  i += assign_pair(e2c_vec, layout_map, i,
357  AV_CH_BACK_LEFT,
358  AV_CH_BACK_RIGHT,
359  AAC_CHANNEL_BACK, &layout);
360  num_back_channels -= 2;
361  }
362  if (num_back_channels) {
363  e2c_vec[i] = (struct elem_to_channel) {
364  .av_position = AV_CH_BACK_CENTER,
365  .syn_ele = TYPE_SCE,
366  .elem_id = layout_map[i][1],
367  .aac_position = AAC_CHANNEL_BACK
368  };
369  layout |= e2c_vec[i].av_position;
370  i++;
371  num_back_channels--;
372  }
373 
374  if (i < tags && layout_map[i][2] == AAC_CHANNEL_LFE) {
375  e2c_vec[i] = (struct elem_to_channel) {
376  .av_position = AV_CH_LOW_FREQUENCY,
377  .syn_ele = TYPE_LFE,
378  .elem_id = layout_map[i][1],
379  .aac_position = AAC_CHANNEL_LFE
380  };
381  layout |= e2c_vec[i].av_position;
382  i++;
383  }
384  if (i < tags && layout_map[i][2] == AAC_CHANNEL_LFE) {
385  e2c_vec[i] = (struct elem_to_channel) {
386  .av_position = AV_CH_LOW_FREQUENCY_2,
387  .syn_ele = TYPE_LFE,
388  .elem_id = layout_map[i][1],
389  .aac_position = AAC_CHANNEL_LFE
390  };
391  layout |= e2c_vec[i].av_position;
392  i++;
393  }
394  while (i < tags && layout_map[i][2] == AAC_CHANNEL_LFE) {
395  e2c_vec[i] = (struct elem_to_channel) {
396  .av_position = UINT64_MAX,
397  .syn_ele = TYPE_LFE,
398  .elem_id = layout_map[i][1],
399  .aac_position = AAC_CHANNEL_LFE
400  };
401  i++;
402  }
403 
404  // The previous checks would end up at 8 at this point for 22.2
405  if (layout == PREFIX_FOR_22POINT2 && tags == 16 && i == 8) {
406  const uint8_t (*reference_layout_map)[3] = aac_channel_layout_map[12];
407  for (int j = 0; j < tags; j++) {
408  if (layout_map[j][0] != reference_layout_map[j][0] ||
409  layout_map[j][2] != reference_layout_map[j][2])
410  goto end_of_layout_definition;
411  }
412 
413  e2c_vec[i] = (struct elem_to_channel) {
414  .av_position = AV_CH_TOP_FRONT_CENTER,
415  .syn_ele = layout_map[i][0],
416  .elem_id = layout_map[i][1],
417  .aac_position = layout_map[i][2]
418  }; layout |= e2c_vec[i].av_position; i++;
419  i += assign_pair(e2c_vec, layout_map, i,
420  AV_CH_TOP_FRONT_LEFT,
421  AV_CH_TOP_FRONT_RIGHT,
422  AAC_CHANNEL_FRONT,
423  &layout);
424  i += assign_pair(e2c_vec, layout_map, i,
425  AV_CH_TOP_SIDE_LEFT,
426  AV_CH_TOP_SIDE_RIGHT,
427  AAC_CHANNEL_SIDE,
428  &layout);
429  e2c_vec[i] = (struct elem_to_channel) {
430  .av_position = AV_CH_TOP_CENTER,
431  .syn_ele = layout_map[i][0],
432  .elem_id = layout_map[i][1],
433  .aac_position = layout_map[i][2]
434  }; layout |= e2c_vec[i].av_position; i++;
435  i += assign_pair(e2c_vec, layout_map, i,
436  AV_CH_TOP_BACK_LEFT,
437  AV_CH_TOP_BACK_RIGHT,
438  AAC_CHANNEL_BACK,
439  &layout);
440  e2c_vec[i] = (struct elem_to_channel) {
441  .av_position = AV_CH_TOP_BACK_CENTER,
442  .syn_ele = layout_map[i][0],
443  .elem_id = layout_map[i][1],
444  .aac_position = layout_map[i][2]
445  }; layout |= e2c_vec[i].av_position; i++;
446  e2c_vec[i] = (struct elem_to_channel) {
447  .av_position = AV_CH_BOTTOM_FRONT_CENTER,
448  .syn_ele = layout_map[i][0],
449  .elem_id = layout_map[i][1],
450  .aac_position = layout_map[i][2]
451  }; layout |= e2c_vec[i].av_position; i++;
452  i += assign_pair(e2c_vec, layout_map, i,
453  AV_CH_BOTTOM_FRONT_LEFT,
454  AV_CH_BOTTOM_FRONT_RIGHT,
455  AAC_CHANNEL_FRONT,
456  &layout);
457  }
458 
459 end_of_layout_definition:
460 
461  total_non_cc_elements = n = i;
462 
463  if (layout == AV_CH_LAYOUT_22POINT2) {
464  // For 22.2 reorder the result as needed
465  FFSWAP(struct elem_to_channel, e2c_vec[2], e2c_vec[0]); // FL & FR first (final), FC third
466  FFSWAP(struct elem_to_channel, e2c_vec[2], e2c_vec[1]); // FC second (final), FLc & FRc third
467  FFSWAP(struct elem_to_channel, e2c_vec[6], e2c_vec[2]); // LFE1 third (final), FLc & FRc seventh
468  FFSWAP(struct elem_to_channel, e2c_vec[4], e2c_vec[3]); // BL & BR fourth (final), SiL & SiR fifth
469  FFSWAP(struct elem_to_channel, e2c_vec[6], e2c_vec[4]); // FLc & FRc fifth (final), SiL & SiR seventh
470  FFSWAP(struct elem_to_channel, e2c_vec[7], e2c_vec[6]); // LFE2 seventh (final), SiL & SiR eight (final)
471  FFSWAP(struct elem_to_channel, e2c_vec[9], e2c_vec[8]); // TpFL & TpFR ninth (final), TFC tenth (final)
472  FFSWAP(struct elem_to_channel, e2c_vec[11], e2c_vec[10]); // TC eleventh (final), TpSiL & TpSiR twelth
473  FFSWAP(struct elem_to_channel, e2c_vec[12], e2c_vec[11]); // TpBL & TpBR twelth (final), TpSiL & TpSiR thirteenth (final)
474  } else {
475  // For everything else, utilize the AV channel position define as a
476  // stable sort.
477  do {
478  int next_n = 0;
479  for (i = 1; i < n; i++)
480  if (e2c_vec[i - 1].av_position > e2c_vec[i].av_position) {
481  FFSWAP(struct elem_to_channel, e2c_vec[i - 1], e2c_vec[i]);
482  next_n = i;
483  }
484  n = next_n;
485  } while (n > 0);
486 
487  }
488 
489  for (i = 0; i < total_non_cc_elements; i++) {
490  layout_map[i][0] = e2c_vec[i].syn_ele;
491  layout_map[i][1] = e2c_vec[i].elem_id;
492  layout_map[i][2] = e2c_vec[i].aac_position;
493  }
494 
495  return layout;
496 }
497 
498 /**
499  * Save current output configuration if and only if it has been locked.
500  */
501 static int push_output_configuration(AACContext *ac) {
502  int pushed = 0;
503 
504  if (ac->oc[1].status == OC_LOCKED || ac->oc[0].status == OC_NONE) {
505  ac->oc[0] = ac->oc[1];
506  pushed = 1;
507  }
508  ac->oc[1].status = OC_NONE;
509  return pushed;
510 }
511 
512 /**
513  * Restore the previous output configuration if and only if the current
514  * configuration is unlocked.
515  */
516 static void pop_output_configuration(AACContext *ac) {
517  if (ac->oc[1].status != OC_LOCKED && ac->oc[0].status != OC_NONE) {
518  ac->oc[1] = ac->oc[0];
519  ac->avctx->channels = ac->oc[1].channels;
520  ac->avctx->channel_layout = ac->oc[1].channel_layout;
521  output_configure(ac, ac->oc[1].layout_map, ac->oc[1].layout_map_tags,
522  ac->oc[1].status, 0);
523  }
524 }
525 
526 /**
527  * Configure output channel order based on the current program
528  * configuration element.
529  *
530  * @return Returns error status. 0 - OK, !0 - error
531  */
532 static int output_configure(AACContext *ac,
533  uint8_t layout_map[MAX_ELEM_ID * 4][3], int tags,
534  enum OCStatus oc_type, int get_new_frame)
535 {
536  AVCodecContext *avctx = ac->avctx;
537  int i, channels = 0, ret;
538  uint64_t layout = 0;
539  uint8_t id_map[TYPE_END][MAX_ELEM_ID] = {{ 0 }};
540  uint8_t type_counts[TYPE_END] = { 0 };
541 
542  if (ac->oc[1].layout_map != layout_map) {
543  memcpy(ac->oc[1].layout_map, layout_map, tags * sizeof(layout_map[0]));
544  ac->oc[1].layout_map_tags = tags;
545  }
546  for (i = 0; i < tags; i++) {
547  int type = layout_map[i][0];
548  int id = layout_map[i][1];
549  id_map[type][id] = type_counts[type]++;
550  if (id_map[type][id] >= MAX_ELEM_ID) {
551  avpriv_request_sample(ac->avctx, "Too large remapped id");
552  return AVERROR_PATCHWELCOME;
553  }
554  }
555  // Try to sniff a reasonable channel order, otherwise output the
556  // channels in the order the PCE declared them.
557  if (avctx->request_channel_layout != AV_CH_LAYOUT_NATIVE)
558  layout = sniff_channel_order(layout_map, tags);
559  for (i = 0; i < tags; i++) {
560  int type = layout_map[i][0];
561  int id = layout_map[i][1];
562  int iid = id_map[type][id];
563  int position = layout_map[i][2];
564  // Allocate or free elements depending on if they are in the
565  // current program configuration.
566  ret = che_configure(ac, position, type, iid, &channels);
567  if (ret < 0)
568  return ret;
569  ac->tag_che_map[type][id] = ac->che[type][iid];
570  }
571  if (ac->oc[1].m4ac.ps == 1 && channels == 2) {
572  if (layout == AV_CH_FRONT_CENTER) {
573  layout = AV_CH_FRONT_LEFT|AV_CH_FRONT_RIGHT;
574  } else {
575  layout = 0;
576  }
577  }
578 
579  if (layout) avctx->channel_layout = layout;
580  ac->oc[1].channel_layout = layout;
581  avctx->channels = ac->oc[1].channels = channels;
582  ac->oc[1].status = oc_type;
583 
584  if (get_new_frame) {
585  if ((ret = frame_configure_elements(ac->avctx)) < 0)
586  return ret;
587  }
588 
589  return 0;
590 }
591 
592 static void flush(AVCodecContext *avctx)
593 {
594  AACContext *ac= avctx->priv_data;
595  int type, i, j;
596 
597  for (type = 3; type >= 0; type--) {
598  for (i = 0; i < MAX_ELEM_ID; i++) {
599  ChannelElement *che = ac->che[type][i];
600  if (che) {
601  for (j = 0; j <= 1; j++) {
602  memset(che->ch[j].saved, 0, sizeof(che->ch[j].saved));
603  }
604  }
605  }
606  }
607 }
608 
609 /**
610  * Set up channel positions based on a default channel configuration
611  * as specified in table 1.17.
612  *
613  * @return Returns error status. 0 - OK, !0 - error
614  */
615 static int set_default_channel_config(AACContext *ac, AVCodecContext *avctx,
616  uint8_t (*layout_map)[3],
617  int *tags,
618  int channel_config)
619 {
620  if (channel_config < 1 || (channel_config > 7 && channel_config < 11) ||
621  channel_config > 13) {
622  av_log(avctx, AV_LOG_ERROR,
623  "invalid default channel configuration (%d)\n",
624  channel_config);
625  return AVERROR_INVALIDDATA;
626  }
627  *tags = tags_per_config[channel_config];
628  memcpy(layout_map, aac_channel_layout_map[channel_config - 1],
629  *tags * sizeof(*layout_map));
630 
631  /*
632  * AAC specification has 7.1(wide) as a default layout for 8-channel streams.
633  * However, at least Nero AAC encoder encodes 7.1 streams using the default
634  * channel config 7, mapping the side channels of the original audio stream
635  * to the second AAC_CHANNEL_FRONT pair in the AAC stream. Similarly, e.g. FAAD
636  * decodes the second AAC_CHANNEL_FRONT pair as side channels, therefore decoding
637  * the incorrect streams as if they were correct (and as the encoder intended).
638  *
639  * As actual intended 7.1(wide) streams are very rare, default to assuming a
640  * 7.1 layout was intended.
641  */
642  if (channel_config == 7 && avctx->strict_std_compliance < FF_COMPLIANCE_STRICT && (!ac || !ac->warned_71_wide++)) {
643  av_log(avctx, AV_LOG_INFO, "Assuming an incorrectly encoded 7.1 channel layout"
644  " instead of a spec-compliant 7.1(wide) layout, use -strict %d to decode"
645  " according to the specification instead.\n", FF_COMPLIANCE_STRICT);
646  layout_map[2][2] = AAC_CHANNEL_SIDE;
647  }
648 
649  return 0;
650 }
651 
652 static ChannelElement *get_che(AACContext *ac, int type, int elem_id)
653 {
654  /* For PCE based channel configurations map the channels solely based
655  * on tags. */
656  if (!ac->oc[1].m4ac.chan_config) {
657  return ac->tag_che_map[type][elem_id];
658  }
659  // Allow single CPE stereo files to be signalled with mono configuration.
660  if (!ac->tags_mapped && type == TYPE_CPE &&
661  ac->oc[1].m4ac.chan_config == 1) {
662  uint8_t layout_map[MAX_ELEM_ID*4][3];
663  int layout_map_tags;
664  push_output_configuration(ac);
665 
666  av_log(ac->avctx, AV_LOG_DEBUG, "mono with CPE\n");
667 
668  if (set_default_channel_config(ac, ac->avctx, layout_map,
669  &layout_map_tags, 2) < 0)
670  return NULL;
671  if (output_configure(ac, layout_map, layout_map_tags,
672  OC_TRIAL_FRAME, 1) < 0)
673  return NULL;
674 
675  ac->oc[1].m4ac.chan_config = 2;
676  ac->oc[1].m4ac.ps = 0;
677  }
678  // And vice-versa
679  if (!ac->tags_mapped && type == TYPE_SCE &&
680  ac->oc[1].m4ac.chan_config == 2) {
681  uint8_t layout_map[MAX_ELEM_ID * 4][3];
682  int layout_map_tags;
683  push_output_configuration(ac);
684 
685  av_log(ac->avctx, AV_LOG_DEBUG, "stereo with SCE\n");
686 
687  if (set_default_channel_config(ac, ac->avctx, layout_map,
688  &layout_map_tags, 1) < 0)
689  return NULL;
690  if (output_configure(ac, layout_map, layout_map_tags,
691  OC_TRIAL_FRAME, 1) < 0)
692  return NULL;
693 
694  ac->oc[1].m4ac.chan_config = 1;
695  if (ac->oc[1].m4ac.sbr)
696  ac->oc[1].m4ac.ps = -1;
697  }
698  /* For indexed channel configurations map the channels solely based
699  * on position. */
700  switch (ac->oc[1].m4ac.chan_config) {
701  case 13:
702  if (ac->tags_mapped > 3 && ((type == TYPE_CPE && elem_id < 8) ||
703  (type == TYPE_SCE && elem_id < 6) ||
704  (type == TYPE_LFE && elem_id < 2))) {
705  ac->tags_mapped++;
706  return ac->tag_che_map[type][elem_id] = ac->che[type][elem_id];
707  }
708  case 12:
709  case 7:
710  if (ac->tags_mapped == 3 && type == TYPE_CPE) {
711  ac->tags_mapped++;
712  return ac->tag_che_map[TYPE_CPE][elem_id] = ac->che[TYPE_CPE][2];
713  }
714  case 11:
715  if (ac->tags_mapped == 2 &&
716  ac->oc[1].m4ac.chan_config == 11 &&
717  type == TYPE_SCE) {
718  ac->tags_mapped++;
719  return ac->tag_che_map[TYPE_SCE][elem_id] = ac->che[TYPE_SCE][1];
720  }
721  case 6:
722  /* Some streams incorrectly code 5.1 audio as
723  * SCE[0] CPE[0] CPE[1] SCE[1]
724  * instead of
725  * SCE[0] CPE[0] CPE[1] LFE[0].
726  * If we seem to have encountered such a stream, transfer
727  * the LFE[0] element to the SCE[1]'s mapping */
728  if (ac->tags_mapped == tags_per_config[ac->oc[1].m4ac.chan_config] - 1 && (type == TYPE_LFE || type == TYPE_SCE)) {
729  if (!ac->warned_remapping_once && (type != TYPE_LFE || elem_id != 0)) {
730  av_log(ac->avctx, AV_LOG_WARNING,
731  "This stream seems to incorrectly report its last channel as %s[%d], mapping to LFE[0]\n",
732  type == TYPE_SCE ? "SCE" : "LFE", elem_id);
733  ac->warned_remapping_once++;
734  }
735  ac->tags_mapped++;
736  return ac->tag_che_map[type][elem_id] = ac->che[TYPE_LFE][0];
737  }
738  case 5:
739  if (ac->tags_mapped == 2 && type == TYPE_CPE) {
740  ac->tags_mapped++;
741  return ac->tag_che_map[TYPE_CPE][elem_id] = ac->che[TYPE_CPE][1];
742  }
743  case 4:
744  /* Some streams incorrectly code 4.0 audio as
745  * SCE[0] CPE[0] LFE[0]
746  * instead of
747  * SCE[0] CPE[0] SCE[1].
748  * If we seem to have encountered such a stream, transfer
749  * the SCE[1] element to the LFE[0]'s mapping */
750  if (ac->tags_mapped == tags_per_config[ac->oc[1].m4ac.chan_config] - 1 && (type == TYPE_LFE || type == TYPE_SCE)) {
751  if (!ac->warned_remapping_once && (type != TYPE_SCE || elem_id != 1)) {
752  av_log(ac->avctx, AV_LOG_WARNING,
753  "This stream seems to incorrectly report its last channel as %s[%d], mapping to SCE[1]\n",
754  type == TYPE_SCE ? "SCE" : "LFE", elem_id);
755  ac->warned_remapping_once++;
756  }
757  ac->tags_mapped++;
758  return ac->tag_che_map[type][elem_id] = ac->che[TYPE_SCE][1];
759  }
760  if (ac->tags_mapped == 2 &&
761  ac->oc[1].m4ac.chan_config == 4 &&
762  type == TYPE_SCE) {
763  ac->tags_mapped++;
764  return ac->tag_che_map[TYPE_SCE][elem_id] = ac->che[TYPE_SCE][1];
765  }
766  case 3:
767  case 2:
768  if (ac->tags_mapped == (ac->oc[1].m4ac.chan_config != 2) &&
769  type == TYPE_CPE) {
770  ac->tags_mapped++;
771  return ac->tag_che_map[TYPE_CPE][elem_id] = ac->che[TYPE_CPE][0];
772  } else if (ac->oc[1].m4ac.chan_config == 2) {
773  return NULL;
774  }
775  case 1:
776  if (!ac->tags_mapped && type == TYPE_SCE) {
777  ac->tags_mapped++;
778  return ac->tag_che_map[TYPE_SCE][elem_id] = ac->che[TYPE_SCE][0];
779  }
780  default:
781  return NULL;
782  }
783 }
784 
785 /**
786  * Decode an array of 4 bit element IDs, optionally interleaved with a
787  * stereo/mono switching bit.
788  *
789  * @param type speaker type/position for these channels
790  */
791 static void decode_channel_map(uint8_t layout_map[][3],
792  enum ChannelPosition type,
793  GetBitContext *gb, int n)
794 {
795  while (n--) {
796  enum RawDataBlockType syn_ele;
797  switch (type) {
798  case AAC_CHANNEL_FRONT:
799  case AAC_CHANNEL_BACK:
800  case AAC_CHANNEL_SIDE:
801  syn_ele = get_bits1(gb);
802  break;
803  case AAC_CHANNEL_CC:
804  skip_bits1(gb);
805  syn_ele = TYPE_CCE;
806  break;
807  case AAC_CHANNEL_LFE:
808  syn_ele = TYPE_LFE;
809  break;
810  default:
811  // AAC_CHANNEL_OFF has no channel map
812  av_assert0(0);
813  }
814  layout_map[0][0] = syn_ele;
815  layout_map[0][1] = get_bits(gb, 4);
816  layout_map[0][2] = type;
817  layout_map++;
818  }
819 }
820 
821 static inline void relative_align_get_bits(GetBitContext *gb,
822  int reference_position) {
823  int n = (reference_position - get_bits_count(gb) & 7);
824  if (n)
825  skip_bits(gb, n);
826 }
827 
828 /**
829  * Decode program configuration element; reference: table 4.2.
830  *
831  * @return Returns error status. 0 - OK, !0 - error
832  */
833 static int decode_pce(AVCodecContext *avctx, MPEG4AudioConfig *m4ac,
834  uint8_t (*layout_map)[3],
835  GetBitContext *gb, int byte_align_ref)
836 {
837  int num_front, num_side, num_back, num_lfe, num_assoc_data, num_cc;
838  int sampling_index;
839  int comment_len;
840  int tags;
841 
842  skip_bits(gb, 2); // object_type
843 
844  sampling_index = get_bits(gb, 4);
845  if (m4ac->sampling_index != sampling_index)
846  av_log(avctx, AV_LOG_WARNING,
847  "Sample rate index in program config element does not "
848  "match the sample rate index configured by the container.\n");
849 
850  num_front = get_bits(gb, 4);
851  num_side = get_bits(gb, 4);
852  num_back = get_bits(gb, 4);
853  num_lfe = get_bits(gb, 2);
854  num_assoc_data = get_bits(gb, 3);
855  num_cc = get_bits(gb, 4);
856 
857  if (get_bits1(gb))
858  skip_bits(gb, 4); // mono_mixdown_tag
859  if (get_bits1(gb))
860  skip_bits(gb, 4); // stereo_mixdown_tag
861 
862  if (get_bits1(gb))
863  skip_bits(gb, 3); // mixdown_coeff_index and pseudo_surround
864 
865  if (get_bits_left(gb) < 5 * (num_front + num_side + num_back + num_cc) + 4 *(num_lfe + num_assoc_data + num_cc)) {
866  av_log(avctx, AV_LOG_ERROR, "decode_pce: " overread_err);
867  return -1;
868  }
869  decode_channel_map(layout_map , AAC_CHANNEL_FRONT, gb, num_front);
870  tags = num_front;
871  decode_channel_map(layout_map + tags, AAC_CHANNEL_SIDE, gb, num_side);
872  tags += num_side;
873  decode_channel_map(layout_map + tags, AAC_CHANNEL_BACK, gb, num_back);
874  tags += num_back;
875  decode_channel_map(layout_map + tags, AAC_CHANNEL_LFE, gb, num_lfe);
876  tags += num_lfe;
877 
878  skip_bits_long(gb, 4 * num_assoc_data);
879 
880  decode_channel_map(layout_map + tags, AAC_CHANNEL_CC, gb, num_cc);
881  tags += num_cc;
882 
883  relative_align_get_bits(gb, byte_align_ref);
884 
885  /* comment field, first byte is length */
886  comment_len = get_bits(gb, 8) * 8;
887  if (get_bits_left(gb) < comment_len) {
888  av_log(avctx, AV_LOG_ERROR, "decode_pce: " overread_err);
889  return AVERROR_INVALIDDATA;
890  }
891  skip_bits_long(gb, comment_len);
892  return tags;
893 }
894 
895 /**
896  * Decode GA "General Audio" specific configuration; reference: table 4.1.
897  *
898  * @param ac pointer to AACContext, may be null
899  * @param avctx pointer to AVCCodecContext, used for logging
900  *
901  * @return Returns error status. 0 - OK, !0 - error
902  */
903 static int decode_ga_specific_config(AACContext *ac, AVCodecContext *avctx,
904  GetBitContext *gb,
905  int get_bit_alignment,
906  MPEG4AudioConfig *m4ac,
907  int channel_config)
908 {
909  int extension_flag, ret, ep_config, res_flags;
910  uint8_t layout_map[MAX_ELEM_ID*4][3];
911  int tags = 0;
912 
913 #if USE_FIXED
914  if (get_bits1(gb)) { // frameLengthFlag
915  avpriv_report_missing_feature(avctx, "Fixed point 960/120 MDCT window");
916  return AVERROR_PATCHWELCOME;
917  }
918  m4ac->frame_length_short = 0;
919 #else
920  m4ac->frame_length_short = get_bits1(gb);
921  if (m4ac->frame_length_short && m4ac->sbr == 1) {
922  avpriv_report_missing_feature(avctx, "SBR with 960 frame length");
923  if (ac) ac->warned_960_sbr = 1;
924  m4ac->sbr = 0;
925  m4ac->ps = 0;
926  }
927 #endif
928 
929  if (get_bits1(gb)) // dependsOnCoreCoder
930  skip_bits(gb, 14); // coreCoderDelay
931  extension_flag = get_bits1(gb);
932 
933  if (m4ac->object_type == AOT_AAC_SCALABLE ||
934  m4ac->object_type == AOT_ER_AAC_SCALABLE)
935  skip_bits(gb, 3); // layerNr
936 
937  if (channel_config == 0) {
938  skip_bits(gb, 4); // element_instance_tag
939  tags = decode_pce(avctx, m4ac, layout_map, gb, get_bit_alignment);
940  if (tags < 0)
941  return tags;
942  } else {
943  if ((ret = set_default_channel_config(ac, avctx, layout_map,
944  &tags, channel_config)))
945  return ret;
946  }
947 
948  if (count_channels(layout_map, tags) > 1) {
949  m4ac->ps = 0;
950  } else if (m4ac->sbr == 1 && m4ac->ps == -1)
951  m4ac->ps = 1;
952 
953  if (ac && (ret = output_configure(ac, layout_map, tags, OC_GLOBAL_HDR, 0)))
954  return ret;
955 
956  if (extension_flag) {
957  switch (m4ac->object_type) {
958  case AOT_ER_BSAC:
959  skip_bits(gb, 5); // numOfSubFrame
960  skip_bits(gb, 11); // layer_length
961  break;
962  case AOT_ER_AAC_LC:
963  case AOT_ER_AAC_LTP:
964  case AOT_ER_AAC_SCALABLE:
965  case AOT_ER_AAC_LD:
966  res_flags = get_bits(gb, 3);
967  if (res_flags) {
968  avpriv_report_missing_feature(avctx,
969  "AAC data resilience (flags %x)",
970  res_flags);
971  return AVERROR_PATCHWELCOME;
972  }
973  break;
974  }
975  skip_bits1(gb); // extensionFlag3 (TBD in version 3)
976  }
977  switch (m4ac->object_type) {
978  case AOT_ER_AAC_LC:
979  case AOT_ER_AAC_LTP:
980  case AOT_ER_AAC_SCALABLE:
981  case AOT_ER_AAC_LD:
982  ep_config = get_bits(gb, 2);
983  if (ep_config) {
984  avpriv_report_missing_feature(avctx,
985  "epConfig %d", ep_config);
986  return AVERROR_PATCHWELCOME;
987  }
988  }
989  return 0;
990 }
991 
992 static int decode_eld_specific_config(AACContext *ac, AVCodecContext *avctx,
993  GetBitContext *gb,
994  MPEG4AudioConfig *m4ac,
995  int channel_config)
996 {
997  int ret, ep_config, res_flags;
998  uint8_t layout_map[MAX_ELEM_ID*4][3];
999  int tags = 0;
1000  const int ELDEXT_TERM = 0;
1001 
1002  m4ac->ps = 0;
1003  m4ac->sbr = 0;
1004 #if USE_FIXED
1005  if (get_bits1(gb)) { // frameLengthFlag
1006  avpriv_request_sample(avctx, "960/120 MDCT window");
1007  return AVERROR_PATCHWELCOME;
1008  }
1009 #else
1010  m4ac->frame_length_short = get_bits1(gb);
1011 #endif
1012  res_flags = get_bits(gb, 3);
1013  if (res_flags) {
1014  avpriv_report_missing_feature(avctx,
1015  "AAC data resilience (flags %x)",
1016  res_flags);
1017  return AVERROR_PATCHWELCOME;
1018  }
1019 
1020  if (get_bits1(gb)) { // ldSbrPresentFlag
1021  avpriv_report_missing_feature(avctx,
1022  "Low Delay SBR");
1023  return AVERROR_PATCHWELCOME;
1024  }
1025 
1026  while (get_bits(gb, 4) != ELDEXT_TERM) {
1027  int len = get_bits(gb, 4);
1028  if (len == 15)
1029  len += get_bits(gb, 8);
1030  if (len == 15 + 255)
1031  len += get_bits(gb, 16);
1032  if (get_bits_left(gb) < len * 8 + 4) {
1033  av_log(avctx, AV_LOG_ERROR, overread_err);
1034  return AVERROR_INVALIDDATA;
1035  }
1036  skip_bits_long(gb, 8 * len);
1037  }
1038 
1039  if ((ret = set_default_channel_config(ac, avctx, layout_map,
1040  &tags, channel_config)))
1041  return ret;
1042 
1043  if (ac && (ret = output_configure(ac, layout_map, tags, OC_GLOBAL_HDR, 0)))
1044  return ret;
1045 
1046  ep_config = get_bits(gb, 2);
1047  if (ep_config) {
1048  avpriv_report_missing_feature(avctx,
1049  "epConfig %d", ep_config);
1050  return AVERROR_PATCHWELCOME;
1051  }
1052  return 0;
1053 }
1054 
1055 /**
1056  * Decode audio specific configuration; reference: table 1.13.
1057  *
1058  * @param ac pointer to AACContext, may be null
1059  * @param avctx pointer to AVCCodecContext, used for logging
1060  * @param m4ac pointer to MPEG4AudioConfig, used for parsing
1061  * @param gb buffer holding an audio specific config
1062  * @param get_bit_alignment relative alignment for byte align operations
1063  * @param sync_extension look for an appended sync extension
1064  *
1065  * @return Returns error status or number of consumed bits. <0 - error
1066  */
1067 static int decode_audio_specific_config_gb(AACContext *ac,
1068  AVCodecContext *avctx,
1069  MPEG4AudioConfig *m4ac,
1070  GetBitContext *gb,
1071  int get_bit_alignment,
1072  int sync_extension)
1073 {
1074  int i, ret;
1075  GetBitContext gbc = *gb;
1076 
1077  if ((i = ff_mpeg4audio_get_config_gb(m4ac, &gbc, sync_extension, avctx)) < 0)
1078  return AVERROR_INVALIDDATA;
1079 
1080  if (m4ac->sampling_index > 12) {
1081  av_log(avctx, AV_LOG_ERROR,
1082  "invalid sampling rate index %d\n",
1083  m4ac->sampling_index);
1084  return AVERROR_INVALIDDATA;
1085  }
1086  if (m4ac->object_type == AOT_ER_AAC_LD &&
1087  (m4ac->sampling_index < 3 || m4ac->sampling_index > 7)) {
1088  av_log(avctx, AV_LOG_ERROR,
1089  "invalid low delay sampling rate index %d\n",
1090  m4ac->sampling_index);
1091  return AVERROR_INVALIDDATA;
1092  }
1093 
1094  skip_bits_long(gb, i);
1095 
1096  switch (m4ac->object_type) {
1097  case AOT_AAC_MAIN:
1098  case AOT_AAC_LC:
1099  case AOT_AAC_SSR:
1100  case AOT_AAC_LTP:
1101  case AOT_ER_AAC_LC:
1102  case AOT_ER_AAC_LD:
1103  if ((ret = decode_ga_specific_config(ac, avctx, gb, get_bit_alignment,
1104  m4ac, m4ac->chan_config)) < 0)
1105  return ret;
1106  break;
1107  case AOT_ER_AAC_ELD:
1108  if ((ret = decode_eld_specific_config(ac, avctx, gb,
1109  m4ac, m4ac->chan_config)) < 0)
1110  return ret;
1111  break;
1112  default:
1113  avpriv_report_missing_feature(avctx,
1114  "Audio object type %s%d",
1115  m4ac->sbr == 1 ? "SBR+" : "",
1116  m4ac->object_type);
1117  return AVERROR(ENOSYS);
1118  }
1119 
1120  ff_dlog(avctx,
1121  "AOT %d chan config %d sampling index %d (%d) SBR %d PS %d\n",
1122  m4ac->object_type, m4ac->chan_config, m4ac->sampling_index,
1123  m4ac->sample_rate, m4ac->sbr,
1124  m4ac->ps);
1125 
1126  return get_bits_count(gb);
1127 }
1128 
1129 static int decode_audio_specific_config(AACContext *ac,
1130  AVCodecContext *avctx,
1131  MPEG4AudioConfig *m4ac,
1132  const uint8_t *data, int64_t bit_size,
1133  int sync_extension)
1134 {
1135  int i, ret;
1136  GetBitContext gb;
1137 
1138  if (bit_size < 0 || bit_size > INT_MAX) {
1139  av_log(avctx, AV_LOG_ERROR, "Audio specific config size is invalid\n");
1140  return AVERROR_INVALIDDATA;
1141  }
1142 
1143  ff_dlog(avctx, "audio specific config size %d\n", (int)bit_size >> 3);
1144  for (i = 0; i < bit_size >> 3; i++)
1145  ff_dlog(avctx, "%02x ", data[i]);
1146  ff_dlog(avctx, "\n");
1147 
1148  if ((ret = init_get_bits(&gb, data, bit_size)) < 0)
1149  return ret;
1150 
1151  return decode_audio_specific_config_gb(ac, avctx, m4ac, &gb, 0,
1152  sync_extension);
1153 }
1154 
1155 /**
1156  * linear congruential pseudorandom number generator
1157  *
1158  * @param previous_val pointer to the current state of the generator
1159  *
1160  * @return Returns a 32-bit pseudorandom integer
1161  */
1162 static av_always_inline int lcg_random(unsigned previous_val)
1163 {
1164  union { unsigned u; int s; } v = { previous_val * 1664525u + 1013904223 };
1165  return v.s;
1166 }
1167 
1168 static void reset_all_predictors(PredictorState *ps)
1169 {
1170  int i;
1171  for (i = 0; i < MAX_PREDICTORS; i++)
1172  reset_predict_state(&ps[i]);
1173 }
1174 
1175 static int sample_rate_idx (int rate)
1176 {
1177  if (92017 <= rate) return 0;
1178  else if (75132 <= rate) return 1;
1179  else if (55426 <= rate) return 2;
1180  else if (46009 <= rate) return 3;
1181  else if (37566 <= rate) return 4;
1182  else if (27713 <= rate) return 5;
1183  else if (23004 <= rate) return 6;
1184  else if (18783 <= rate) return 7;
1185  else if (13856 <= rate) return 8;
1186  else if (11502 <= rate) return 9;
1187  else if (9391 <= rate) return 10;
1188  else return 11;
1189 }
1190 
1191 static void reset_predictor_group(PredictorState *ps, int group_num)
1192 {
1193  int i;
1194  for (i = group_num - 1; i < MAX_PREDICTORS; i += 30)
1195  reset_predict_state(&ps[i]);
1196 }
1197 
1198 static void aacdec_init(AACContext *ac);
1199 
1200 static av_cold void aac_static_table_init(void)
1201 {
1202  static VLC_TYPE vlc_buf[304 + 270 + 550 + 300 + 328 +
1203  294 + 306 + 268 + 510 + 366 + 462][2];
1204  for (unsigned i = 0, offset = 0; i < 11; i++) {
1205  vlc_spectral[i].table = &vlc_buf[offset];
1206  vlc_spectral[i].table_allocated = FF_ARRAY_ELEMS(vlc_buf) - offset;
1207  ff_init_vlc_sparse(&vlc_spectral[i], 8, ff_aac_spectral_sizes[i],
1208  ff_aac_spectral_bits[i], sizeof(ff_aac_spectral_bits[i][0]),
1209  sizeof(ff_aac_spectral_bits[i][0]),
1210  ff_aac_spectral_codes[i], sizeof(ff_aac_spectral_codes[i][0]),
1211  sizeof(ff_aac_spectral_codes[i][0]),
1212  ff_aac_codebook_vector_idx[i], sizeof(ff_aac_codebook_vector_idx[i][0]),
1213  sizeof(ff_aac_codebook_vector_idx[i][0]),
1214  INIT_VLC_STATIC_OVERLONG);
1215  offset += vlc_spectral[i].table_size;
1216  }
1217 
1218  AAC_RENAME(ff_aac_sbr_init)();
1219 
1220  ff_aac_tableinit();
1221 
1222  INIT_VLC_STATIC(&vlc_scalefactors, 7,
1223  FF_ARRAY_ELEMS(ff_aac_scalefactor_code),
1224  ff_aac_scalefactor_bits,
1225  sizeof(ff_aac_scalefactor_bits[0]),
1226  sizeof(ff_aac_scalefactor_bits[0]),
1227  ff_aac_scalefactor_code,
1228  sizeof(ff_aac_scalefactor_code[0]),
1229  sizeof(ff_aac_scalefactor_code[0]),
1230  352);
1231 
1232  // window initialization
1233 #if !USE_FIXED
1234  AAC_RENAME(ff_kbd_window_init)(AAC_RENAME(aac_kbd_long_960), 4.0, 960);
1235  AAC_RENAME(ff_kbd_window_init)(AAC_RENAME(aac_kbd_short_120), 6.0, 120);
1236  AAC_RENAME(ff_sine_window_init)(AAC_RENAME(sine_960), 960);
1237  AAC_RENAME(ff_sine_window_init)(AAC_RENAME(sine_120), 120);
1238  ff_aac_float_common_init();
1239 #else
1240  AAC_RENAME(ff_kbd_window_init)(AAC_KBD_RENAME(kbd_long_1024), 4.0, 1024);
1241  AAC_RENAME(ff_kbd_window_init)(AAC_KBD_RENAME(kbd_short_128), 6.0, 128);
1242  AAC_RENAME(ff_init_ff_sine_windows)(10);
1243  AAC_RENAME(ff_init_ff_sine_windows)( 7);
1244 #endif
1245  AAC_RENAME(ff_init_ff_sine_windows)( 9);
1246 
1247  AAC_RENAME(ff_cbrt_tableinit)();
1248 }
1249 
1250 static AVOnce aac_table_init = AV_ONCE_INIT;
1251 
1252 static av_cold int aac_decode_init(AVCodecContext *avctx)
1253 {
1254  AACContext *ac = avctx->priv_data;
1255  int ret;
1256 
1257  if (avctx->sample_rate > 96000)
1258  return AVERROR_INVALIDDATA;
1259 
1260  ret = ff_thread_once(&aac_table_init, &aac_static_table_init);
1261  if (ret != 0)
1262  return AVERROR_UNKNOWN;
1263 
1264  ac->avctx = avctx;
1265  ac->oc[1].m4ac.sample_rate = avctx->sample_rate;
1266 
1267  aacdec_init(ac);
1268 #if USE_FIXED
1269  avctx->sample_fmt = AV_SAMPLE_FMT_S32P;
1270 #else
1271  avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;
1272 #endif /* USE_FIXED */
1273 
1274  if (avctx->extradata_size > 0) {
1275  if ((ret = decode_audio_specific_config(ac, ac->avctx, &ac->oc[1].m4ac,
1276  avctx->extradata,
1277  avctx->extradata_size * 8LL,
1278  1)) < 0)
1279  return ret;
1280  } else {
1281  int sr, i;
1282  uint8_t layout_map[MAX_ELEM_ID*4][3];
1283  int layout_map_tags;
1284 
1285  sr = sample_rate_idx(avctx->sample_rate);
1286  ac->oc[1].m4ac.sampling_index = sr;
1287  ac->oc[1].m4ac.channels = avctx->channels;
1288  ac->oc[1].m4ac.sbr = -1;
1289  ac->oc[1].m4ac.ps = -1;
1290 
1291  for (i = 0; i < FF_ARRAY_ELEMS(ff_mpeg4audio_channels); i++)
1292  if (ff_mpeg4audio_channels[i] == avctx->channels)
1293  break;
1294  if (i == FF_ARRAY_ELEMS(ff_mpeg4audio_channels)) {
1295  i = 0;
1296  }
1297  ac->oc[1].m4ac.chan_config = i;
1298 
1299  if (ac->oc[1].m4ac.chan_config) {
1300  int ret = set_default_channel_config(ac, avctx, layout_map,
1301  &layout_map_tags, ac->oc[1].m4ac.chan_config);
1302  if (!ret)
1303  output_configure(ac, layout_map, layout_map_tags,
1304  OC_GLOBAL_HDR, 0);
1305  else if (avctx->err_recognition & AV_EF_EXPLODE)
1306  return AVERROR_INVALIDDATA;
1307  }
1308  }
1309 
1310  if (avctx->channels > MAX_CHANNELS) {
1311  av_log(avctx, AV_LOG_ERROR, "Too many channels\n");
1312  return AVERROR_INVALIDDATA;
1313  }
1314 
1315 #if USE_FIXED
1316  ac->fdsp = avpriv_alloc_fixed_dsp(avctx->flags & AV_CODEC_FLAG_BITEXACT);
1317 #else
1318  ac->fdsp = avpriv_float_dsp_alloc(avctx->flags & AV_CODEC_FLAG_BITEXACT);
1319 #endif /* USE_FIXED */
1320  if (!ac->fdsp) {
1321  return AVERROR(ENOMEM);
1322  }
1323 
1324  ac->random_state = 0x1f2e3d4c;
1325 
1326  AAC_RENAME_32(ff_mdct_init)(&ac->mdct, 11, 1, 1.0 / RANGE15(1024.0));
1327  AAC_RENAME_32(ff_mdct_init)(&ac->mdct_ld, 10, 1, 1.0 / RANGE15(512.0));
1328  AAC_RENAME_32(ff_mdct_init)(&ac->mdct_small, 8, 1, 1.0 / RANGE15(128.0));
1329  AAC_RENAME_32(ff_mdct_init)(&ac->mdct_ltp, 11, 0, RANGE15(-2.0));
1330 #if !USE_FIXED
1331  ret = ff_mdct15_init(&ac->mdct120, 1, 3, 1.0f/(16*1024*120*2));
1332  if (ret < 0)
1333  return ret;
1334  ret = ff_mdct15_init(&ac->mdct480, 1, 5, 1.0f/(16*1024*960));
1335  if (ret < 0)
1336  return ret;
1337  ret = ff_mdct15_init(&ac->mdct960, 1, 6, 1.0f/(16*1024*960*2));
1338  if (ret < 0)
1339  return ret;
1340 #endif
1341 
1342  return 0;
1343 }
1344 
1345 /**
1346  * Skip data_stream_element; reference: table 4.10.
1347  */
1348 static int skip_data_stream_element(AACContext *ac, GetBitContext *gb)
1349 {
1350  int byte_align = get_bits1(gb);
1351  int count = get_bits(gb, 8);
1352  if (count == 255)
1353  count += get_bits(gb, 8);
1354  if (byte_align)
1355  align_get_bits(gb);
1356 
1357  if (get_bits_left(gb) < 8 * count) {
1358  av_log(ac->avctx, AV_LOG_ERROR, "skip_data_stream_element: "overread_err);
1359  return AVERROR_INVALIDDATA;
1360  }
1361  skip_bits_long(gb, 8 * count);
1362  return 0;
1363 }
1364 
1365 static int decode_prediction(AACContext *ac, IndividualChannelStream *ics,
1366  GetBitContext *gb)
1367 {
1368  int sfb;
1369  if (get_bits1(gb)) {
1370  ics->predictor_reset_group = get_bits(gb, 5);
1371  if (ics->predictor_reset_group == 0 ||
1372  ics->predictor_reset_group > 30) {
1373  av_log(ac->avctx, AV_LOG_ERROR,
1374  "Invalid Predictor Reset Group.\n");
1375  return AVERROR_INVALIDDATA;
1376  }
1377  }
1378  for (sfb = 0; sfb < FFMIN(ics->max_sfb, ff_aac_pred_sfb_max[ac->oc[1].m4ac.sampling_index]); sfb++) {
1379  ics->prediction_used[sfb] = get_bits1(gb);
1380  }
1381  return 0;
1382 }
1383 
1384 /**
1385  * Decode Long Term Prediction data; reference: table 4.xx.
1386  */
1387 static void decode_ltp(LongTermPrediction *ltp,
1388  GetBitContext *gb, uint8_t max_sfb)
1389 {
1390  int sfb;
1391 
1392  ltp->lag = get_bits(gb, 11);
1393  ltp->coef = ltp_coef[get_bits(gb, 3)];
1394  for (sfb = 0; sfb < FFMIN(max_sfb, MAX_LTP_LONG_SFB); sfb++)
1395  ltp->used[sfb] = get_bits1(gb);
1396 }
1397 
1398 /**
1399  * Decode Individual Channel Stream info; reference: table 4.6.
1400  */
1401 static int decode_ics_info(AACContext *ac, IndividualChannelStream *ics,
1402  GetBitContext *gb)
1403 {
1404  const MPEG4AudioConfig *const m4ac = &ac->oc[1].m4ac;
1405  const int aot = m4ac->object_type;
1406  const int sampling_index = m4ac->sampling_index;
1407  int ret_fail = AVERROR_INVALIDDATA;
1408 
1409  if (aot != AOT_ER_AAC_ELD) {
1410  if (get_bits1(gb)) {
1411  av_log(ac->avctx, AV_LOG_ERROR, "Reserved bit set.\n");
1412  if (ac->avctx->err_recognition & AV_EF_BITSTREAM)
1413  return AVERROR_INVALIDDATA;
1414  }
1415  ics->window_sequence[1] = ics->window_sequence[0];
1416  ics->window_sequence[0] = get_bits(gb, 2);
1417  if (aot == AOT_ER_AAC_LD &&
1418  ics->window_sequence[0] != ONLY_LONG_SEQUENCE) {
1419  av_log(ac->avctx, AV_LOG_ERROR,
1420  "AAC LD is only defined for ONLY_LONG_SEQUENCE but "
1421  "window sequence %d found.\n", ics->window_sequence[0]);
1422  ics->window_sequence[0] = ONLY_LONG_SEQUENCE;
1423  return AVERROR_INVALIDDATA;
1424  }
1425  ics->use_kb_window[1] = ics->use_kb_window[0];
1426  ics->use_kb_window[0] = get_bits1(gb);
1427  }
1428  ics->num_window_groups = 1;
1429  ics->group_len[0] = 1;
1430  if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) {
1431  int i;
1432  ics->max_sfb = get_bits(gb, 4);
1433  for (i = 0; i < 7; i++) {
1434  if (get_bits1(gb)) {
1435  ics->group_len[ics->num_window_groups - 1]++;
1436  } else {
1437  ics->num_window_groups++;
1438  ics->group_len[ics->num_window_groups - 1] = 1;
1439  }
1440  }
1441  ics->num_windows = 8;
1442  if (m4ac->frame_length_short) {
1443  ics->swb_offset = ff_swb_offset_120[sampling_index];
1444  ics->num_swb = ff_aac_num_swb_120[sampling_index];
1445  } else {
1446  ics->swb_offset = ff_swb_offset_128[sampling_index];
1447  ics->num_swb = ff_aac_num_swb_128[sampling_index];
1448  }
1449  ics->tns_max_bands = ff_tns_max_bands_128[sampling_index];
1450  ics->predictor_present = 0;
1451  } else {
1452  ics->max_sfb = get_bits(gb, 6);
1453  ics->num_windows = 1;
1454  if (aot == AOT_ER_AAC_LD || aot == AOT_ER_AAC_ELD) {
1455  if (m4ac->frame_length_short) {
1456  ics->swb_offset = ff_swb_offset_480[sampling_index];
1457  ics->num_swb = ff_aac_num_swb_480[sampling_index];
1458  ics->tns_max_bands = ff_tns_max_bands_480[sampling_index];
1459  } else {
1460  ics->swb_offset = ff_swb_offset_512[sampling_index];
1461  ics->num_swb = ff_aac_num_swb_512[sampling_index];
1462  ics->tns_max_bands = ff_tns_max_bands_512[sampling_index];
1463  }
1464  if (!ics->num_swb || !ics->swb_offset) {
1465  ret_fail = AVERROR_BUG;
1466  goto fail;
1467  }
1468  } else {
1469  if (m4ac->frame_length_short) {
1470  ics->num_swb = ff_aac_num_swb_960[sampling_index];
1471  ics->swb_offset = ff_swb_offset_960[sampling_index];
1472  } else {
1473  ics->num_swb = ff_aac_num_swb_1024[sampling_index];
1474  ics->swb_offset = ff_swb_offset_1024[sampling_index];
1475  }
1476  ics->tns_max_bands = ff_tns_max_bands_1024[sampling_index];
1477  }
1478  if (aot != AOT_ER_AAC_ELD) {
1479  ics->predictor_present = get_bits1(gb);
1480  ics->predictor_reset_group = 0;
1481  }
1482  if (ics->predictor_present) {
1483  if (aot == AOT_AAC_MAIN) {
1484  if (decode_prediction(ac, ics, gb)) {
1485  goto fail;
1486  }
1487  } else if (aot == AOT_AAC_LC ||
1488  aot == AOT_ER_AAC_LC) {
1489  av_log(ac->avctx, AV_LOG_ERROR,
1490  "Prediction is not allowed in AAC-LC.\n");
1491  goto fail;
1492  } else {
1493  if (aot == AOT_ER_AAC_LD) {
1494  av_log(ac->avctx, AV_LOG_ERROR,
1495  "LTP in ER AAC LD not yet implemented.\n");
1496  ret_fail = AVERROR_PATCHWELCOME;
1497  goto fail;
1498  }
1499  if ((ics->ltp.present = get_bits(gb, 1)))
1500  decode_ltp(&ics->ltp, gb, ics->max_sfb);
1501  }
1502  }
1503  }
1504 
1505  if (ics->max_sfb > ics->num_swb) {
1506  av_log(ac->avctx, AV_LOG_ERROR,
1507  "Number of scalefactor bands in group (%d) "
1508  "exceeds limit (%d).\n",
1509  ics->max_sfb, ics->num_swb);
1510  goto fail;
1511  }
1512 
1513  return 0;
1514 fail:
1515  ics->max_sfb = 0;
1516  return ret_fail;
1517 }
1518 
1519 /**
1520  * Decode band types (section_data payload); reference: table 4.46.
1521  *
1522  * @param band_type array of the used band type
1523  * @param band_type_run_end array of the last scalefactor band of a band type run
1524  *
1525  * @return Returns error status. 0 - OK, !0 - error
1526  */
1527 static int decode_band_types(AACContext *ac, enum BandType band_type[120],
1528  int band_type_run_end[120], GetBitContext *gb,
1529  IndividualChannelStream *ics)
1530 {
1531  int g, idx = 0;
1532  const int bits = (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) ? 3 : 5;
1533  for (g = 0; g < ics->num_window_groups; g++) {
1534  int k = 0;
1535  while (k < ics->max_sfb) {
1536  uint8_t sect_end = k;
1537  int sect_len_incr;
1538  int sect_band_type = get_bits(gb, 4);
1539  if (sect_band_type == 12) {
1540  av_log(ac->avctx, AV_LOG_ERROR, "invalid band type\n");
1541  return AVERROR_INVALIDDATA;
1542  }
1543  do {
1544  sect_len_incr = get_bits(gb, bits);
1545  sect_end += sect_len_incr;
1546  if (get_bits_left(gb) < 0) {
1547  av_log(ac->avctx, AV_LOG_ERROR, "decode_band_types: "overread_err);
1548  return AVERROR_INVALIDDATA;
1549  }
1550  if (sect_end > ics->max_sfb) {
1551  av_log(ac->avctx, AV_LOG_ERROR,
1552  "Number of bands (%d) exceeds limit (%d).\n",
1553  sect_end, ics->max_sfb);
1554  return AVERROR_INVALIDDATA;
1555  }
1556  } while (sect_len_incr == (1 << bits) - 1);
1557  for (; k < sect_end; k++) {
1558  band_type [idx] = sect_band_type;
1559  band_type_run_end[idx++] = sect_end;
1560  }
1561  }
1562  }
1563  return 0;
1564 }
1565 
1566 /**
1567  * Decode scalefactors; reference: table 4.47.
1568  *
1569  * @param global_gain first scalefactor value as scalefactors are differentially coded
1570  * @param band_type array of the used band type
1571  * @param band_type_run_end array of the last scalefactor band of a band type run
1572  * @param sf array of scalefactors or intensity stereo positions
1573  *
1574  * @return Returns error status. 0 - OK, !0 - error
1575  */
1576 static int decode_scalefactors(AACContext *ac, INTFLOAT sf[120], GetBitContext *gb,
1577  unsigned int global_gain,
1578  IndividualChannelStream *ics,
1579  enum BandType band_type[120],
1580  int band_type_run_end[120])
1581 {
1582  int g, i, idx = 0;
1583  int offset[3] = { global_gain, global_gain - NOISE_OFFSET, 0 };
1584  int clipped_offset;
1585  int noise_flag = 1;
1586  for (g = 0; g < ics->num_window_groups; g++) {
1587  for (i = 0; i < ics->max_sfb;) {
1588  int run_end = band_type_run_end[idx];
1589  if (band_type[idx] == ZERO_BT) {
1590  for (; i < run_end; i++, idx++)
1591  sf[idx] = FIXR(0.);
1592  } else if ((band_type[idx] == INTENSITY_BT) ||
1593  (band_type[idx] == INTENSITY_BT2)) {
1594  for (; i < run_end; i++, idx++) {
1595  offset[2] += get_vlc2(gb, vlc_scalefactors.table, 7, 3) - SCALE_DIFF_ZERO;
1596  clipped_offset = av_clip(offset[2], -155, 100);
1597  if (offset[2] != clipped_offset) {
1598  avpriv_request_sample(ac->avctx,
1599  "If you heard an audible artifact, there may be a bug in the decoder. "
1600  "Clipped intensity stereo position (%d -> %d)",
1601  offset[2], clipped_offset);
1602  }
1603 #if USE_FIXED
1604  sf[idx] = 100 - clipped_offset;
1605 #else
1606  sf[idx] = ff_aac_pow2sf_tab[-clipped_offset + POW_SF2_ZERO];
1607 #endif /* USE_FIXED */
1608  }
1609  } else if (band_type[idx] == NOISE_BT) {
1610  for (; i < run_end; i++, idx++) {
1611  if (noise_flag-- > 0)
1612  offset[1] += get_bits(gb, NOISE_PRE_BITS) - NOISE_PRE;
1613  else
1614  offset[1] += get_vlc2(gb, vlc_scalefactors.table, 7, 3) - SCALE_DIFF_ZERO;
1615  clipped_offset = av_clip(offset[1], -100, 155);
1616  if (offset[1] != clipped_offset) {
1617  avpriv_request_sample(ac->avctx,
1618  "If you heard an audible artifact, there may be a bug in the decoder. "
1619  "Clipped noise gain (%d -> %d)",
1620  offset[1], clipped_offset);
1621  }
1622 #if USE_FIXED
1623  sf[idx] = -(100 + clipped_offset);
1624 #else
1625  sf[idx] = -ff_aac_pow2sf_tab[clipped_offset + POW_SF2_ZERO];
1626 #endif /* USE_FIXED */
1627  }
1628  } else {
1629  for (; i < run_end; i++, idx++) {
1630  offset[0] += get_vlc2(gb, vlc_scalefactors.table, 7, 3) - SCALE_DIFF_ZERO;
1631  if (offset[0] > 255U) {
1632  av_log(ac->avctx, AV_LOG_ERROR,
1633  "Scalefactor (%d) out of range.\n", offset[0]);
1634  return AVERROR_INVALIDDATA;
1635  }
1636 #if USE_FIXED
1637  sf[idx] = -offset[0];
1638 #else
1639  sf[idx] = -ff_aac_pow2sf_tab[offset[0] - 100 + POW_SF2_ZERO];
1640 #endif /* USE_FIXED */
1641  }
1642  }
1643  }
1644  }
1645  return 0;
1646 }
1647 
1648 /**
1649  * Decode pulse data; reference: table 4.7.
1650  */
1651 static int decode_pulses(Pulse *pulse, GetBitContext *gb,
1652  const uint16_t *swb_offset, int num_swb)
1653 {
1654  int i, pulse_swb;
1655  pulse->num_pulse = get_bits(gb, 2) + 1;
1656  pulse_swb = get_bits(gb, 6);
1657  if (pulse_swb >= num_swb)
1658  return -1;
1659  pulse->pos[0] = swb_offset[pulse_swb];
1660  pulse->pos[0] += get_bits(gb, 5);
1661  if (pulse->pos[0] >= swb_offset[num_swb])
1662  return -1;
1663  pulse->amp[0] = get_bits(gb, 4);
1664  for (i = 1; i < pulse->num_pulse; i++) {
1665  pulse->pos[i] = get_bits(gb, 5) + pulse->pos[i - 1];
1666  if (pulse->pos[i] >= swb_offset[num_swb])
1667  return -1;
1668  pulse->amp[i] = get_bits(gb, 4);
1669  }
1670  return 0;
1671 }
1672 
1673 /**
1674  * Decode Temporal Noise Shaping data; reference: table 4.48.
1675  *
1676  * @return Returns error status. 0 - OK, !0 - error
1677  */
1678 static int decode_tns(AACContext *ac, TemporalNoiseShaping *tns,
1679  GetBitContext *gb, const IndividualChannelStream *ics)
1680 {
1681  int w, filt, i, coef_len, coef_res, coef_compress;
1682  const int is8 = ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE;
1683  const int tns_max_order = is8 ? 7 : ac->oc[1].m4ac.object_type == AOT_AAC_MAIN ? 20 : 12;
1684  for (w = 0; w < ics->num_windows; w++) {
1685  if ((tns->n_filt[w] = get_bits(gb, 2 - is8))) {
1686  coef_res = get_bits1(gb);
1687 
1688  for (filt = 0; filt < tns->n_filt[w]; filt++) {
1689  int tmp2_idx;
1690  tns->length[w][filt] = get_bits(gb, 6 - 2 * is8);
1691 
1692  if ((tns->order[w][filt] = get_bits(gb, 5 - 2 * is8)) > tns_max_order) {
1693  av_log(ac->avctx, AV_LOG_ERROR,
1694  "TNS filter order %d is greater than maximum %d.\n",
1695  tns->order[w][filt], tns_max_order);
1696  tns->order[w][filt] = 0;
1697  return AVERROR_INVALIDDATA;
1698  }
1699  if (tns->order[w][filt]) {
1700  tns->direction[w][filt] = get_bits1(gb);
1701  coef_compress = get_bits1(gb);
1702  coef_len = coef_res + 3 - coef_compress;
1703  tmp2_idx = 2 * coef_compress + coef_res;
1704 
1705  for (i = 0; i < tns->order[w][filt]; i++)
1706  tns->coef[w][filt][i] = tns_tmp2_map[tmp2_idx][get_bits(gb, coef_len)];
1707  }
1708  }
1709  }
1710  }
1711  return 0;
1712 }
1713 
1714 /**
1715  * Decode Mid/Side data; reference: table 4.54.
1716  *
1717  * @param ms_present Indicates mid/side stereo presence. [0] mask is all 0s;
1718  * [1] mask is decoded from bitstream; [2] mask is all 1s;
1719  * [3] reserved for scalable AAC
1720  */
1721 static void decode_mid_side_stereo(ChannelElement *cpe, GetBitContext *gb,
1722  int ms_present)
1723 {
1724  int idx;
1725  int max_idx = cpe->ch[0].ics.num_window_groups * cpe->ch[0].ics.max_sfb;
1726  if (ms_present == 1) {
1727  for (idx = 0; idx < max_idx; idx++)
1728  cpe->ms_mask[idx] = get_bits1(gb);
1729  } else if (ms_present == 2) {
1730  memset(cpe->ms_mask, 1, max_idx * sizeof(cpe->ms_mask[0]));
1731  }
1732 }
1733 
1734 /**
1735  * Decode spectral data; reference: table 4.50.
1736  * Dequantize and scale spectral data; reference: 4.6.3.3.
1737  *
1738  * @param coef array of dequantized, scaled spectral data
1739  * @param sf array of scalefactors or intensity stereo positions
1740  * @param pulse_present set if pulses are present
1741  * @param pulse pointer to pulse data struct
1742  * @param band_type array of the used band type
1743  *
1744  * @return Returns error status. 0 - OK, !0 - error
1745  */
1746 static int decode_spectrum_and_dequant(AACContext *ac, INTFLOAT coef[1024],
1747  GetBitContext *gb, const INTFLOAT sf[120],
1748  int pulse_present, const Pulse *pulse,
1749  const IndividualChannelStream *ics,
1750  enum BandType band_type[120])
1751 {
1752  int i, k, g, idx = 0;
1753  const int c = 1024 / ics->num_windows;
1754  const uint16_t *offsets = ics->swb_offset;
1755  INTFLOAT *coef_base = coef;
1756 
1757  for (g = 0; g < ics->num_windows; g++)
1758  memset(coef + g * 128 + offsets[ics->max_sfb], 0,
1759  sizeof(INTFLOAT) * (c - offsets[ics->max_sfb]));
1760 
1761  for (g = 0; g < ics->num_window_groups; g++) {
1762  unsigned g_len = ics->group_len[g];
1763 
1764  for (i = 0; i < ics->max_sfb; i++, idx++) {
1765  const unsigned cbt_m1 = band_type[idx] - 1;
1766  INTFLOAT *cfo = coef + offsets[i];
1767  int off_len = offsets[i + 1] - offsets[i];
1768  int group;
1769 
1770  if (cbt_m1 >= INTENSITY_BT2 - 1) {
1771  for (group = 0; group < (AAC_SIGNE)g_len; group++, cfo+=128) {
1772  memset(cfo, 0, off_len * sizeof(*cfo));
1773  }
1774  } else if (cbt_m1 == NOISE_BT - 1) {
1775  for (group = 0; group < (AAC_SIGNE)g_len; group++, cfo+=128) {
1776  INTFLOAT band_energy;
1777 #if USE_FIXED
1778  for (k = 0; k < off_len; k++) {
1779  ac->random_state = lcg_random(ac->random_state);
1780  cfo[k] = ac->random_state >> 3;
1781  }
1782 
1783  band_energy = ac->fdsp->scalarproduct_fixed(cfo, cfo, off_len);
1784  band_energy = fixed_sqrt(band_energy, 31);
1785  noise_scale(cfo, sf[idx], band_energy, off_len);
1786 #else
1787  float scale;
1788 
1789  for (k = 0; k < off_len; k++) {
1790  ac->random_state = lcg_random(ac->random_state);
1791  cfo[k] = ac->random_state;
1792  }
1793 
1794  band_energy = ac->fdsp->scalarproduct_float(cfo, cfo, off_len);
1795  scale = sf[idx] / sqrtf(band_energy);
1796  ac->fdsp->vector_fmul_scalar(cfo, cfo, scale, off_len);
1797 #endif /* USE_FIXED */
1798  }
1799  } else {
1800 #if !USE_FIXED
1801  const float *vq = ff_aac_codebook_vector_vals[cbt_m1];
1802 #endif /* !USE_FIXED */
1803  VLC_TYPE (*vlc_tab)[2] = vlc_spectral[cbt_m1].table;
1804  OPEN_READER(re, gb);
1805 
1806  switch (cbt_m1 >> 1) {
1807  case 0:
1808  for (group = 0; group < (AAC_SIGNE)g_len; group++, cfo+=128) {
1809  INTFLOAT *cf = cfo;
1810  int len = off_len;
1811 
1812  do {
1813  int code;
1814  unsigned cb_idx;
1815 
1816  UPDATE_CACHE(re, gb);
1817  GET_VLC(code, re, gb, vlc_tab, 8, 2);
1818  cb_idx = code;
1819 #if USE_FIXED
1820  cf = DEC_SQUAD(cf, cb_idx);
1821 #else
1822  cf = VMUL4(cf, vq, cb_idx, sf + idx);
1823 #endif /* USE_FIXED */
1824  } while (len -= 4);
1825  }
1826  break;
1827 
1828  case 1:
1829  for (group = 0; group < (AAC_SIGNE)g_len; group++, cfo+=128) {
1830  INTFLOAT *cf = cfo;
1831  int len = off_len;
1832 
1833  do {
1834  int code;
1835  unsigned nnz;
1836  unsigned cb_idx;
1837  uint32_t bits;
1838 
1839  UPDATE_CACHE(re, gb);
1840  GET_VLC(code, re, gb, vlc_tab, 8, 2);
1841  cb_idx = code;
1842  nnz = cb_idx >> 8 & 15;
1843  bits = nnz ? GET_CACHE(re, gb) : 0;
1844  LAST_SKIP_BITS(re, gb, nnz);
1845 #if USE_FIXED
1846  cf = DEC_UQUAD(cf, cb_idx, bits);
1847 #else
1848  cf = VMUL4S(cf, vq, cb_idx, bits, sf + idx);
1849 #endif /* USE_FIXED */
1850  } while (len -= 4);
1851  }
1852  break;
1853 
1854  case 2:
1855  for (group = 0; group < (AAC_SIGNE)g_len; group++, cfo+=128) {
1856  INTFLOAT *cf = cfo;
1857  int len = off_len;
1858 
1859  do {
1860  int code;
1861  unsigned cb_idx;
1862 
1863  UPDATE_CACHE(re, gb);
1864  GET_VLC(code, re, gb, vlc_tab, 8, 2);
1865  cb_idx = code;
1866 #if USE_FIXED
1867  cf = DEC_SPAIR(cf, cb_idx);
1868 #else
1869  cf = VMUL2(cf, vq, cb_idx, sf + idx);
1870 #endif /* USE_FIXED */
1871  } while (len -= 2);
1872  }
1873  break;
1874 
1875  case 3:
1876  case 4:
1877  for (group = 0; group < (AAC_SIGNE)g_len; group++, cfo+=128) {
1878  INTFLOAT *cf = cfo;
1879  int len = off_len;
1880 
1881  do {
1882  int code;
1883  unsigned nnz;
1884  unsigned cb_idx;
1885  unsigned sign;
1886 
1887  UPDATE_CACHE(re, gb);
1888  GET_VLC(code, re, gb, vlc_tab, 8, 2);
1889  cb_idx = code;
1890  nnz = cb_idx >> 8 & 15;
1891  sign = nnz ? SHOW_UBITS(re, gb, nnz) << (cb_idx >> 12) : 0;
1892  LAST_SKIP_BITS(re, gb, nnz);
1893 #if USE_FIXED
1894  cf = DEC_UPAIR(cf, cb_idx, sign);
1895 #else
1896  cf = VMUL2S(cf, vq, cb_idx, sign, sf + idx);
1897 #endif /* USE_FIXED */
1898  } while (len -= 2);
1899  }
1900  break;
1901 
1902  default:
1903  for (group = 0; group < (AAC_SIGNE)g_len; group++, cfo+=128) {
1904 #if USE_FIXED
1905  int *icf = cfo;
1906  int v;
1907 #else
1908  float *cf = cfo;
1909  uint32_t *icf = (uint32_t *) cf;
1910 #endif /* USE_FIXED */
1911  int len = off_len;
1912 
1913  do {
1914  int code;
1915  unsigned nzt, nnz;
1916  unsigned cb_idx;
1917  uint32_t bits;
1918  int j;
1919 
1920  UPDATE_CACHE(re, gb);
1921  GET_VLC(code, re, gb, vlc_tab, 8, 2);
1922  cb_idx = code;
1923 
1924  if (cb_idx == 0x0000) {
1925  *icf++ = 0;
1926  *icf++ = 0;
1927  continue;
1928  }
1929 
1930  nnz = cb_idx >> 12;
1931  nzt = cb_idx >> 8;
1932  bits = SHOW_UBITS(re, gb, nnz) << (32-nnz);
1933  LAST_SKIP_BITS(re, gb, nnz);
1934 
1935  for (j = 0; j < 2; j++) {
1936  if (nzt & 1<<j) {
1937  uint32_t b;
1938  int n;
1939  /* The total length of escape_sequence must be < 22 bits according
1940  to the specification (i.e. max is 111111110xxxxxxxxxxxx). */
1941  UPDATE_CACHE(re, gb);
1942  b = GET_CACHE(re, gb);
1943  b = 31 - av_log2(~b);
1944 
1945  if (b > 8) {
1946  av_log(ac->avctx, AV_LOG_ERROR, "error in spectral data, ESC overflow\n");
1947  return AVERROR_INVALIDDATA;
1948  }
1949 
1950  SKIP_BITS(re, gb, b + 1);
1951  b += 4;
1952  n = (1 << b) + SHOW_UBITS(re, gb, b);
1953  LAST_SKIP_BITS(re, gb, b);
1954 #if USE_FIXED
1955  v = n;
1956  if (bits & 1U<<31)
1957  v = -v;
1958  *icf++ = v;
1959 #else
1960  *icf++ = ff_cbrt_tab[n] | (bits & 1U<<31);
1961 #endif /* USE_FIXED */
1962  bits <<= 1;
1963  } else {
1964 #if USE_FIXED
1965  v = cb_idx & 15;
1966  if (bits & 1U<<31)
1967  v = -v;
1968  *icf++ = v;
1969 #else
1970  unsigned v = ((const uint32_t*)vq)[cb_idx & 15];
1971  *icf++ = (bits & 1U<<31) | v;
1972 #endif /* USE_FIXED */
1973  bits <<= !!v;
1974  }
1975  cb_idx >>= 4;
1976  }
1977  } while (len -= 2);
1978 #if !USE_FIXED
1979  ac->fdsp->vector_fmul_scalar(cfo, cfo, sf[idx], off_len);
1980 #endif /* !USE_FIXED */
1981  }
1982  }
1983 
1984  CLOSE_READER(re, gb);
1985  }
1986  }
1987  coef += g_len << 7;
1988  }
1989 
1990  if (pulse_present) {
1991  idx = 0;
1992  for (i = 0; i < pulse->num_pulse; i++) {
1993  INTFLOAT co = coef_base[ pulse->pos[i] ];
1994  while (offsets[idx + 1] <= pulse->pos[i])
1995  idx++;
1996  if (band_type[idx] != NOISE_BT && sf[idx]) {
1997  INTFLOAT ico = -pulse->amp[i];
1998 #if USE_FIXED
1999  if (co) {
2000  ico = co + (co > 0 ? -ico : ico);
2001  }
2002  coef_base[ pulse->pos[i] ] = ico;
2003 #else
2004  if (co) {
2005  co /= sf[idx];
2006  ico = co / sqrtf(sqrtf(fabsf(co))) + (co > 0 ? -ico : ico);
2007  }
2008  coef_base[ pulse->pos[i] ] = cbrtf(fabsf(ico)) * ico * sf[idx];
2009 #endif /* USE_FIXED */
2010  }
2011  }
2012  }
2013 #if USE_FIXED
2014  coef = coef_base;
2015  idx = 0;
2016  for (g = 0; g < ics->num_window_groups; g++) {
2017  unsigned g_len = ics->group_len[g];
2018 
2019  for (i = 0; i < ics->max_sfb; i++, idx++) {
2020  const unsigned cbt_m1 = band_type[idx] - 1;
2021  int *cfo = coef + offsets[i];
2022  int off_len = offsets[i + 1] - offsets[i];
2023  int group;
2024 
2025  if (cbt_m1 < NOISE_BT - 1) {
2026  for (group = 0; group < (int)g_len; group++, cfo+=128) {
2027  ac->vector_pow43(cfo, off_len);
2028  ac->subband_scale(cfo, cfo, sf[idx], 34, off_len, ac->avctx);
2029  }
2030  }
2031  }
2032  coef += g_len << 7;
2033  }
2034 #endif /* USE_FIXED */
2035  return 0;
2036 }
2037 
2038 /**
2039  * Apply AAC-Main style frequency domain prediction.
2040  */
2041 static void apply_prediction(AACContext *ac, SingleChannelElement *sce)
2042 {
2043  int sfb, k;
2044 
2045  if (!sce->ics.predictor_initialized) {
2046  reset_all_predictors(sce->predictor_state);
2047  sce->ics.predictor_initialized = 1;
2048  }
2049 
2050  if (sce->ics.window_sequence[0] != EIGHT_SHORT_SEQUENCE) {
2051  for (sfb = 0;
2052  sfb < ff_aac_pred_sfb_max[ac->oc[1].m4ac.sampling_index];
2053  sfb++) {
2054  for (k = sce->ics.swb_offset[sfb];
2055  k < sce->ics.swb_offset[sfb + 1];
2056  k++) {
2057  predict(&sce->predictor_state[k], &sce->coeffs[k],
2058  sce->ics.predictor_present &&
2059  sce->ics.prediction_used[sfb]);
2060  }
2061  }
2062  if (sce->ics.predictor_reset_group)
2063  reset_predictor_group(sce->predictor_state,
2064  sce->ics.predictor_reset_group);
2065  } else
2066  reset_all_predictors(sce->predictor_state);
2067 }
2068 
2069 static void decode_gain_control(SingleChannelElement * sce, GetBitContext * gb)
2070 {
2071  // wd_num, wd_test, aloc_size
2072  static const uint8_t gain_mode[4][3] = {
2073  {1, 0, 5}, // ONLY_LONG_SEQUENCE = 0,
2074  {2, 1, 2}, // LONG_START_SEQUENCE,
2075  {8, 0, 2}, // EIGHT_SHORT_SEQUENCE,
2076  {2, 1, 5}, // LONG_STOP_SEQUENCE
2077  };
2078 
2079  const int mode = sce->ics.window_sequence[0];
2080  uint8_t bd, wd, ad;
2081 
2082  // FIXME: Store the gain control data on |sce| and do something with it.
2083  uint8_t max_band = get_bits(gb, 2);
2084  for (bd = 0; bd < max_band; bd++) {
2085  for (wd = 0; wd < gain_mode[mode][0]; wd++) {
2086  uint8_t adjust_num = get_bits(gb, 3);
2087  for (ad = 0; ad < adjust_num; ad++) {
2088  skip_bits(gb, 4 + ((wd == 0 && gain_mode[mode][1])
2089  ? 4
2090  : gain_mode[mode][2]));
2091  }
2092  }
2093  }
2094 }
2095 
2096 /**
2097  * Decode an individual_channel_stream payload; reference: table 4.44.
2098  *
2099  * @param common_window Channels have independent [0], or shared [1], Individual Channel Stream information.
2100  * @param scale_flag scalable [1] or non-scalable [0] AAC (Unused until scalable AAC is implemented.)
2101  *
2102  * @return Returns error status. 0 - OK, !0 - error
2103  */
2104 static int decode_ics(AACContext *ac, SingleChannelElement *sce,
2105  GetBitContext *gb, int common_window, int scale_flag)
2106 {
2107  Pulse pulse;
2108  TemporalNoiseShaping *tns = &sce->tns;
2109  IndividualChannelStream *ics = &sce->ics;
2110  INTFLOAT *out = sce->coeffs;
2111  int global_gain, eld_syntax, er_syntax, pulse_present = 0;
2112  int ret;
2113 
2114  eld_syntax = ac->oc[1].m4ac.object_type == AOT_ER_AAC_ELD;
2115  er_syntax = ac->oc[1].m4ac.object_type == AOT_ER_AAC_LC ||
2116  ac->oc[1].m4ac.object_type == AOT_ER_AAC_LTP ||
2117  ac->oc[1].m4ac.object_type == AOT_ER_AAC_LD ||
2118  ac->oc[1].m4ac.object_type == AOT_ER_AAC_ELD;
2119 
2120  /* This assignment is to silence a GCC warning about the variable being used
2121  * uninitialized when in fact it always is.
2122  */
2123  pulse.num_pulse = 0;
2124 
2125  global_gain = get_bits(gb, 8);
2126 
2127  if (!common_window && !scale_flag) {
2128  ret = decode_ics_info(ac, ics, gb);
2129  if (ret < 0)
2130  goto fail;
2131  }
2132 
2133  if ((ret = decode_band_types(ac, sce->band_type,
2134  sce->band_type_run_end, gb, ics)) < 0)
2135  goto fail;
2136  if ((ret = decode_scalefactors(ac, sce->sf, gb, global_gain, ics,
2137  sce->band_type, sce->band_type_run_end)) < 0)
2138  goto fail;
2139 
2140  pulse_present = 0;
2141  if (!scale_flag) {
2142  if (!eld_syntax && (pulse_present = get_bits1(gb))) {
2143  if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) {
2144  av_log(ac->avctx, AV_LOG_ERROR,
2145  "Pulse tool not allowed in eight short sequence.\n");
2146  ret = AVERROR_INVALIDDATA;
2147  goto fail;
2148  }
2149  if (decode_pulses(&pulse, gb, ics->swb_offset, ics->num_swb)) {
2150  av_log(ac->avctx, AV_LOG_ERROR,
2151  "Pulse data corrupt or invalid.\n");
2152  ret = AVERROR_INVALIDDATA;
2153  goto fail;
2154  }
2155  }
2156  tns->present = get_bits1(gb);
2157  if (tns->present && !er_syntax) {
2158  ret = decode_tns(ac, tns, gb, ics);
2159  if (ret < 0)
2160  goto fail;
2161  }
2162  if (!eld_syntax && get_bits1(gb)) {
2163  decode_gain_control(sce, gb);
2164  if (!ac->warned_gain_control) {
2165  avpriv_report_missing_feature(ac->avctx, "Gain control");
2166  ac->warned_gain_control = 1;
2167  }
2168  }
2169  // I see no textual basis in the spec for this occurring after SSR gain
2170  // control, but this is what both reference and real implmentations do
2171  if (tns->present && er_syntax) {
2172  ret = decode_tns(ac, tns, gb, ics);
2173  if (ret < 0)
2174  goto fail;
2175  }
2176  }
2177 
2178  ret = decode_spectrum_and_dequant(ac, out, gb, sce->sf, pulse_present,
2179  &pulse, ics, sce->band_type);
2180  if (ret < 0)
2181  goto fail;
2182 
2183  if (ac->oc[1].m4ac.object_type == AOT_AAC_MAIN && !common_window)
2184  apply_prediction(ac, sce);
2185 
2186  return 0;
2187 fail:
2188  tns->present = 0;
2189  return ret;
2190 }
2191 
2192 /**
2193  * Mid/Side stereo decoding; reference: 4.6.8.1.3.
2194  */
2195 static void apply_mid_side_stereo(AACContext *ac, ChannelElement *cpe)
2196 {
2197  const IndividualChannelStream *ics = &cpe->ch[0].ics;
2198  INTFLOAT *ch0 = cpe->ch[0].coeffs;
2199  INTFLOAT *ch1 = cpe->ch[1].coeffs;
2200  int g, i, group, idx = 0;
2201  const uint16_t *offsets = ics->swb_offset;
2202  for (g = 0; g < ics->num_window_groups; g++) {
2203  for (i = 0; i < ics->max_sfb; i++, idx++) {
2204  if (cpe->ms_mask[idx] &&
2205  cpe->ch[0].band_type[idx] < NOISE_BT &&
2206  cpe->ch[1].band_type[idx] < NOISE_BT) {
2207 #if USE_FIXED
2208  for (group = 0; group < ics->group_len[g]; group++) {
2209  ac->fdsp->butterflies_fixed(ch0 + group * 128 + offsets[i],
2210  ch1 + group * 128 + offsets[i],
2211  offsets[i+1] - offsets[i]);
2212 #else
2213  for (group = 0; group < ics->group_len[g]; group++) {
2214  ac->fdsp->butterflies_float(ch0 + group * 128 + offsets[i],
2215  ch1 + group * 128 + offsets[i],
2216  offsets[i+1] - offsets[i]);
2217 #endif /* USE_FIXED */
2218  }
2219  }
2220  }
2221  ch0 += ics->group_len[g] * 128;
2222  ch1 += ics->group_len[g] * 128;
2223  }
2224 }
2225 
2226 /**
2227  * intensity stereo decoding; reference: 4.6.8.2.3
2228  *
2229  * @param ms_present Indicates mid/side stereo presence. [0] mask is all 0s;
2230  * [1] mask is decoded from bitstream; [2] mask is all 1s;
2231  * [3] reserved for scalable AAC
2232  */
2233 static void apply_intensity_stereo(AACContext *ac,
2234  ChannelElement *cpe, int ms_present)
2235 {
2236  const IndividualChannelStream *ics = &cpe->ch[1].ics;
2237  SingleChannelElement *sce1 = &cpe->ch[1];
2238  INTFLOAT *coef0 = cpe->ch[0].coeffs, *coef1 = cpe->ch[1].coeffs;
2239  const uint16_t *offsets = ics->swb_offset;
2240  int g, group, i, idx = 0;
2241  int c;
2242  INTFLOAT scale;
2243  for (g = 0; g < ics->num_window_groups; g++) {
2244  for (i = 0; i < ics->max_sfb;) {
2245  if (sce1->band_type[idx] == INTENSITY_BT ||
2246  sce1->band_type[idx] == INTENSITY_BT2) {
2247  const int bt_run_end = sce1->band_type_run_end[idx];
2248  for (; i < bt_run_end; i++, idx++) {
2249  c = -1 + 2 * (sce1->band_type[idx] - 14);
2250  if (ms_present)
2251  c *= 1 - 2 * cpe->ms_mask[idx];
2252  scale = c * sce1->sf[idx];
2253  for (group = 0; group < ics->group_len[g]; group++)
2254 #if USE_FIXED
2255  ac->subband_scale(coef1 + group * 128 + offsets[i],
2256  coef0 + group * 128 + offsets[i],
2257  scale,
2258  23,
2259  offsets[i + 1] - offsets[i] ,ac->avctx);
2260 #else
2261  ac->fdsp->vector_fmul_scalar(coef1 + group * 128 + offsets[i],
2262  coef0 + group * 128 + offsets[i],
2263  scale,
2264  offsets[i + 1] - offsets[i]);
2265 #endif /* USE_FIXED */
2266  }
2267  } else {
2268  int bt_run_end = sce1->band_type_run_end[idx];
2269  idx += bt_run_end - i;
2270  i = bt_run_end;
2271  }
2272  }
2273  coef0 += ics->group_len[g] * 128;
2274  coef1 += ics->group_len[g] * 128;
2275  }
2276 }
2277 
2278 /**
2279  * Decode a channel_pair_element; reference: table 4.4.
2280  *
2281  * @return Returns error status. 0 - OK, !0 - error
2282  */
2283 static int decode_cpe(AACContext *ac, GetBitContext *gb, ChannelElement *cpe)
2284 {
2285  int i, ret, common_window, ms_present = 0;
2286  int eld_syntax = ac->oc[1].m4ac.object_type == AOT_ER_AAC_ELD;
2287 
2288  common_window = eld_syntax || get_bits1(gb);
2289  if (common_window) {
2290  if (decode_ics_info(ac, &cpe->ch[0].ics, gb))
2291  return AVERROR_INVALIDDATA;
2292  i = cpe->ch[1].ics.use_kb_window[0];
2293  cpe->ch[1].ics = cpe->ch[0].ics;
2294  cpe->ch[1].ics.use_kb_window[1] = i;
2295  if (cpe->ch[1].ics.predictor_present &&
2296  (ac->oc[1].m4ac.object_type != AOT_AAC_MAIN))
2297  if ((cpe->ch[1].ics.ltp.present = get_bits(gb, 1)))
2298  decode_ltp(&cpe->ch[1].ics.ltp, gb, cpe->ch[1].ics.max_sfb);
2299  ms_present = get_bits(gb, 2);
2300  if (ms_present == 3) {
2301  av_log(ac->avctx, AV_LOG_ERROR, "ms_present = 3 is reserved.\n");
2302  return AVERROR_INVALIDDATA;
2303  } else if (ms_present)
2304  decode_mid_side_stereo(cpe, gb, ms_present);
2305  }
2306  if ((ret = decode_ics(ac, &cpe->ch[0], gb, common_window, 0)))
2307  return ret;
2308  if ((ret = decode_ics(ac, &cpe->ch[1], gb, common_window, 0)))
2309  return ret;
2310 
2311  if (common_window) {
2312  if (ms_present)
2313  apply_mid_side_stereo(ac, cpe);
2314  if (ac->oc[1].m4ac.object_type == AOT_AAC_MAIN) {
2315  apply_prediction(ac, &cpe->ch[0]);
2316  apply_prediction(ac, &cpe->ch[1]);
2317  }
2318  }
2319 
2320  apply_intensity_stereo(ac, cpe, ms_present);
2321  return 0;
2322 }
2323 
2324 static const float cce_scale[] = {
2325  1.09050773266525765921, //2^(1/8)
2326  1.18920711500272106672, //2^(1/4)
2327  M_SQRT2,
2328  2,
2329 };
2330 
2331 /**
2332  * Decode coupling_channel_element; reference: table 4.8.
2333  *
2334  * @return Returns error status. 0 - OK, !0 - error
2335  */
2336 static int decode_cce(AACContext *ac, GetBitContext *gb, ChannelElement *che)
2337 {
2338  int num_gain = 0;
2339  int c, g, sfb, ret;
2340  int sign;
2341  INTFLOAT scale;
2342  SingleChannelElement *sce = &che->ch[0];
2343  ChannelCoupling *coup = &che->coup;
2344 
2345  coup->coupling_point = 2 * get_bits1(gb);
2346  coup->num_coupled = get_bits(gb, 3);
2347  for (c = 0; c <= coup->num_coupled; c++) {
2348  num_gain++;
2349  coup->type[c] = get_bits1(gb) ? TYPE_CPE : TYPE_SCE;
2350  coup->id_select[c] = get_bits(gb, 4);
2351  if (coup->type[c] == TYPE_CPE) {
2352  coup->ch_select[c] = get_bits(gb, 2);
2353  if (coup->ch_select[c] == 3)
2354  num_gain++;
2355  } else
2356  coup->ch_select[c] = 2;
2357  }
2358  coup->coupling_point += get_bits1(gb) || (coup->coupling_point >> 1);
2359 
2360  sign = get_bits(gb, 1);
2361 #if USE_FIXED
2362  scale = get_bits(gb, 2);
2363 #else
2364  scale = cce_scale[get_bits(gb, 2)];
2365 #endif
2366 
2367  if ((ret = decode_ics(ac, sce, gb, 0, 0)))
2368  return ret;
2369 
2370  for (c = 0; c < num_gain; c++) {
2371  int idx = 0;
2372  int cge = 1;
2373  int gain = 0;
2374  INTFLOAT gain_cache = FIXR10(1.);
2375  if (c) {
2376  cge = coup->coupling_point == AFTER_IMDCT ? 1 : get_bits1(gb);
2377  gain = cge ? get_vlc2(gb, vlc_scalefactors.table, 7, 3) - 60: 0;
2378  gain_cache = GET_GAIN(scale, gain);
2379 #if USE_FIXED
2380  if ((abs(gain_cache)-1024) >> 3 > 30)
2381  return AVERROR(ERANGE);
2382 #endif
2383  }
2384  if (coup->coupling_point == AFTER_IMDCT) {
2385  coup->gain[c][0] = gain_cache;
2386  } else {
2387  for (g = 0; g < sce->ics.num_window_groups; g++) {
2388  for (sfb = 0; sfb < sce->ics.max_sfb; sfb++, idx++) {
2389  if (sce->band_type[idx] != ZERO_BT) {
2390  if (!cge) {
2391  int t = get_vlc2(gb, vlc_scalefactors.table, 7, 3) - 60;
2392  if (t) {
2393  int s = 1;
2394  t = gain += t;
2395  if (sign) {
2396  s -= 2 * (t & 0x1);
2397  t >>= 1;
2398  }
2399  gain_cache = GET_GAIN(scale, t) * s;
2400 #if USE_FIXED
2401  if ((abs(gain_cache)-1024) >> 3 > 30)
2402  return AVERROR(ERANGE);
2403 #endif
2404  }
2405  }
2406  coup->gain[c][idx] = gain_cache;
2407  }
2408  }
2409  }
2410  }
2411  }
2412  return 0;
2413 }
2414 
2415 /**
2416  * Parse whether channels are to be excluded from Dynamic Range Compression; reference: table 4.53.
2417  *
2418  * @return Returns number of bytes consumed.
2419  */
2420 static int decode_drc_channel_exclusions(DynamicRangeControl *che_drc,
2421  GetBitContext *gb)
2422 {
2423  int i;
2424  int num_excl_chan = 0;
2425 
2426  do {
2427  for (i = 0; i < 7; i++)
2428  che_drc->exclude_mask[num_excl_chan++] = get_bits1(gb);
2429  } while (num_excl_chan < MAX_CHANNELS - 7 && get_bits1(gb));
2430 
2431  return num_excl_chan / 7;
2432 }
2433 
2434 /**
2435  * Decode dynamic range information; reference: table 4.52.
2436  *
2437  * @return Returns number of bytes consumed.
2438  */
2439 static int decode_dynamic_range(DynamicRangeControl *che_drc,
2440  GetBitContext *gb)
2441 {
2442  int n = 1;
2443  int drc_num_bands = 1;
2444  int i;
2445 
2446  /* pce_tag_present? */
2447  if (get_bits1(gb)) {
2448  che_drc->pce_instance_tag = get_bits(gb, 4);
2449  skip_bits(gb, 4); // tag_reserved_bits
2450  n++;
2451  }
2452 
2453  /* excluded_chns_present? */
2454  if (get_bits1(gb)) {
2455  n += decode_drc_channel_exclusions(che_drc, gb);
2456  }
2457 
2458  /* drc_bands_present? */
2459  if (get_bits1(gb)) {
2460  che_drc->band_incr = get_bits(gb, 4);
2461  che_drc->interpolation_scheme = get_bits(gb, 4);
2462  n++;
2463  drc_num_bands += che_drc->band_incr;
2464  for (i = 0; i < drc_num_bands; i++) {
2465  che_drc->band_top[i] = get_bits(gb, 8);
2466  n++;
2467  }
2468  }
2469 
2470  /* prog_ref_level_present? */
2471  if (get_bits1(gb)) {
2472  che_drc->prog_ref_level = get_bits(gb, 7);
2473  skip_bits1(gb); // prog_ref_level_reserved_bits
2474  n++;
2475  }
2476 
2477  for (i = 0; i < drc_num_bands; i++) {
2478  che_drc->dyn_rng_sgn[i] = get_bits1(gb);
2479  che_drc->dyn_rng_ctl[i] = get_bits(gb, 7);
2480  n++;
2481  }
2482 
2483  return n;
2484 }
2485 
2486 static int decode_fill(AACContext *ac, GetBitContext *gb, int len) {
2487  uint8_t buf[256];
2488  int i, major, minor;
2489 
2490  if (len < 13+7*8)
2491  goto unknown;
2492 
2493  get_bits(gb, 13); len -= 13;
2494 
2495  for(i=0; i+1<sizeof(buf) && len>=8; i++, len-=8)
2496  buf[i] = get_bits(gb, 8);
2497 
2498  buf[i] = 0;
2499  if (ac->avctx->debug & FF_DEBUG_PICT_INFO)
2500  av_log(ac->avctx, AV_LOG_DEBUG, "FILL:%s\n", buf);
2501 
2502  if (sscanf(buf, "libfaac %d.%d", &major, &minor) == 2){
2503  ac->avctx->internal->skip_samples = 1024;
2504  }
2505 
2506 unknown:
2507  skip_bits_long(gb, len);
2508 
2509  return 0;
2510 }
2511 
2512 /**
2513  * Decode extension data (incomplete); reference: table 4.51.
2514  *
2515  * @param cnt length of TYPE_FIL syntactic element in bytes
2516  *
2517  * @return Returns number of bytes consumed
2518  */
2519 static int decode_extension_payload(AACContext *ac, GetBitContext *gb, int cnt,
2520  ChannelElement *che, enum RawDataBlockType elem_type)
2521 {
2522  int crc_flag = 0;
2523  int res = cnt;
2524  int type = get_bits(gb, 4);
2525 
2526  if (ac->avctx->debug & FF_DEBUG_STARTCODE)
2527  av_log(ac->avctx, AV_LOG_DEBUG, "extension type: %d len:%d\n", type, cnt);
2528 
2529  switch (type) { // extension type
2530  case EXT_SBR_DATA_CRC:
2531  crc_flag++;
2532  case EXT_SBR_DATA:
2533  if (!che) {
2534  av_log(ac->avctx, AV_LOG_ERROR, "SBR was found before the first channel element.\n");
2535  return res;
2536  } else if (ac->oc[1].m4ac.frame_length_short) {
2537  if (!ac->warned_960_sbr)
2538  avpriv_report_missing_feature(ac->avctx,
2539  "SBR with 960 frame length");
2540  ac->warned_960_sbr = 1;
2541  skip_bits_long(gb, 8 * cnt - 4);
2542  return res;
2543  } else if (!ac->oc[1].m4ac.sbr) {
2544  av_log(ac->avctx, AV_LOG_ERROR, "SBR signaled to be not-present but was found in the bitstream.\n");
2545  skip_bits_long(gb, 8 * cnt - 4);
2546  return res;
2547  } else if (ac->oc[1].m4ac.sbr == -1 && ac->oc[1].status == OC_LOCKED) {
2548  av_log(ac->avctx, AV_LOG_ERROR, "Implicit SBR was found with a first occurrence after the first frame.\n");
2549  skip_bits_long(gb, 8 * cnt - 4);
2550  return res;
2551  } else if (ac->oc[1].m4ac.ps == -1 && ac->oc[1].status < OC_LOCKED && ac->avctx->channels == 1) {
2552  ac->oc[1].m4ac.sbr = 1;
2553  ac->oc[1].m4ac.ps = 1;
2554  ac->avctx->profile = FF_PROFILE_AAC_HE_V2;
2555  output_configure(ac, ac->oc[1].layout_map, ac->oc[1].layout_map_tags,
2556  ac->oc[1].status, 1);
2557  } else {
2558  ac->oc[1].m4ac.sbr = 1;
2559  ac->avctx->profile = FF_PROFILE_AAC_HE;
2560  }
2561  res = AAC_RENAME(ff_decode_sbr_extension)(ac, &che->sbr, gb, crc_flag, cnt, elem_type);
2562  break;
2563  case EXT_DYNAMIC_RANGE:
2564  res = decode_dynamic_range(&ac->che_drc, gb);
2565  break;
2566  case EXT_FILL:
2567  decode_fill(ac, gb, 8 * cnt - 4);
2568  break;
2569  case EXT_FILL_DATA:
2570  case EXT_DATA_ELEMENT:
2571  default:
2572  skip_bits_long(gb, 8 * cnt - 4);
2573  break;
2574  };
2575  return res;
2576 }
2577 
2578 /**
2579  * Decode Temporal Noise Shaping filter coefficients and apply all-pole filters; reference: 4.6.9.3.
2580  *
2581  * @param decode 1 if tool is used normally, 0 if tool is used in LTP.
2582  * @param coef spectral coefficients
2583  */
2584 static void apply_tns(INTFLOAT coef_param[1024], TemporalNoiseShaping *tns,
2585  IndividualChannelStream *ics, int decode)
2586 {
2587  const int mmm = FFMIN(ics->tns_max_bands, ics->max_sfb);
2588  int w, filt, m, i;
2589  int bottom, top, order, start, end, size, inc;
2590  INTFLOAT lpc[TNS_MAX_ORDER];
2591  INTFLOAT tmp[TNS_MAX_ORDER+1];
2592  UINTFLOAT *coef = coef_param;
2593 
2594  if(!mmm)
2595  return;
2596 
2597  for (w = 0; w < ics->num_windows; w++) {
2598  bottom = ics->num_swb;
2599  for (filt = 0; filt < tns->n_filt[w]; filt++) {
2600  top = bottom;
2601  bottom = FFMAX(0, top - tns->length[w][filt]);
2602  order = tns->order[w][filt];
2603  if (order == 0)
2604  continue;
2605 
2606  // tns_decode_coef
2607  AAC_RENAME(compute_lpc_coefs)(tns->coef[w][filt], order, lpc, 0, 0, 0);
2608 
2609  start = ics->swb_offset[FFMIN(bottom, mmm)];
2610  end = ics->swb_offset[FFMIN( top, mmm)];
2611  if ((size = end - start) <= 0)
2612  continue;
2613  if (tns->direction[w][filt]) {
2614  inc = -1;
2615  start = end - 1;
2616  } else {
2617  inc = 1;
2618  }
2619  start += w * 128;
2620 
2621  if (decode) {
2622  // ar filter
2623  for (m = 0; m < size; m++, start += inc)
2624  for (i = 1; i <= FFMIN(m, order); i++)
2625  coef[start] -= AAC_MUL26((INTFLOAT)coef[start - i * inc], lpc[i - 1]);
2626  } else {
2627  // ma filter
2628  for (m = 0; m < size; m++, start += inc) {
2629  tmp[0] = coef[start];
2630  for (i = 1; i <= FFMIN(m, order); i++)
2631  coef[start] += AAC_MUL26(tmp[i], lpc[i - 1]);
2632  for (i = order; i > 0; i--)
2633  tmp[i] = tmp[i - 1];
2634  }
2635  }
2636  }
2637  }
2638 }
2639 
2640 /**
2641  * Apply windowing and MDCT to obtain the spectral
2642  * coefficient from the predicted sample by LTP.
2643  */
2644 static void windowing_and_mdct_ltp(AACContext *ac, INTFLOAT *out,
2645  INTFLOAT *in, IndividualChannelStream *ics)
2646 {
2647  const INTFLOAT *lwindow = ics->use_kb_window[0] ? AAC_KBD_RENAME(kbd_long_1024) : AAC_RENAME(ff_sine_1024);
2648  const INTFLOAT *swindow = ics->use_kb_window[0] ? AAC_KBD_RENAME(kbd_short_128) : AAC_RENAME(ff_sine_128);
2649  const INTFLOAT *lwindow_prev = ics->use_kb_window[1] ? AAC_KBD_RENAME(kbd_long_1024) : AAC_RENAME(ff_sine_1024);
2650  const INTFLOAT *swindow_prev = ics->use_kb_window[1] ? AAC_KBD_RENAME(kbd_short_128) : AAC_RENAME(ff_sine_128);
2651 
2652  if (ics->window_sequence[0] != LONG_STOP_SEQUENCE) {
2653  ac->fdsp->vector_fmul(in, in, lwindow_prev, 1024);
2654  } else {
2655  memset(in, 0, 448 * sizeof(*in));
2656  ac->fdsp->vector_fmul(in + 448, in + 448, swindow_prev, 128);
2657  }
2658  if (ics->window_sequence[0] != LONG_START_SEQUENCE) {
2659  ac->fdsp->vector_fmul_reverse(in + 1024, in + 1024, lwindow, 1024);
2660  } else {
2661  ac->fdsp->vector_fmul_reverse(in + 1024 + 448, in + 1024 + 448, swindow, 128);
2662  memset(in + 1024 + 576, 0, 448 * sizeof(*in));
2663  }
2664  ac->mdct_ltp.mdct_calc(&ac->mdct_ltp, out, in);
2665 }
2666 
2667 /**
2668  * Apply the long term prediction
2669  */
2670 static void apply_ltp(AACContext *ac, SingleChannelElement *sce)
2671 {
2672  const LongTermPrediction *ltp = &sce->ics.ltp;
2673  const uint16_t *offsets = sce->ics.swb_offset;
2674  int i, sfb;
2675 
2676  if (sce->ics.window_sequence[0] != EIGHT_SHORT_SEQUENCE) {
2677  INTFLOAT *predTime = sce->ret;
2678  INTFLOAT *predFreq = ac->buf_mdct;
2679  int16_t num_samples = 2048;
2680 
2681  if (ltp->lag < 1024)
2682  num_samples = ltp->lag + 1024;
2683  for (i = 0; i < num_samples; i++)
2684  predTime[i] = AAC_MUL30(sce->ltp_state[i + 2048 - ltp->lag], ltp->coef);
2685  memset(&predTime[i], 0, (2048 - i) * sizeof(*predTime));
2686 
2687  ac->windowing_and_mdct_ltp(ac, predFreq, predTime, &sce->ics);
2688 
2689  if (sce->tns.present)
2690  ac->apply_tns(predFreq, &sce->tns, &sce->ics, 0);
2691 
2692  for (sfb = 0; sfb < FFMIN(sce->ics.max_sfb, MAX_LTP_LONG_SFB); sfb++)
2693  if (ltp->used[sfb])
2694  for (i = offsets[sfb]; i < offsets[sfb + 1]; i++)
2695  sce->coeffs[i] += (UINTFLOAT)predFreq[i];
2696  }
2697 }
2698 
2699 /**
2700  * Update the LTP buffer for next frame
2701  */
2702 static void update_ltp(AACContext *ac, SingleChannelElement *sce)
2703 {
2704  IndividualChannelStream *ics = &sce->ics;
2705  INTFLOAT *saved = sce->saved;
2706  INTFLOAT *saved_ltp = sce->coeffs;
2707  const INTFLOAT *lwindow = ics->use_kb_window[0] ? AAC_KBD_RENAME(kbd_long_1024) : AAC_RENAME(ff_sine_1024);
2708  const INTFLOAT *swindow = ics->use_kb_window[0] ? AAC_KBD_RENAME(kbd_short_128) : AAC_RENAME(ff_sine_128);
2709  int i;
2710 
2711  if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) {
2712  memcpy(saved_ltp, saved, 512 * sizeof(*saved_ltp));
2713  memset(saved_ltp + 576, 0, 448 * sizeof(*saved_ltp));
2714  ac->fdsp->vector_fmul_reverse(saved_ltp + 448, ac->buf_mdct + 960, &swindow[64], 64);
2715 
2716  for (i = 0; i < 64; i++)
2717  saved_ltp[i + 512] = AAC_MUL31(ac->buf_mdct[1023 - i], swindow[63 - i]);
2718  } else if (ics->window_sequence[0] == LONG_START_SEQUENCE) {
2719  memcpy(saved_ltp, ac->buf_mdct + 512, 448 * sizeof(*saved_ltp));
2720  memset(saved_ltp + 576, 0, 448 * sizeof(*saved_ltp));
2721  ac->fdsp->vector_fmul_reverse(saved_ltp + 448, ac->buf_mdct + 960, &swindow[64], 64);
2722 
2723  for (i = 0; i < 64; i++)
2724  saved_ltp[i + 512] = AAC_MUL31(ac->buf_mdct[1023 - i], swindow[63 - i]);
2725  } else { // LONG_STOP or ONLY_LONG
2726  ac->fdsp->vector_fmul_reverse(saved_ltp, ac->buf_mdct + 512, &lwindow[512], 512);
2727 
2728  for (i = 0; i < 512; i++)
2729  saved_ltp[i + 512] = AAC_MUL31(ac->buf_mdct[1023 - i], lwindow[511 - i]);
2730  }
2731 
2732  memcpy(sce->ltp_state, sce->ltp_state+1024, 1024 * sizeof(*sce->ltp_state));
2733  memcpy(sce->ltp_state+1024, sce->ret, 1024 * sizeof(*sce->ltp_state));
2734  memcpy(sce->ltp_state+2048, saved_ltp, 1024 * sizeof(*sce->ltp_state));
2735 }
2736 
2737 /**
2738  * Conduct IMDCT and windowing.
2739  */
2740 static void imdct_and_windowing(AACContext *ac, SingleChannelElement *sce)
2741 {
2742  IndividualChannelStream *ics = &sce->ics;
2743  INTFLOAT *in = sce->coeffs;
2744  INTFLOAT *out = sce->ret;
2745  INTFLOAT *saved = sce->saved;
2746  const INTFLOAT *swindow = ics->use_kb_window[0] ? AAC_KBD_RENAME(kbd_short_128) : AAC_RENAME(ff_sine_128);
2747  const INTFLOAT *lwindow_prev = ics->use_kb_window[1] ? AAC_KBD_RENAME(kbd_long_1024) : AAC_RENAME(ff_sine_1024);
2748  const INTFLOAT *swindow_prev = ics->use_kb_window[1] ? AAC_KBD_RENAME(kbd_short_128) : AAC_RENAME(ff_sine_128);
2749  INTFLOAT *buf = ac->buf_mdct;
2750  INTFLOAT *temp = ac->temp;
2751  int i;
2752 
2753  // imdct
2754  if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) {
2755  for (i = 0; i < 1024; i += 128)
2756  ac->mdct_small.imdct_half(&ac->mdct_small, buf + i, in + i);
2757  } else {
2758  ac->mdct.imdct_half(&ac->mdct, buf, in);
2759 #if USE_FIXED
2760  for (i=0; i<1024; i++)
2761  buf[i] = (buf[i] + 4LL) >> 3;
2762 #endif /* USE_FIXED */
2763  }
2764 
2765  /* window overlapping
2766  * NOTE: To simplify the overlapping code, all 'meaningless' short to long
2767  * and long to short transitions are considered to be short to short
2768  * transitions. This leaves just two cases (long to long and short to short)
2769  * with a little special sauce for EIGHT_SHORT_SEQUENCE.
2770  */
2771  if ((ics->window_sequence[1] == ONLY_LONG_SEQUENCE || ics->window_sequence[1] == LONG_STOP_SEQUENCE) &&
2772  (ics->window_sequence[0] == ONLY_LONG_SEQUENCE || ics->window_sequence[0] == LONG_START_SEQUENCE)) {
2773  ac->fdsp->vector_fmul_window( out, saved, buf, lwindow_prev, 512);
2774  } else {
2775  memcpy( out, saved, 448 * sizeof(*out));
2776 
2777  if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) {
2778  ac->fdsp->vector_fmul_window(out + 448 + 0*128, saved + 448, buf + 0*128, swindow_prev, 64);
2779  ac->fdsp->vector_fmul_window(out + 448 + 1*128, buf + 0*128 + 64, buf + 1*128, swindow, 64);
2780  ac->fdsp->vector_fmul_window(out + 448 + 2*128, buf + 1*128 + 64, buf + 2*128, swindow, 64);
2781  ac->fdsp->vector_fmul_window(out + 448 + 3*128, buf + 2*128 + 64, buf + 3*128, swindow, 64);
2782  ac->fdsp->vector_fmul_window(temp, buf + 3*128 + 64, buf + 4*128, swindow, 64);
2783  memcpy( out + 448 + 4*128, temp, 64 * sizeof(*out));
2784  } else {
2785  ac->fdsp->vector_fmul_window(out + 448, saved + 448, buf, swindow_prev, 64);
2786  memcpy( out + 576, buf + 64, 448 * sizeof(*out));
2787  }
2788  }
2789 
2790  // buffer update
2791  if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) {
2792  memcpy( saved, temp + 64, 64 * sizeof(*saved));
2793  ac->fdsp->vector_fmul_window(saved + 64, buf + 4*128 + 64, buf + 5*128, swindow, 64);
2794  ac->fdsp->vector_fmul_window(saved + 192, buf + 5*128 + 64, buf + 6*128, swindow, 64);
2795  ac->fdsp->vector_fmul_window(saved + 320, buf + 6*128 + 64, buf + 7*128, swindow, 64);
2796  memcpy( saved + 448, buf + 7*128 + 64, 64 * sizeof(*saved));
2797  } else if (ics->window_sequence[0] == LONG_START_SEQUENCE) {
2798  memcpy( saved, buf + 512, 448 * sizeof(*saved));
2799  memcpy( saved + 448, buf + 7*128 + 64, 64 * sizeof(*saved));
2800  } else { // LONG_STOP or ONLY_LONG
2801  memcpy( saved, buf + 512, 512 * sizeof(*saved));
2802  }
2803 }
2804 
2805 /**
2806  * Conduct IMDCT and windowing.
2807  */
2808 static void imdct_and_windowing_960(AACContext *ac, SingleChannelElement *sce)
2809 {
2810 #if !USE_FIXED
2811  IndividualChannelStream *ics = &sce->ics;
2812  INTFLOAT *in = sce->coeffs;
2813  INTFLOAT *out = sce->ret;
2814  INTFLOAT *saved = sce->saved;
2815  const INTFLOAT *swindow = ics->use_kb_window[0] ? AAC_RENAME(aac_kbd_short_120) : AAC_RENAME(sine_120);
2816  const INTFLOAT *lwindow_prev = ics->use_kb_window[1] ? AAC_RENAME(aac_kbd_long_960) : AAC_RENAME(sine_960);
2817  const INTFLOAT *swindow_prev = ics->use_kb_window[1] ? AAC_RENAME(aac_kbd_short_120) : AAC_RENAME(sine_120);
2818  INTFLOAT *buf = ac->buf_mdct;
2819  INTFLOAT *temp = ac->temp;
2820  int i;
2821 
2822  // imdct
2823  if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) {
2824  for (i = 0; i < 8; i++)
2825  ac->mdct120->imdct_half(ac->mdct120, buf + i * 120, in + i * 128, 1);
2826  } else {
2827  ac->mdct960->imdct_half(ac->mdct960, buf, in, 1);
2828  }
2829 
2830  /* window overlapping
2831  * NOTE: To simplify the overlapping code, all 'meaningless' short to long
2832  * and long to short transitions are considered to be short to short
2833  * transitions. This leaves just two cases (long to long and short to short)
2834  * with a little special sauce for EIGHT_SHORT_SEQUENCE.
2835  */
2836 
2837  if ((ics->window_sequence[1] == ONLY_LONG_SEQUENCE || ics->window_sequence[1] == LONG_STOP_SEQUENCE) &&
2838  (ics->window_sequence[0] == ONLY_LONG_SEQUENCE || ics->window_sequence[0] == LONG_START_SEQUENCE)) {
2839  ac->fdsp->vector_fmul_window( out, saved, buf, lwindow_prev, 480);
2840  } else {
2841  memcpy( out, saved, 420 * sizeof(*out));
2842 
2843  if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) {
2844  ac->fdsp->vector_fmul_window(out + 420 + 0*120, saved + 420, buf + 0*120, swindow_prev, 60);
2845  ac->fdsp->vector_fmul_window(out + 420 + 1*120, buf + 0*120 + 60, buf + 1*120, swindow, 60);
2846  ac->fdsp->vector_fmul_window(out + 420 + 2*120, buf + 1*120 + 60, buf + 2*120, swindow, 60);
2847  ac->fdsp->vector_fmul_window(out + 420 + 3*120, buf + 2*120 + 60, buf + 3*120, swindow, 60);
2848  ac->fdsp->vector_fmul_window(temp, buf + 3*120 + 60, buf + 4*120, swindow, 60);
2849  memcpy( out + 420 + 4*120, temp, 60 * sizeof(*out));
2850  } else {
2851  ac->fdsp->vector_fmul_window(out + 420, saved + 420, buf, swindow_prev, 60);
2852  memcpy( out + 540, buf + 60, 420 * sizeof(*out));
2853  }
2854  }
2855 
2856  // buffer update
2857  if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) {
2858  memcpy( saved, temp + 60, 60 * sizeof(*saved));
2859  ac->fdsp->vector_fmul_window(saved + 60, buf + 4*120 + 60, buf + 5*120, swindow, 60);
2860  ac->fdsp->vector_fmul_window(saved + 180, buf + 5*120 + 60, buf + 6*120, swindow, 60);
2861  ac->fdsp->vector_fmul_window(saved + 300, buf + 6*120 + 60, buf + 7*120, swindow, 60);
2862  memcpy( saved + 420, buf + 7*120 + 60, 60 * sizeof(*saved));
2863  } else if (ics->window_sequence[0] == LONG_START_SEQUENCE) {
2864  memcpy( saved, buf + 480, 420 * sizeof(*saved));
2865  memcpy( saved + 420, buf + 7*120 + 60, 60 * sizeof(*saved));
2866  } else { // LONG_STOP or ONLY_LONG
2867  memcpy( saved, buf + 480, 480 * sizeof(*saved));
2868  }
2869 #endif
2870 }
2871 static void imdct_and_windowing_ld(AACContext *ac, SingleChannelElement *sce)
2872 {
2873  IndividualChannelStream *ics = &sce->ics;
2874  INTFLOAT *in = sce->coeffs;
2875  INTFLOAT *out = sce->ret;
2876  INTFLOAT *saved = sce->saved;
2877  INTFLOAT *buf = ac->buf_mdct;
2878 #if USE_FIXED
2879  int i;
2880 #endif /* USE_FIXED */
2881 
2882  // imdct
2883  ac->mdct.imdct_half(&ac->mdct_ld, buf, in);
2884 
2885 #if USE_FIXED
2886  for (i = 0; i < 1024; i++)
2887  buf[i] = (buf[i] + 2) >> 2;
2888 #endif /* USE_FIXED */
2889 
2890  // window overlapping
2891  if (ics->use_kb_window[1]) {
2892  // AAC LD uses a low overlap sine window instead of a KBD window
2893  memcpy(out, saved, 192 * sizeof(*out));
2894  ac->fdsp->vector_fmul_window(out + 192, saved + 192, buf, AAC_RENAME(ff_sine_128), 64);
2895  memcpy( out + 320, buf + 64, 192 * sizeof(*out));
2896  } else {
2897  ac->fdsp->vector_fmul_window(out, saved, buf, AAC_RENAME(ff_sine_512), 256);
2898  }
2899 
2900  // buffer update
2901  memcpy(saved, buf + 256, 256 * sizeof(*saved));
2902 }
2903 
2904 static void imdct_and_windowing_eld(AACContext *ac, SingleChannelElement *sce)
2905 {
2906  INTFLOAT *in = sce->coeffs;
2907  INTFLOAT *out = sce->ret;
2908  INTFLOAT *saved = sce->saved;
2909  INTFLOAT *buf = ac->buf_mdct;
2910  int i;
2911  const int n = ac->oc[1].m4ac.frame_length_short ? 480 : 512;
2912  const int n2 = n >> 1;
2913  const int n4 = n >> 2;
2914  const INTFLOAT *const window = n == 480 ? AAC_RENAME(ff_aac_eld_window_480) :
2915  AAC_RENAME(ff_aac_eld_window_512);
2916 
2917  // Inverse transform, mapped to the conventional IMDCT by
2918  // Chivukula, R.K.; Reznik, Y.A.; Devarajan, V.,
2919  // "Efficient algorithms for MPEG-4 AAC-ELD, AAC-LD and AAC-LC filterbanks,"
2920  // International Conference on Audio, Language and Image Processing, ICALIP 2008.
2921  // URL: http://ieeexplore.ieee.org/stamp/stamp.jsp?tp=&arnumber=4590245&isnumber=4589950
2922  for (i = 0; i < n2; i+=2) {
2923  INTFLOAT temp;
2924  temp = in[i ]; in[i ] = -in[n - 1 - i]; in[n - 1 - i] = temp;
2925  temp = -in[i + 1]; in[i + 1] = in[n - 2 - i]; in[n - 2 - i] = temp;
2926  }
2927 #if !USE_FIXED
2928  if (n == 480)
2929  ac->mdct480->imdct_half(ac->mdct480, buf, in, 1);
2930  else
2931 #endif
2932  ac->mdct.imdct_half(&ac->mdct_ld, buf, in);
2933 
2934 #if USE_FIXED
2935  for (i = 0; i < 1024; i++)
2936  buf[i] = (buf[i] + 1) >> 1;
2937 #endif /* USE_FIXED */
2938 
2939  for (i = 0; i < n; i+=2) {
2940  buf[i] = -buf[i];
2941  }
2942  // Like with the regular IMDCT at this point we still have the middle half
2943  // of a transform but with even symmetry on the left and odd symmetry on
2944  // the right
2945 
2946  // window overlapping
2947  // The spec says to use samples [0..511] but the reference decoder uses
2948  // samples [128..639].
2949  for (i = n4; i < n2; i ++) {
2950  out[i - n4] = AAC_MUL31( buf[ n2 - 1 - i] , window[i - n4]) +
2951  AAC_MUL31( saved[ i + n2] , window[i + n - n4]) +
2952  AAC_MUL31(-saved[n + n2 - 1 - i] , window[i + 2*n - n4]) +
2953  AAC_MUL31(-saved[ 2*n + n2 + i] , window[i + 3*n - n4]);
2954  }
2955  for (i = 0; i < n2; i ++) {
2956  out[n4 + i] = AAC_MUL31( buf[ i] , window[i + n2 - n4]) +
2957  AAC_MUL31(-saved[ n - 1 - i] , window[i + n2 + n - n4]) +
2958  AAC_MUL31(-saved[ n + i] , window[i + n2 + 2*n - n4]) +
2959  AAC_MUL31( saved[2*n + n - 1 - i] , window[i + n2 + 3*n - n4]);
2960  }
2961  for (i = 0; i < n4; i ++) {
2962  out[n2 + n4 + i] = AAC_MUL31( buf[ i + n2] , window[i + n - n4]) +
2963  AAC_MUL31(-saved[n2 - 1 - i] , window[i + 2*n - n4]) +
2964  AAC_MUL31(-saved[n + n2 + i] , window[i + 3*n - n4]);
2965  }
2966 
2967  // buffer update
2968  memmove(saved + n, saved, 2 * n * sizeof(*saved));
2969  memcpy( saved, buf, n * sizeof(*saved));
2970 }
2971 
2972 /**
2973  * channel coupling transformation interface
2974  *
2975  * @param apply_coupling_method pointer to (in)dependent coupling function
2976  */
2977 static void apply_channel_coupling(AACContext *ac, ChannelElement *cc,
2978  enum RawDataBlockType type, int elem_id,
2979  enum CouplingPoint coupling_point,
2980  void (*apply_coupling_method)(AACContext *ac, SingleChannelElement *target, ChannelElement *cce, int index))
2981 {
2982  int i, c;
2983 
2984  for (i = 0; i < MAX_ELEM_ID; i++) {
2985  ChannelElement *cce = ac->che[TYPE_CCE][i];
2986  int index = 0;
2987 
2988  if (cce && cce->coup.coupling_point == coupling_point) {
2989  ChannelCoupling *coup = &cce->coup;
2990 
2991  for (c = 0; c <= coup->num_coupled; c++) {
2992  if (coup->type[c] == type && coup->id_select[c] == elem_id) {
2993  if (coup->ch_select[c] != 1) {
2994  apply_coupling_method(ac, &cc->ch[0], cce, index);
2995  if (coup->ch_select[c] != 0)
2996  index++;
2997  }
2998  if (coup->ch_select[c] != 2)
2999  apply_coupling_method(ac, &cc->ch[1], cce, index++);
3000  } else
3001  index += 1 + (coup->ch_select[c] == 3);
3002  }
3003  }
3004  }
3005 }
3006 
3007 /**
3008  * Convert spectral data to samples, applying all supported tools as appropriate.
3009  */
3010 static void spectral_to_sample(AACContext *ac, int samples)
3011 {
3012  int i, type;
3013  void (*imdct_and_window)(AACContext *ac, SingleChannelElement *sce);
3014  switch (ac->oc[1].m4ac.object_type) {
3015  case AOT_ER_AAC_LD:
3016  imdct_and_window = imdct_and_windowing_ld;
3017  break;
3018  case AOT_ER_AAC_ELD:
3019  imdct_and_window = imdct_and_windowing_eld;
3020  break;
3021  default:
3022  if (ac->oc[1].m4ac.frame_length_short)
3023  imdct_and_window = imdct_and_windowing_960;
3024  else
3025  imdct_and_window = ac->imdct_and_windowing;
3026  }
3027  for (type = 3; type >= 0; type--) {
3028  for (i = 0; i < MAX_ELEM_ID; i++) {
3029  ChannelElement *che = ac->che[type][i];
3030  if (che && che->present) {
3031  if (type <= TYPE_CPE)
3032  apply_channel_coupling(ac, che, type, i, BEFORE_TNS, AAC_RENAME(apply_dependent_coupling));
3033  if (ac->oc[1].m4ac.object_type == AOT_AAC_LTP) {
3034  if (che->ch[0].ics.predictor_present) {
3035  if (che->ch[0].ics.ltp.present)
3036  ac->apply_ltp(ac, &che->ch[0]);
3037  if (che->ch[1].ics.ltp.present && type == TYPE_CPE)
3038  ac->apply_ltp(ac, &che->ch[1]);
3039  }
3040  }
3041  if (che->ch[0].tns.present)
3042  ac->apply_tns(che->ch[0].coeffs, &che->ch[0].tns, &che->ch[0].ics, 1);
3043  if (che->ch[1].tns.present)
3044  ac->apply_tns(che->ch[1].coeffs, &che->ch[1].tns, &che->ch[1].ics, 1);
3045  if (type <= TYPE_CPE)
3046  apply_channel_coupling(ac, che, type, i, BETWEEN_TNS_AND_IMDCT, AAC_RENAME(apply_dependent_coupling));
3047  if (type != TYPE_CCE || che->coup.coupling_point == AFTER_IMDCT) {
3048  imdct_and_window(ac, &che->ch[0]);
3049  if (ac->oc[1].m4ac.object_type == AOT_AAC_LTP)
3050  ac->update_ltp(ac, &che->ch[0]);
3051  if (type == TYPE_CPE) {
3052  imdct_and_window(ac, &che->ch[1]);
3053  if (ac->oc[1].m4ac.object_type == AOT_AAC_LTP)
3054  ac->update_ltp(ac, &che->ch[1]);
3055  }
3056  if (ac->oc[1].m4ac.sbr > 0) {
3057  AAC_RENAME(ff_sbr_apply)(ac, &che->sbr, type, che->ch[0].ret, che->ch[1].ret);
3058  }
3059  }
3060  if (type <= TYPE_CCE)
3061  apply_channel_coupling(ac, che, type, i, AFTER_IMDCT, AAC_RENAME(apply_independent_coupling));
3062 
3063 #if USE_FIXED
3064  {
3065  int j;
3066  /* preparation for resampler */
3067  for(j = 0; j<samples; j++){
3068  che->ch[0].ret[j] = (int32_t)av_clip64((int64_t)che->ch[0].ret[j]*128, INT32_MIN, INT32_MAX-0x8000)+0x8000;
3069  if(type == TYPE_CPE)
3070  che->ch[1].ret[j] = (int32_t)av_clip64((int64_t)che->ch[1].ret[j]*128, INT32_MIN, INT32_MAX-0x8000)+0x8000;
3071  }
3072  }
3073 #endif /* USE_FIXED */
3074  che->present = 0;
3075  } else if (che) {
3076  av_log(ac->avctx, AV_LOG_VERBOSE, "ChannelElement %d.%d missing \n", type, i);
3077  }
3078  }
3079  }
3080 }
3081 
3082 static int parse_adts_frame_header(AACContext *ac, GetBitContext *gb)
3083 {
3084  int size;
3085  AACADTSHeaderInfo hdr_info;
3086  uint8_t layout_map[MAX_ELEM_ID*4][3];
3087  int layout_map_tags, ret;
3088 
3089  size = ff_adts_header_parse(gb, &hdr_info);
3090  if (size > 0) {
3091  if (!ac->warned_num_aac_frames && hdr_info.num_aac_frames != 1) {
3092  // This is 2 for "VLB " audio in NSV files.
3093  // See samples/nsv/vlb_audio.
3094  avpriv_report_missing_feature(ac->avctx,
3095  "More than one AAC RDB per ADTS frame");
3096  ac->warned_num_aac_frames = 1;
3097  }
3098  push_output_configuration(ac);
3099  if (hdr_info.chan_config) {
3100  ac->oc[1].m4ac.chan_config = hdr_info.chan_config;
3101  if ((ret = set_default_channel_config(ac, ac->avctx,
3102  layout_map,
3103  &layout_map_tags,
3104  hdr_info.chan_config)) < 0)
3105  return ret;
3106  if ((ret = output_configure(ac, layout_map, layout_map_tags,
3107  FFMAX(ac->oc[1].status,
3108  OC_TRIAL_FRAME), 0)) < 0)
3109  return ret;
3110  } else {
3111  ac->oc[1].m4ac.chan_config = 0;
3112  /**
3113  * dual mono frames in Japanese DTV can have chan_config 0
3114  * WITHOUT specifying PCE.
3115  * thus, set dual mono as default.
3116  */
3117  if (ac->dmono_mode && ac->oc[0].status == OC_NONE) {
3118  layout_map_tags = 2;
3119  layout_map[0][0] = layout_map[1][0] = TYPE_SCE;
3120  layout_map[0][2] = layout_map[1][2] = AAC_CHANNEL_FRONT;
3121  layout_map[0][1] = 0;
3122  layout_map[1][1] = 1;
3123  if (output_configure(ac, layout_map, layout_map_tags,
3124  OC_TRIAL_FRAME, 0))
3125  return -7;
3126  }
3127  }
3128  ac->oc[1].m4ac.sample_rate = hdr_info.sample_rate;
3129  ac->oc[1].m4ac.sampling_index = hdr_info.sampling_index;
3130  ac->oc[1].m4ac.object_type = hdr_info.object_type;
3131  ac->oc[1].m4ac.frame_length_short = 0;
3132  if (ac->oc[0].status != OC_LOCKED ||
3133  ac->oc[0].m4ac.chan_config != hdr_info.chan_config ||
3134  ac->oc[0].m4ac.sample_rate != hdr_info.sample_rate) {
3135  ac->oc[1].m4ac.sbr = -1;
3136  ac->oc[1].m4ac.ps = -1;
3137  }
3138  if (!hdr_info.crc_absent)
3139  skip_bits(gb, 16);
3140  }
3141  return size;
3142 }
3143 
3144 static int aac_decode_er_frame(AVCodecContext *avctx, void *data,
3145  int *got_frame_ptr, GetBitContext *gb)
3146 {
3147  AACContext *ac = avctx->priv_data;
3148  const MPEG4AudioConfig *const m4ac = &ac->oc[1].m4ac;
3149  ChannelElement *che;
3150  int err, i;
3151  int samples = m4ac->frame_length_short ? 960 : 1024;
3152  int chan_config = m4ac->chan_config;
3153  int aot = m4ac->object_type;
3154 
3155  if (aot == AOT_ER_AAC_LD || aot == AOT_ER_AAC_ELD)
3156  samples >>= 1;
3157 
3158  ac->frame = data;
3159 
3160  if ((err = frame_configure_elements(avctx)) < 0)
3161  return err;
3162 
3163  // The FF_PROFILE_AAC_* defines are all object_type - 1
3164  // This may lead to an undefined profile being signaled
3165  ac->avctx->profile = aot - 1;
3166 
3167  ac->tags_mapped = 0;
3168 
3169  if (chan_config < 0 || (chan_config >= 8 && chan_config < 11) || chan_config >= 13) {
3170  avpriv_request_sample(avctx, "Unknown ER channel configuration %d",
3171  chan_config);
3172  return AVERROR_INVALIDDATA;
3173  }
3174  for (i = 0; i < tags_per_config[chan_config]; i++) {
3175  const int elem_type = aac_channel_layout_map[chan_config-1][i][0];
3176  const int elem_id = aac_channel_layout_map[chan_config-1][i][1];
3177  if (!(che=get_che(ac, elem_type, elem_id))) {
3178  av_log(ac->avctx, AV_LOG_ERROR,
3179  "channel element %d.%d is not allocated\n",
3180  elem_type, elem_id);
3181  return AVERROR_INVALIDDATA;
3182  }
3183  che->present = 1;
3184  if (aot != AOT_ER_AAC_ELD)
3185  skip_bits(gb, 4);
3186  switch (elem_type) {
3187  case TYPE_SCE:
3188  err = decode_ics(ac, &che->ch[0], gb, 0, 0);
3189  break;
3190  case TYPE_CPE:
3191  err = decode_cpe(ac, gb, che);
3192  break;
3193  case TYPE_LFE:
3194  err = decode_ics(ac, &che->ch[0], gb, 0, 0);
3195  break;
3196  }
3197  if (err < 0)
3198  return err;
3199  }
3200 
3201  spectral_to_sample(ac, samples);
3202 
3203  if (!ac->frame->data[0] && samples) {
3204  av_log(avctx, AV_LOG_ERROR, "no frame data found\n");
3205  return AVERROR_INVALIDDATA;
3206  }
3207 
3208  ac->frame->nb_samples = samples;
3209  ac->frame->sample_rate = avctx->sample_rate;
3210  *got_frame_ptr = 1;
3211 
3212  skip_bits_long(gb, get_bits_left(gb));
3213  return 0;
3214 }
3215 
3216 static int aac_decode_frame_int(AVCodecContext *avctx, void *data,
3217  int *got_frame_ptr, GetBitContext *gb, AVPacket *avpkt)
3218 {
3219  AACContext *ac = avctx->priv_data;
3220  ChannelElement *che = NULL, *che_prev = NULL;
3221  enum RawDataBlockType elem_type, che_prev_type = TYPE_END;
3222  int err, elem_id;
3223  int samples = 0, multiplier, audio_found = 0, pce_found = 0;
3224  int is_dmono, sce_count = 0;
3225  int payload_alignment;
3226  uint8_t che_presence[4][MAX_ELEM_ID] = {{0}};
3227 
3228  ac->frame = data;
3229 
3230  if (show_bits(gb, 12) == 0xfff) {
3231  if ((err = parse_adts_frame_header(ac, gb)) < 0) {
3232  av_log(avctx, AV_LOG_ERROR, "Error decoding AAC frame header.\n");
3233  goto fail;
3234  }
3235  if (ac->oc[1].m4ac.sampling_index > 12) {
3236  av_log(ac->avctx, AV_LOG_ERROR, "invalid sampling rate index %d\n", ac->oc[1].m4ac.sampling_index);
3237  err = AVERROR_INVALIDDATA;
3238  goto fail;
3239  }
3240  }
3241 
3242  if ((err = frame_configure_elements(avctx)) < 0)
3243  goto fail;
3244 
3245  // The FF_PROFILE_AAC_* defines are all object_type - 1
3246  // This may lead to an undefined profile being signaled
3247  ac->avctx->profile = ac->oc[1].m4ac.object_type - 1;
3248 
3249  payload_alignment = get_bits_count(gb);
3250  ac->tags_mapped = 0;
3251  // parse
3252  while ((elem_type = get_bits(gb, 3)) != TYPE_END) {
3253  elem_id = get_bits(gb, 4);
3254 
3255  if (avctx->debug & FF_DEBUG_STARTCODE)
3256  av_log(avctx, AV_LOG_DEBUG, "Elem type:%x id:%x\n", elem_type, elem_id);
3257 
3258  if (!avctx->channels && elem_type != TYPE_PCE) {
3259  err = AVERROR_INVALIDDATA;
3260  goto fail;
3261  }
3262 
3263  if (elem_type < TYPE_DSE) {
3264  if (che_presence[elem_type][elem_id]) {
3265  int error = che_presence[elem_type][elem_id] > 1;
3266  av_log(ac->avctx, error ? AV_LOG_ERROR : AV_LOG_DEBUG, "channel element %d.%d duplicate\n",
3267  elem_type, elem_id);
3268  if (error) {
3269  err = AVERROR_INVALIDDATA;
3270  goto fail;
3271  }
3272  }
3273  che_presence[elem_type][elem_id]++;
3274 
3275  if (!(che=get_che(ac, elem_type, elem_id))) {
3276  av_log(ac->avctx, AV_LOG_ERROR, "channel element %d.%d is not allocated\n",
3277  elem_type, elem_id);
3278  err = AVERROR_INVALIDDATA;
3279  goto fail;
3280  }
3281  samples = ac->oc[1].m4ac.frame_length_short ? 960 : 1024;
3282  che->present = 1;
3283  }
3284 
3285  switch (elem_type) {
3286 
3287  case TYPE_SCE:
3288  err = decode_ics(ac, &che->ch[0], gb, 0, 0);
3289  audio_found = 1;
3290  sce_count++;
3291  break;
3292 
3293  case TYPE_CPE:
3294  err = decode_cpe(ac, gb, che);
3295  audio_found = 1;
3296  break;
3297 
3298  case TYPE_CCE:
3299  err = decode_cce(ac, gb, che);
3300  break;
3301 
3302  case TYPE_LFE:
3303  err = decode_ics(ac, &che->ch[0], gb, 0, 0);
3304  audio_found = 1;
3305  break;
3306 
3307  case TYPE_DSE:
3308  err = skip_data_stream_element(ac, gb);
3309  break;
3310 
3311  case TYPE_PCE: {
3312  uint8_t layout_map[MAX_ELEM_ID*4][3] = {{0}};
3313  int tags;
3314 
3315  int pushed = push_output_configuration(ac);
3316  if (pce_found && !pushed) {
3317  err = AVERROR_INVALIDDATA;
3318  goto fail;
3319  }
3320 
3321  tags = decode_pce(avctx, &ac->oc[1].m4ac, layout_map, gb,
3322  payload_alignment);
3323  if (tags < 0) {
3324  err = tags;
3325  break;
3326  }
3327  if (pce_found) {
3328  av_log(avctx, AV_LOG_ERROR,
3329  "Not evaluating a further program_config_element as this construct is dubious at best.\n");
3330  pop_output_configuration(ac);
3331  } else {
3332  err = output_configure(ac, layout_map, tags, OC_TRIAL_PCE, 1);
3333  if (!err)
3334  ac->oc[1].m4ac.chan_config = 0;
3335  pce_found = 1;
3336  }
3337  break;
3338  }
3339 
3340  case TYPE_FIL:
3341  if (elem_id == 15)
3342  elem_id += get_bits(gb, 8) - 1;
3343  if (get_bits_left(gb) < 8 * elem_id) {
3344  av_log(avctx, AV_LOG_ERROR, "TYPE_FIL: "overread_err);
3345  err = AVERROR_INVALIDDATA;
3346  goto fail;
3347  }
3348  err = 0;
3349  while (elem_id > 0) {
3350  int ret = decode_extension_payload(ac, gb, elem_id, che_prev, che_prev_type);
3351  if (ret < 0) {
3352  err = ret;
3353  break;
3354  }
3355  elem_id -= ret;
3356  }
3357  break;
3358 
3359  default:
3360  err = AVERROR_BUG; /* should not happen, but keeps compiler happy */
3361  break;
3362  }
3363 
3364  if (elem_type < TYPE_DSE) {
3365  che_prev = che;
3366  che_prev_type = elem_type;
3367  }
3368 
3369  if (err)
3370  goto fail;
3371 
3372  if (get_bits_left(gb) < 3) {
3373  av_log(avctx, AV_LOG_ERROR, overread_err);
3374  err = AVERROR_INVALIDDATA;
3375  goto fail;
3376  }
3377  }
3378 
3379  if (!avctx->channels) {
3380  *got_frame_ptr = 0;
3381  return 0;
3382  }
3383 
3384  multiplier = (ac->oc[1].m4ac.sbr == 1) ? ac->oc[1].m4ac.ext_sample_rate > ac->oc[1].m4ac.sample_rate : 0;
3385  samples <<= multiplier;
3386 
3387  spectral_to_sample(ac, samples);
3388 
3389  if (ac->oc[1].status && audio_found) {
3390  avctx->sample_rate = ac->oc[1].m4ac.sample_rate << multiplier;
3391  avctx->frame_size = samples;
3392  ac->oc[1].status = OC_LOCKED;
3393  }
3394 
3395  if (multiplier)
3396  avctx->internal->skip_samples_multiplier = 2;
3397 
3398  if (!ac->frame->data[0] && samples) {
3399  av_log(avctx, AV_LOG_ERROR, "no frame data found\n");
3400  err = AVERROR_INVALIDDATA;
3401  goto fail;
3402  }
3403 
3404  if (samples) {
3405  ac->frame->nb_samples = samples;
3406  ac->frame->sample_rate = avctx->sample_rate;
3407  } else
3408  av_frame_unref(ac->frame);
3409  *got_frame_ptr = !!samples;
3410 
3411  /* for dual-mono audio (SCE + SCE) */
3412  is_dmono = ac->dmono_mode && sce_count == 2 &&
3413  ac->oc[1].channel_layout == (AV_CH_FRONT_LEFT | AV_CH_FRONT_RIGHT);
3414  if (is_dmono) {
3415  if (ac->dmono_mode == 1)
3416  ((AVFrame *)data)->data[1] =((AVFrame *)data)->data[0];
3417  else if (ac->dmono_mode == 2)
3418  ((AVFrame *)data)->data[0] =((AVFrame *)data)->data[1];
3419  }
3420 
3421  return 0;
3422 fail:
3423  pop_output_configuration(ac);
3424  return err;
3425 }
3426 
3427 static int aac_decode_frame(AVCodecContext *avctx, void *data,
3428  int *got_frame_ptr, AVPacket *avpkt)
3429 {
3430  AACContext *ac = avctx->priv_data;
3431  const uint8_t *buf = avpkt->data;
3432  int buf_size = avpkt->size;
3433  GetBitContext gb;
3434  int buf_consumed;
3435  int buf_offset;
3436  int err;
3437  int new_extradata_size;
3438  const uint8_t *new_extradata = av_packet_get_side_data(avpkt,
3439  AV_PKT_DATA_NEW_EXTRADATA,
3440  &new_extradata_size);
3441  int jp_dualmono_size;
3442  const uint8_t *jp_dualmono = av_packet_get_side_data(avpkt,
3443  AV_PKT_DATA_JP_DUALMONO,
3444  &jp_dualmono_size);
3445 
3446  if (new_extradata) {
3447  /* discard previous configuration */
3448  ac->oc[1].status = OC_NONE;
3449  err = decode_audio_specific_config(ac, ac->avctx, &ac->oc[1].m4ac,
3450  new_extradata,
3451  new_extradata_size * 8LL, 1);
3452  if (err < 0) {
3453  return err;
3454  }
3455  }
3456 
3457  ac->dmono_mode = 0;
3458  if (jp_dualmono && jp_dualmono_size > 0)
3459  ac->dmono_mode = 1 + *jp_dualmono;
3460  if (ac->force_dmono_mode >= 0)
3461  ac->dmono_mode = ac->force_dmono_mode;
3462 
3463  if (INT_MAX / 8 <= buf_size)
3464  return AVERROR_INVALIDDATA;
3465 
3466  if ((err = init_get_bits8(&gb, buf, buf_size)) < 0)
3467  return err;
3468 
3469  switch (ac->oc[1].m4ac.object_type) {
3470  case AOT_ER_AAC_LC:
3471  case AOT_ER_AAC_LTP:
3472  case AOT_ER_AAC_LD:
3473  case AOT_ER_AAC_ELD:
3474  err = aac_decode_er_frame(avctx, data, got_frame_ptr, &gb);
3475  break;
3476  default:
3477  err = aac_decode_frame_int(avctx, data, got_frame_ptr, &gb, avpkt);
3478  }
3479  if (err < 0)
3480  return err;
3481 
3482  buf_consumed = (get_bits_count(&gb) + 7) >> 3;
3483  for (buf_offset = buf_consumed; buf_offset < buf_size; buf_offset++)
3484  if (buf[buf_offset])
3485  break;
3486 
3487  return buf_size > buf_offset ? buf_consumed : buf_size;
3488 }
3489 
3490 static av_cold int aac_decode_close(AVCodecContext *avctx)
3491 {
3492  AACContext *ac = avctx->priv_data;
3493  int i, type;
3494 
3495  for (i = 0; i < MAX_ELEM_ID; i++) {
3496  for (type = 0; type < 4; type++) {
3497  if (ac->che[type][i])
3498  AAC_RENAME(ff_aac_sbr_ctx_close)(&ac->che[type][i]->sbr);
3499  av_freep(&ac->che[type][i]);
3500  }
3501  }
3502 
3503  ff_mdct_end(&ac->mdct);
3504  ff_mdct_end(&ac->mdct_small);
3505  ff_mdct_end(&ac->mdct_ld);
3506  ff_mdct_end(&ac->mdct_ltp);
3507 #if !USE_FIXED
3508  ff_mdct15_uninit(&ac->mdct120);
3509  ff_mdct15_uninit(&ac->mdct480);
3510  ff_mdct15_uninit(&ac->mdct960);
3511 #endif
3512  av_freep(&ac->fdsp);
3513  return 0;
3514 }
3515 
3516 static void aacdec_init(AACContext *c)
3517 {
3518  c->imdct_and_windowing = imdct_and_windowing;
3519  c->apply_ltp = apply_ltp;
3520  c->apply_tns = apply_tns;
3521  c->windowing_and_mdct_ltp = windowing_and_mdct_ltp;
3522  c->update_ltp = update_ltp;
3523 #if USE_FIXED
3524  c->vector_pow43 = vector_pow43;
3525  c->subband_scale = subband_scale;
3526 #endif
3527 
3528 #if !USE_FIXED
3529  if(ARCH_MIPS)
3530  ff_aacdec_init_mips(c);
3531 #endif /* !USE_FIXED */
3532 }
3533 /**
3534  * AVOptions for Japanese DTV specific extensions (ADTS only)
3535  */
3536 #define AACDEC_FLAGS AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM
3537 static const AVOption options[] = {
3538  {"dual_mono_mode", "Select the channel to decode for dual mono",
3539  offsetof(AACContext, force_dmono_mode), AV_OPT_TYPE_INT, {.i64=-1}, -1, 2,
3540  AACDEC_FLAGS, "dual_mono_mode"},
3541 
3542  {"auto", "autoselection", 0, AV_OPT_TYPE_CONST, {.i64=-1}, INT_MIN, INT_MAX, AACDEC_FLAGS, "dual_mono_mode"},
3543  {"main", "Select Main/Left channel", 0, AV_OPT_TYPE_CONST, {.i64= 1}, INT_MIN, INT_MAX, AACDEC_FLAGS, "dual_mono_mode"},
3544  {"sub" , "Select Sub/Right channel", 0, AV_OPT_TYPE_CONST, {.i64= 2}, INT_MIN, INT_MAX, AACDEC_FLAGS, "dual_mono_mode"},
3545  {"both", "Select both channels", 0, AV_OPT_TYPE_CONST, {.i64= 0}, INT_MIN, INT_MAX, AACDEC_FLAGS, "dual_mono_mode"},
3546 
3547  {NULL},
3548 };
3549 
3550 static const AVClass aac_decoder_class = {
3551  .class_name = "AAC decoder",
3552  .item_name = av_default_item_name,
3553  .option = options,
3554  .version = LIBAVUTIL_VERSION_INT,
3555 };
IndividualChannelStream::predictor_initialized
int predictor_initialized
Definition: aac.h:188
UINTFLOAT
float UINTFLOAT
Definition: aac_defines.h:89
VMUL4S
static float * VMUL4S(float *dst, const float *v, unsigned idx, unsigned sign, const float *scale)
Definition: aacdec.c:129
AACContext::fdsp
AVFloatDSPContext * fdsp
Definition: aac.h:334
apply_prediction
static void apply_prediction(AACContext *ac, SingleChannelElement *sce)
Apply AAC-Main style frequency domain prediction.
Definition: aacdec_template.c:2041
AV_SAMPLE_FMT_FLTP
float, planar
Definition: samplefmt.h:69
AVFloatDSPContext::scalarproduct_float
float(* scalarproduct_float)(const float *v1, const float *v2, int len)
Calculate the scalar product of two vectors of floats.
Definition: float_dsp.h:175
imdct_and_windowing
static void imdct_and_windowing(AACContext *ac, SingleChannelElement *sce)
Conduct IMDCT and windowing.
Definition: aacdec_template.c:2740
apply_ltp
static void apply_ltp(AACContext *ac, SingleChannelElement *sce)
Apply the long term prediction.
Definition: aacdec_template.c:2670
NULL
#define NULL
Definition: coverity.c:32
sine_120
static INTFLOAT sine_120[120]
Definition: aacdec.c:72
VLC::table_size
int table_size
Definition: vlc.h:29
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
TYPE_DSE
Definition: aac.h:61
elem_to_channel::elem_id
uint8_t elem_id
Definition: aacdec_template.c:195
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_template.c:1651
IndividualChannelStream::use_kb_window
uint8_t use_kb_window[2]
If set, use Kaiser-Bessel window, otherwise use a sine window.
Definition: aac.h:178
AACContext::buf_mdct
INTFLOAT buf_mdct[1024]
Definition: aac.h:317
set_default_channel_config
static int set_default_channel_config(AACContext *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_template.c:615
overread_err
#define overread_err
Definition: aacdec_template.c:101
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:314
AV_CH_TOP_FRONT_RIGHT
#define AV_CH_TOP_FRONT_RIGHT
Definition: channel_layout.h:63
AACADTSHeaderInfo::object_type
uint8_t object_type
Definition: adts_header.h:33
AVOption
AVOption.
Definition: opt.h:248
ff_aac_tableinit
void ff_aac_tableinit(void)
Definition: aactab.c:3347
data
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
flush
static void flush(AVCodecContext *avctx)
Definition: aacdec_template.c:592
tags_per_config
static const int8_t tags_per_config[16]
Definition: aacdectab.h:38
AACContext::avctx
AVCodecContext * avctx
Definition: aac.h:296
Pulse
Definition: aac.h:225
DEC_UPAIR
static int * DEC_UPAIR(int *dst, unsigned idx, unsigned sign)
Definition: aacdec_fixed.c:128
aac_table_init
static AVOnce aac_table_init
Definition: aacdec_template.c:1250
re
float re
Definition: fft.c:82
AAC_MUL26
#define AAC_MUL26(x, y)
Definition: aac_defines.h:102
ret
ret
Definition: filter_design.txt:187
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:200
ff_kbd_window_init
av_cold void ff_kbd_window_init(float *window, float alpha, int n)
Generate a Kaiser-Bessel Derived Window.
Definition: kbdwin.c:26
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
SCALE_DIFF_ZERO
#define SCALE_DIFF_ZERO
codebook index corresponding to zero scalefactor indices difference
Definition: aac.h:153
temp
else temp
Definition: vf_mcdeint.c:256
TYPE_END
Definition: aac.h:64
cce_scale
static const float cce_scale[]
Definition: aacdec_template.c:2324
skip_bits_long
static void skip_bits_long(GetBitContext *s, int n)
Skips the specified number of bits.
Definition: get_bits.h:291
g
const char * g
Definition: vf_curves.c:115
AV_OPT_TYPE_INT
Definition: opt.h:225
AV_CH_TOP_SIDE_LEFT
#define AV_CH_TOP_SIDE_LEFT
Definition: channel_layout.h:74
VMUL2S
static float * VMUL2S(float *dst, const float *v, unsigned idx, unsigned sign, const float *scale)
Definition: aacdec.c:112
AACDEC_FLAGS
#define AACDEC_FLAGS
AVOptions for Japanese DTV specific extensions (ADTS only)
Definition: aacdec_template.c:3536
imdct_and_windowing_eld
static void imdct_and_windowing_eld(AACContext *ac, SingleChannelElement *sce)
Definition: aacdec_template.c:2904
elem_to_channel
Definition: aacdec_template.c:192
INIT_VLC_STATIC
#define INIT_VLC_STATIC(vlc, bits, a, b, c, d, e, f, g, static_size)
Definition: vlc.h:120
aacdec_init
static void aacdec_init(AACContext *ac)
Definition: aacdec_template.c:3516
FIXR10
#define FIXR10(x)
Definition: aac_defines.h:95
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h:39
AV_CH_TOP_FRONT_LEFT
#define AV_CH_TOP_FRONT_LEFT
Definition: channel_layout.h:61
DEC_SQUAD
static int * DEC_SQUAD(int *dst, unsigned idx)
Definition: aacdec_fixed.c:118
decode_audio_specific_config_gb
static int decode_audio_specific_config_gb(AACContext *ac, AVCodecContext *avctx, MPEG4AudioConfig *m4ac, GetBitContext *gb, int get_bit_alignment, int sync_extension)
Decode audio specific configuration; reference: table 1.13.
Definition: aacdec_template.c:1067
TYPE_SCE
Definition: aac.h:57
TYPE_CPE
Definition: aac.h:58
AACContext::che
ChannelElement * che[4][MAX_ELEM_ID]
Definition: aac.h:306
ff_init_vlc_sparse
int ff_init_vlc_sparse(VLC *vlc_arg, int nb_bits, int nb_codes, const void *bits, int bits_wrap, int bits_size, const void *codes, int codes_wrap, int codes_size, const void *symbols, int symbols_wrap, int symbols_size, int flags)
Definition: bitstream.c:323
AV_CH_TOP_FRONT_CENTER
#define AV_CH_TOP_FRONT_CENTER
Definition: channel_layout.h:62
AVPacket::size
int size
Definition: packet.h:364
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
AV_CH_LOW_FREQUENCY_2
#define AV_CH_LOW_FREQUENCY_2
Definition: channel_layout.h:73
aac_channel_layout_map
static const uint8_t aac_channel_layout_map[16][16][3]
Definition: aacdectab.h:40
av_log2
int av_log2(unsigned v)
Definition: intmath.c:26
SingleChannelElement::ret
INTFLOAT * ret
PCM output.
Definition: aac.h:270
aac_kbd_long_960
static INTFLOAT aac_kbd_long_960[960]
Definition: aacdec.c:74
ChannelElement::present
int present
Definition: aac.h:277
update_ltp
static void update_ltp(AACContext *ac, SingleChannelElement *sce)
Update the LTP buffer for next frame.
Definition: aacdec_template.c:2702
vector_pow43
static void vector_pow43(int *coefs, int len)
Definition: aacdec_fixed.c:154
sine_960
static INTFLOAT sine_960[960]
Definition: aacdec.c:73
OutputConfiguration::channel_layout
uint64_t channel_layout
Definition: aac.h:129
type
GLint GLenum type
Definition: opengl_enc.c:104
SingleChannelElement::sf
INTFLOAT sf[120]
scalefactors
Definition: aac.h:256
AV_EF_BITSTREAM
#define AV_EF_BITSTREAM
detect bitstream specification deviations
Definition: avcodec.h:1669
decode_ga_specific_config
static int decode_ga_specific_config(AACContext *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_template.c:903
ChannelElement::ms_mask
uint8_t ms_mask[128]
Set if mid/side stereo is used for each scalefactor window band.
Definition: aac.h:282
apply_independent_coupling
static void apply_independent_coupling(AACContext *ac, SingleChannelElement *target, ChannelElement *cce, int index)
Apply independent channel coupling (applied after IMDCT).
Definition: aacdec.c:251
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:237
MAX_LTP_LONG_SFB
#define MAX_LTP_LONG_SFB
Definition: aac.h:52
GET_GAIN
#define GET_GAIN(x, y)
Definition: aac_defines.h:100
DynamicRangeControl
Dynamic Range Control - decoded from the bitstream but not processed further.
Definition: aac.h:212
error
static void error(const char *err)
Definition: target_bsf_fuzzer.c:30
che_configure
static av_cold int che_configure(AACContext *ac, enum ChannelPosition che_pos, int type, int id, int *channels)
Check for the channel element in the current channel position configuration.
Definition: aacdec_template.c:127
vlc_scalefactors
static VLC vlc_scalefactors
Definition: aacdec_template.c:94
NOISE_PRE
#define NOISE_PRE
preamble for NOISE_BT, put in bitstream with the first noise band
Definition: aac.h:157
FF_PROFILE_AAC_HE_V2
#define FF_PROFILE_AAC_HE_V2
Definition: avcodec.h:1880
predict
static av_always_inline void predict(PredictorState *ps, float *coef, int output_enable)
Definition: aacdec.c:179
ChannelCoupling::type
enum RawDataBlockType type[8]
Type of channel element to be coupled - SCE or CPE.
Definition: aac.h:238
AVCodecContext::profile
int profile
profile
Definition: avcodec.h:1871
output_configure
static int output_configure(AACContext *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_template.c:532
ChannelPosition
ChannelPosition
Definition: aac.h:95
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_template.c:791
decode
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
aac_decode_er_frame
static int aac_decode_er_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, GetBitContext *gb)
Definition: aacdec_template.c:3144
NOISE_BT
Spectral data are scaled white noise not coded in the bitstream.
Definition: aac.h:88
TYPE_CCE
Definition: aac.h:59
decode_cce
static int decode_cce(AACContext *ac, GetBitContext *gb, ChannelElement *che)
Decode coupling_channel_element; reference: table 4.8.
Definition: aacdec_template.c:2336
USE_FIXED
#define USE_FIXED
Definition: aac_defines.h:25
lcg_random
static av_always_inline int lcg_random(unsigned previous_val)
linear congruential pseudorandom number generator
Definition: aacdec_template.c:1162
DynamicRangeControl::band_incr
int band_incr
Number of DRC bands greater than 1 having DRC info.
Definition: aac.h:217
ff_aac_num_swb_128
const uint8_t ff_aac_num_swb_128[]
Definition: aactab.c:80
AAC_RENAME_32
#define AAC_RENAME_32(x)
Definition: aac_defines.h:86
ff_cbrt_tableinit
void ff_cbrt_tableinit(void)
Definition: cbrt_tablegen.h:40
AACContext::dmono_mode
int dmono_mode
0->not dmono, 1->use first channel, 2->use second channel
Definition: aac.h:352
IndividualChannelStream::swb_offset
const uint16_t * swb_offset
table of offsets to the lowest spectral coefficient of a scalefactor band, sfb, for a particular wind...
Definition: aac.h:182
AOT_ER_AAC_LTP
N Error Resilient Long Term Prediction.
Definition: mpeg4audio.h:105
INTFLOAT
float INTFLOAT
Definition: aac_defines.h:88
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:72
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
AV_OPT_TYPE_CONST
Definition: opt.h:234
decode_ics_info
static int decode_ics_info(AACContext *ac, IndividualChannelStream *ics, GetBitContext *gb)
Decode Individual Channel Stream info; reference: table 4.6.
Definition: aacdec_template.c:1401
EXT_FILL
Definition: aac.h:68
BandType
BandType
Definition: aac.h:83
AVCodecContext::sample_fmt
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1199
uint8_t
uint8_t
Definition: audio_convert.c:194
FIXR
#define FIXR(x)
Definition: aac_defines.h:94
av_cold
#define av_cold
Definition: attributes.h:88
OutputConfiguration::layout_map
uint8_t layout_map[MAX_ELEM_ID *4][3]
Definition: aac.h:126
OC_TRIAL_PCE
Output configuration under trial specified by an inband PCE.
Definition: aac.h:118
ff_swb_offset_480
const uint16_t *const ff_swb_offset_480[]
Definition: aactab.c:1379
ff_mpeg4audio_channels
const uint8_t ff_mpeg4audio_channels[14]
Definition: mpeg4audio.c:67
FF_DEBUG_PICT_INFO
#define FF_DEBUG_PICT_INFO
Definition: avcodec.h:1617
AACContext::warned_960_sbr
int warned_960_sbr
Definition: aac.h:359
ChannelElement::ch
SingleChannelElement ch[2]
Definition: aac.h:285
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:84
ff_swb_offset_512
const uint16_t *const ff_swb_offset_512[]
Definition: aactab.c:1371
AV_CH_TOP_BACK_LEFT
#define AV_CH_TOP_BACK_LEFT
Definition: channel_layout.h:64
TYPE_LFE
Definition: aac.h:60
ff_tns_max_bands_480
const uint8_t ff_tns_max_bands_480[]
Definition: aactab.c:1421
end
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:92
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
AVFloatDSPContext::vector_fmul
void(* vector_fmul)(float *dst, const float *src0, const float *src1, int len)
Calculate the entry wise product of two vectors of floats and store the result in a vector of floats...
Definition: float_dsp.h:38
SingleChannelElement::tns
TemporalNoiseShaping tns
Definition: aac.h:251
AV_CH_BOTTOM_FRONT_LEFT
#define AV_CH_BOTTOM_FRONT_LEFT
Definition: channel_layout.h:77
AOT_ER_AAC_LD
N Error Resilient Low Delay.
Definition: mpeg4audio.h:109
AV_CH_TOP_BACK_CENTER
#define AV_CH_TOP_BACK_CENTER
Definition: channel_layout.h:65
decode_extension_payload
static int decode_extension_payload(AACContext *ac, GetBitContext *gb, int cnt, ChannelElement *che, enum RawDataBlockType elem_type)
Decode extension data (incomplete); reference: table 4.51.
Definition: aacdec_template.c:2519
ff_aac_scalefactor_bits
const uint8_t ff_aac_scalefactor_bits[121]
Definition: aactab.c:111
CouplingPoint
CouplingPoint
The point during decoding at which channel coupling is applied.
Definition: aac.h:107
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:632
ChannelCoupling::num_coupled
int num_coupled
number of target elements
Definition: aac.h:237
u
#define u(width, name, range_min, range_max)
Definition: cbs_h2645.c:262
AV_CH_LOW_FREQUENCY
#define AV_CH_LOW_FREQUENCY
Definition: channel_layout.h:52
ff_mdct15_init
av_cold int ff_mdct15_init(MDCT15Context **ps, int inverse, int N, double scale)
Definition: mdct15.c:247
DynamicRangeControl::exclude_mask
int exclude_mask[MAX_CHANNELS]
Channels to be excluded from DRC processing.
Definition: aac.h:216
TemporalNoiseShaping::n_filt
int n_filt[8]
Definition: aac.h:201
AACContext::mdct_ltp
FFTContext mdct_ltp
Definition: aac.h:327
AACContext::output_element
SingleChannelElement * output_element[MAX_CHANNELS]
Points to each SingleChannelElement.
Definition: aac.h:343
aac_decode_init
static av_cold int aac_decode_init(AVCodecContext *avctx)
Definition: aacdec_template.c:1252
AVPacket::data
uint8_t * data
Definition: packet.h:363
get_bits_count
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:219
AAC_MUL31
#define AAC_MUL31(x, y)
Definition: aac_defines.h:104
count_channels
static int count_channels(uint8_t(*layout)[3], int tags)
Definition: aacdec_template.c:103
ff_dlog
#define ff_dlog(a,...)
Definition: tableprint_vlc.h:29
INTENSITY_BT
Scalefactor data are intensity stereo positions (in phase).
Definition: aac.h:90
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:210
sample_rate_idx
static int sample_rate_idx(int rate)
Definition: aacdec_template.c:1175
decode_tns
static int decode_tns(AACContext *ac, TemporalNoiseShaping *tns, GetBitContext *gb, const IndividualChannelStream *ics)
Decode Temporal Noise Shaping data; reference: table 4.48.
Definition: aacdec_template.c:1678
AV_CH_BACK_LEFT
#define AV_CH_BACK_LEFT
Definition: channel_layout.h:53
ChannelCoupling::id_select
int id_select[8]
element id
Definition: aac.h:239
size
ptrdiff_t size
Definition: opengl_enc.c:100
ff_aac_codebook_vector_vals
const float *const ff_aac_codebook_vector_vals[]
Definition: aactab.c:1093
ff_aac_float_common_init
void ff_aac_float_common_init(void)
fixed_sqrt
static av_always_inline int fixed_sqrt(int x, int bits)
Calculate the square root.
Definition: fixed_dsp.h:176
AOT_ER_AAC_LC
N Error Resilient Low Complexity.
Definition: mpeg4audio.h:104
AACContext::tag_che_map
ChannelElement * tag_che_map[4][MAX_ELEM_ID]
Definition: aac.h:307
channels
channels
Definition: aptx.h:33
AVOnce
#define AVOnce
Definition: thread.h:172
fabsf
static __device__ float fabsf(float a)
Definition: cuda_runtime.h:181
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
OC_GLOBAL_HDR
Output configuration set in a global header but not yet locked.
Definition: aac.h:120
convert_header.minor
int minor
Definition: convert_header.py:26
spectral_to_sample
static void spectral_to_sample(AACContext *ac, int samples)
Convert spectral data to samples, applying all supported tools as appropriate.
Definition: aacdec_template.c:3010
AACContext::random_state
int random_state
Definition: aac.h:336
AACContext::mdct480
MDCT15Context * mdct480
Definition: aac.h:332
U
#define U(x)
Definition: vp56_arith.h:37
parse_adts_frame_header
static int parse_adts_frame_header(AACContext *ac, GetBitContext *gb)
Definition: aacdec_template.c:3082
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:849
AVFloatDSPContext::vector_fmul_window
void(* vector_fmul_window)(float *dst, const float *src0, const float *src1, const float *win, int len)
Overlap/add with window function.
Definition: float_dsp.h:119
AV_CH_LAYOUT_22POINT2
#define AV_CH_LAYOUT_22POINT2
Definition: channel_layout.h:118
OutputConfiguration::m4ac
MPEG4AudioConfig m4ac
Definition: aac.h:125
DynamicRangeControl::dyn_rng_sgn
int dyn_rng_sgn[17]
DRC sign information; 0 - positive, 1 - negative.
Definition: aac.h:214
ff_sbr_apply
void AAC_RENAME() ff_sbr_apply(AACContext *ac, SpectralBandReplication *sbr, int id_aac, INTFLOAT *L, INTFLOAT *R)
Apply one SBR element to one AAC element.
Definition: aacsbr_template.c:1475
ff_cbrt_tab
uint32_t ff_cbrt_tab[1<< 13]
pop_output_configuration
static void pop_output_configuration(AACContext *ac)
Restore the previous output configuration if and only if the current configuration is unlocked...
Definition: aacdec_template.c:516
decode_fill
static int decode_fill(AACContext *ac, GetBitContext *gb, int len)
Definition: aacdec_template.c:2486
UPDATE_CACHE
#define UPDATE_CACHE(name, gb)
Definition: get_bits.h:178
SingleChannelElement::predictor_state
PredictorState predictor_state[MAX_PREDICTORS]
Definition: aac.h:269
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
avpriv_float_dsp_alloc
av_cold AVFloatDSPContext * avpriv_float_dsp_alloc(int bit_exact)
Allocate a float DSP context.
Definition: float_dsp.c:135
ff_aac_num_swb_960
const uint8_t ff_aac_num_swb_960[]
Definition: aactab.c:68
relative_align_get_bits
static void relative_align_get_bits(GetBitContext *gb, int reference_position)
Definition: aacdec_template.c:821
ChannelElement::sbr
SpectralBandReplication sbr
Definition: aac.h:288
AACContext::mdct_small
FFTContext mdct_small
Definition: aac.h:325
ChannelCoupling::coupling_point
enum CouplingPoint coupling_point
The point during decoding at which coupling is applied.
Definition: aac.h:236
ff_swb_offset_120
const uint16_t *const ff_swb_offset_120[]
Definition: aactab.c:1397
elem_to_channel::av_position
uint64_t av_position
Definition: aacdec_template.c:193
av_packet_get_side_data
uint8_t * av_packet_get_side_data(const AVPacket *pkt, enum AVPacketSideDataType type, int *size)
Get side information from packet.
Definition: avpacket.c:353
ff_aac_num_swb_1024
const uint8_t ff_aac_num_swb_1024[]
Definition: aactab.c:64
imdct_and_windowing_960
static void imdct_and_windowing_960(AACContext *ac, SingleChannelElement *sce)
Conduct IMDCT and windowing.
Definition: aacdec_template.c:2808
pos
unsigned int pos
Definition: spdifenc.c:410
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:215
AACContext::temp
INTFLOAT temp[128]
Definition: aac.h:355
ff_aac_spectral_sizes
const uint16_t ff_aac_spectral_sizes[11]
Definition: aactab.c:446
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:611
decode_eld_specific_config
static int decode_eld_specific_config(AACContext *ac, AVCodecContext *avctx, GetBitContext *gb, MPEG4AudioConfig *m4ac, int channel_config)
Definition: aacdec_template.c:992
FFTContext::mdct_calc
void(* mdct_calc)(struct FFTContext *s, FFTSample *output, const FFTSample *input)
Definition: fft.h:104
AACADTSHeaderInfo::sampling_index
uint8_t sampling_index
Definition: adts_header.h:34
Pulse::amp
int amp[4]
Definition: aac.h:229
AACContext::apply_ltp
void(* apply_ltp)(AACContext *ac, SingleChannelElement *sce)
Definition: aac.h:365
IndividualChannelStream::max_sfb
uint8_t max_sfb
number of scalefactor bands per group
Definition: aac.h:176
bits
uint8_t bits
Definition: vp3data.h:141
AV_CH_TOP_SIDE_RIGHT
#define AV_CH_TOP_SIDE_RIGHT
Definition: channel_layout.h:75
ff_mdct_init
#define ff_mdct_init
Definition: fft.h:161
ff_aac_eld_window_512
const float ff_aac_eld_window_512[1920]
Definition: aactab.c:1430
TYPE_FIL
Definition: aac.h:63
count
GLsizei count
Definition: opengl_enc.c:108
CLOSE_READER
#define CLOSE_READER(name, gb)
Definition: get_bits.h:149
IndividualChannelStream::num_swb
int num_swb
number of scalefactor window bands
Definition: aac.h:184
count_paired_channels
static int count_paired_channels(uint8_t(*layout_map)[3], int tags, int pos, int *current)
Definition: aacdec_template.c:237
FFMAX
#define FFMAX(a, b)
Definition: common.h:94
fail
#define fail()
Definition: checkasm.h:123
DynamicRangeControl::prog_ref_level
int prog_ref_level
A reference level for the long-term program audio level for all channels combined.
Definition: aac.h:220
OC_LOCKED
Output configuration locked in place.
Definition: aac.h:121
PredictorState
Predictor State.
Definition: aac.h:136
AACADTSHeaderInfo::chan_config
uint8_t chan_config
Definition: adts_header.h:35
VLC
Definition: vlc.h:26
ff_aac_pow2sf_tab
float ff_aac_pow2sf_tab[428]
Definition: aactab.c:39
AVCodecContext::channel_layout
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:1242
SKIP_BITS
#define SKIP_BITS(name, gb, num)
Definition: get_bits.h:193
AV_CH_BOTTOM_FRONT_CENTER
#define AV_CH_BOTTOM_FRONT_CENTER
Definition: channel_layout.h:76
AAC_RENAME
#define AAC_RENAME(x)
Definition: aac_defines.h:85
AACContext::warned_remapping_once
int warned_remapping_once
Definition: aac.h:309
SingleChannelElement::ret_buf
INTFLOAT ret_buf[2048]
PCM output buffer.
Definition: aac.h:265
AOT_ER_AAC_SCALABLE
N Error Resilient Scalable.
Definition: mpeg4audio.h:106
window
static SDL_Window * window
Definition: ffplay.c:368
reset_predictor_group
static void reset_predictor_group(PredictorState *ps, int group_num)
Definition: aacdec_template.c:1191
AV_CH_TOP_CENTER
#define AV_CH_TOP_CENTER
Definition: channel_layout.h:60
b
#define b
Definition: input.c:41
AACContext::apply_tns
void(* apply_tns)(INTFLOAT coef[1024], TemporalNoiseShaping *tns, IndividualChannelStream *ics, int decode)
Definition: aac.h:366
get_che
static ChannelElement * get_che(AACContext *ac, int type, int elem_id)
Definition: aacdec_template.c:652
IndividualChannelStream::window_sequence
enum WindowSequence window_sequence[2]
Definition: aac.h:177
SingleChannelElement::ltp_state
INTFLOAT ltp_state[3072]
time signal for LTP
Definition: aac.h:266
AV_CODEC_FLAG_BITEXACT
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
Definition: avcodec.h:333
ff_aac_num_swb_512
const uint8_t ff_aac_num_swb_512[]
Definition: aactab.c:72
AVCodecContext::err_recognition
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
Definition: avcodec.h:1660
aac_decode_frame
static int aac_decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)
Definition: aacdec_template.c:3427
IndividualChannelStream::predictor_reset_group
int predictor_reset_group
Definition: aac.h:189
ff_aac_spectral_bits
const uint8_t *const ff_aac_spectral_bits[11]
Definition: aactab.c:441
frame_configure_elements
static int frame_configure_elements(AVCodecContext *avctx)
Definition: aacdec_template.c:158
FFMIN
#define FFMIN(a, b)
Definition: common.h:96
DynamicRangeControl::dyn_rng_ctl
int dyn_rng_ctl[17]
DRC magnitude information.
Definition: aac.h:215
AV_SAMPLE_FMT_S32P
signed 32 bits, planar
Definition: samplefmt.h:68
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:99
ltp_coef
static const INTFLOAT ltp_coef[8]
Definition: aactab.h:50
w
uint8_t w
Definition: llviddspenc.c:39
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_template.c:1721
void
typedef void(APIENTRY *FF_PFNGLACTIVETEXTUREPROC)(GLenum texture)
apply_intensity_stereo
static void apply_intensity_stereo(AACContext *ac, ChannelElement *cpe, int ms_present)
intensity stereo decoding; reference: 4.6.8.2.3
Definition: aacdec_template.c:2233
AACADTSHeaderInfo::num_aac_frames
uint8_t num_aac_frames
Definition: adts_header.h:36
Pulse::pos
int pos[4]
Definition: aac.h:228
AACContext::mdct120
MDCT15Context * mdct120
Definition: aac.h:331
AOT_AAC_MAIN
Y Main.
Definition: mpeg4audio.h:90
int32_t
int32_t
Definition: audio_convert.c:194
aac_kbd_short_120
static INTFLOAT aac_kbd_short_120[120]
Definition: aacdec.c:75
show_bits
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
Definition: get_bits.h:446
PREFIX_FOR_22POINT2
#define PREFIX_FOR_22POINT2
Definition: aacdec_template.c:269
AACContext::mdct_ld
FFTContext mdct_ld
Definition: aac.h:326
s
#define s(width, name)
Definition: cbs_vp9.c:257
ff_aacdec_init_mips
void ff_aacdec_init_mips(AACContext *c)
Definition: aacdec_mips.c:433
ff_decode_sbr_extension
int AAC_RENAME() ff_decode_sbr_extension(AACContext *ac, SpectralBandReplication *sbr, GetBitContext *gb, int crc, int cnt, int id_aac)
Decode one SBR element.
Definition: aacsbr_template.c:1111
LAST_SKIP_BITS
#define LAST_SKIP_BITS(name, gb, num)
Definition: get_bits.h:199
get_vlc2
static av_always_inline int get_vlc2(GetBitContext *s, VLC_TYPE(*table)[2], int bits, int max_depth)
Parse a vlc code.
Definition: get_bits.h:797
TemporalNoiseShaping::length
int length[8][4]
Definition: aac.h:202
aac_static_table_init
static av_cold void aac_static_table_init(void)
Definition: aacdec_template.c:1200
ff_aac_sbr_ctx_close
void AAC_RENAME() ff_aac_sbr_ctx_close(SpectralBandReplication *sbr)
Close one SBR context.
Definition: aacsbr_template.c:111
apply_channel_coupling
static void apply_channel_coupling(AACContext *ac, ChannelElement *cc, enum RawDataBlockType type, int elem_id, enum CouplingPoint coupling_point, void(*apply_coupling_method)(AACContext *ac, SingleChannelElement *target, ChannelElement *cce, int index))
channel coupling transformation interface
Definition: aacdec_template.c:2977
AV_CH_FRONT_LEFT_OF_CENTER
#define AV_CH_FRONT_LEFT_OF_CENTER
Definition: channel_layout.h:55
AV_EF_EXPLODE
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: avcodec.h:1671
ff_tns_max_bands_1024
const uint8_t ff_tns_max_bands_1024[]
Definition: aactab.c:1413
GET_VLC
#define GET_VLC(code, name, gb, table, bits, max_depth)
If the vlc code is invalid and max_depth=1, then no bits will be removed.
Definition: get_bits.h:706
compute_lpc_coefs
static int AAC_RENAME() compute_lpc_coefs(const LPC_TYPE *autoc, int max_order, LPC_TYPE *lpc, int lpc_stride, int fail, int normalize)
Levinson-Durbin recursion.
Definition: lpc.h:166
AV_CH_FRONT_CENTER
#define AV_CH_FRONT_CENTER
Definition: channel_layout.h:51
decode_ltp
static void decode_ltp(LongTermPrediction *ltp, GetBitContext *gb, uint8_t max_sfb)
Decode Long Term Prediction data; reference: table 4.xx.
Definition: aacdec_template.c:1387
aac_decode_frame_int
static int aac_decode_frame_int(AVCodecContext *avctx, void *data, int *got_frame_ptr, GetBitContext *gb, AVPacket *avpkt)
Definition: aacdec_template.c:3216
apply_dependent_coupling
static void apply_dependent_coupling(AACContext *ac, SingleChannelElement *target, ChannelElement *cce, int index)
Apply dependent channel coupling (applied before IMDCT).
Definition: aacdec.c:215
decode_spectrum_and_dequant
static int decode_spectrum_and_dequant(AACContext *ac, INTFLOAT coef[1024], GetBitContext *gb, const INTFLOAT sf[120], int pulse_present, const Pulse *pulse, const IndividualChannelStream *ics, enum BandType band_type[120])
Decode spectral data; reference: table 4.50.
Definition: aacdec_template.c:1746
ff_aac_sbr_init
void AAC_RENAME() ff_aac_sbr_init(void)
Initialize SBR.
Definition: aacsbr_template.c:45
DynamicRangeControl::pce_instance_tag
int pce_instance_tag
Indicates with which program the DRC info is associated.
Definition: aac.h:213
AOT_AAC_SSR
N (code in SoC repo) Scalable Sample Rate.
Definition: mpeg4audio.h:92
windowing_and_mdct_ltp
static void windowing_and_mdct_ltp(AACContext *ac, INTFLOAT *out, INTFLOAT *in, IndividualChannelStream *ics)
Apply windowing and MDCT to obtain the spectral coefficient from the predicted sample by LTP...
Definition: aacdec_template.c:2644
AOT_AAC_SCALABLE
N Scalable.
Definition: mpeg4audio.h:95
tns_tmp2_map
static const INTFLOAT *const tns_tmp2_map[4]
Definition: aactab.h:82
elem_to_channel::aac_position
uint8_t aac_position
Definition: aacdec_template.c:196
SHOW_UBITS
#define SHOW_UBITS(name, gb, num)
Definition: get_bits.h:211
push_output_configuration
static int push_output_configuration(AACContext *ac)
Save current output configuration if and only if it has been locked.
Definition: aacdec_template.c:501
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen_template.c:37
AV_CH_FRONT_RIGHT_OF_CENTER
#define AV_CH_FRONT_RIGHT_OF_CENTER
Definition: channel_layout.h:56
DynamicRangeControl::interpolation_scheme
int interpolation_scheme
Indicates the interpolation scheme used in the SBR QMF domain.
Definition: aac.h:218
ChannelCoupling
coupling parameters
Definition: aac.h:235
AACContext::tags_mapped
int tags_mapped
Definition: aac.h:308
reset_all_predictors
static void reset_all_predictors(PredictorState *ps)
Definition: aacdec_template.c:1168
AACContext::mdct960
MDCT15Context * mdct960
Definition: aac.h:333
skip_data_stream_element
static int skip_data_stream_element(AACContext *ac, GetBitContext *gb)
Skip data_stream_element; reference: table 4.10.
Definition: aacdec_template.c:1348
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
VLC::table_allocated
int table_allocated
Definition: vlc.h:29
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
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: aac.h:240
AVCodecContext::frame_size
int frame_size
Number of samples per channel in an audio frame.
Definition: avcodec.h:1211
AACContext::force_dmono_mode
int force_dmono_mode
0->not dmono, 1->use first channel, 2->use second channel
Definition: aac.h:351
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:55
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_template.c:199
TemporalNoiseShaping::order
int order[8][4]
Definition: aac.h:204
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:205
AV_ONCE_INIT
#define AV_ONCE_INIT
Definition: thread.h:173
AACContext::warned_num_aac_frames
int warned_num_aac_frames
Definition: aac.h:358
MDCT15Context::imdct_half
void(* imdct_half)(struct MDCT15Context *s, float *dst, const float *src, ptrdiff_t stride)
Definition: mdct15.h:54
TemporalNoiseShaping
Temporal Noise Shaping.
Definition: aac.h:199
AVCodecContext::sample_rate
int sample_rate
samples per second
Definition: avcodec.h:1191
ff_sine_window_init
void AAC_RENAME() ff_sine_window_init(INTFLOAT *window, int n)
Generate a sine window.
Definition: sinewin_tablegen.h:70
options
static const AVOption options[]
Definition: aacdec_template.c:3537
init_get_bits8
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:677
AV_CH_LAYOUT_NATIVE
#define AV_CH_LAYOUT_NATIVE
Channel mask value used for AVCodecContext.request_channel_layout to indicate that the user requests ...
Definition: channel_layout.h:83
abs
#define abs(x)
Definition: cuda_runtime.h:35
decode_scalefactors
static int decode_scalefactors(AACContext *ac, INTFLOAT sf[120], GetBitContext *gb, unsigned int global_gain, IndividualChannelStream *ics, enum BandType band_type[120], int band_type_run_end[120])
Decode scalefactors; reference: table 4.47.
Definition: aacdec_template.c:1576
AVCodecContext::debug
int debug
debug
Definition: avcodec.h:1616
decode_cpe
static int decode_cpe(AACContext *ac, GetBitContext *gb, ChannelElement *cpe)
Decode a channel_pair_element; reference: table 4.4.
Definition: aacdec_template.c:2283
LongTermPrediction
Long Term Prediction.
Definition: aac.h:164
apply_tns
static void apply_tns(INTFLOAT coef_param[1024], TemporalNoiseShaping *tns, IndividualChannelStream *ics, int decode)
Decode Temporal Noise Shaping filter coefficients and apply all-pole filters; reference: 4...
Definition: aacdec_template.c:2584
AVCodecContext
main external API structure.
Definition: avcodec.h:531
AV_CH_FRONT_LEFT
#define AV_CH_FRONT_LEFT
Definition: channel_layout.h:49
AVCodecInternal::skip_samples_multiplier
int skip_samples_multiplier
Definition: internal.h:194
NOISE_PRE_BITS
#define NOISE_PRE_BITS
length of preamble
Definition: aac.h:158
OPEN_READER
#define OPEN_READER(name, gb)
Definition: get_bits.h:138
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1876
SingleChannelElement::ics
IndividualChannelStream ics
Definition: aac.h:250
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:206
AVFloatDSPContext::butterflies_float
void(* butterflies_float)(float *av_restrict v1, float *av_restrict v2, int len)
Calculate the sum and difference of two vectors of floats.
Definition: float_dsp.h:164
MAX_PREDICTORS
#define MAX_PREDICTORS
Definition: aac.h:147
cbrtf
static av_always_inline float cbrtf(float x)
Definition: libm.h:61
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:633
ff_aac_sbr_ctx_init
void AAC_RENAME() ff_aac_sbr_ctx_init(AACContext *ac, SpectralBandReplication *sbr, int id_aac)
Initialize one SBR context.
Definition: aacsbr_template.c:92
IndividualChannelStream::group_len
uint8_t group_len[8]
Definition: aac.h:180
AVERROR_BUG
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
Definition: error.h:50
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
in
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(const int16_t *) pi >> 8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t,*(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t,*(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(const int32_t *) pi >> 24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t,*(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t,*(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31))))#define SET_CONV_FUNC_GROUP(ofmt, ifmt) static void set_generic_function(AudioConvert *ac){}void ff_audio_convert_free(AudioConvert **ac){if(!*ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);}AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, int sample_rate, int apply_map){AudioConvert *ac;int in_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) return NULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method!=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt) > 2){ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc){av_free(ac);return NULL;}return ac;}in_planar=ff_sample_fmt_is_planar(in_fmt, channels);out_planar=ff_sample_fmt_is_planar(out_fmt, channels);if(in_planar==out_planar){ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar?ac->channels:1;}else if(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;else ac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_AARCH64) ff_audio_convert_init_aarch64(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);return ac;}int ff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in){int use_generic=1;int len=in->nb_samples;int p;if(ac->dc){av_log(ac->avr, AV_LOG_TRACE,"%d samples - audio_convert: %s to %s (dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));return ff_convert_dither(ac-> in
Definition: audio_convert.c:194
skip_bits1
static void skip_bits1(GetBitContext *s)
Definition: get_bits.h:538
AV_CH_TOP_BACK_RIGHT
#define AV_CH_TOP_BACK_RIGHT
Definition: channel_layout.h:66
MAX_ELEM_ID
#define MAX_ELEM_ID
Definition: aac.h:49
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:67
AVFrame::sample_rate
int sample_rate
Sample rate of the audio data.
Definition: frame.h:486
aac_decode_close
static av_cold int aac_decode_close(AVCodecContext *avctx)
Definition: aacdec_template.c:3490
skip_bits
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:467
decode_audio_specific_config
static int decode_audio_specific_config(AACContext *ac, AVCodecContext *avctx, MPEG4AudioConfig *m4ac, const uint8_t *data, int64_t bit_size, int sync_extension)
Definition: aacdec_template.c:1129
AAC_MUL30
#define AAC_MUL30(x, y)
Definition: aac_defines.h:103
sniff_channel_order
static uint64_t sniff_channel_order(uint8_t(*layout_map)[3], int tags)
Definition: aacdec_template.c:270
AAC_KBD_RENAME
#define AAC_KBD_RENAME(x)
Definition: aac_defines.h:87
ff_swb_offset_960
const uint16_t *const ff_swb_offset_960[]
Definition: aactab.c:1363
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_template.c:2420
index
int index
Definition: gxfenc.c:89
noise_scale
static void noise_scale(int *coefs, int scale, int band_energy, int len)
Definition: aacdec_fixed.c:199
AACContext::warned_71_wide
unsigned warned_71_wide
Definition: aac.h:360
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_template.c:833
init_get_bits
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:659
GET_CACHE
#define GET_CACHE(name, gb)
Definition: get_bits.h:215
elem_to_channel::syn_ele
uint8_t syn_ele
Definition: aacdec_template.c:194
AVFloatDSPContext::vector_fmul_scalar
void(* vector_fmul_scalar)(float *dst, const float *src, float mul, int len)
Multiply a vector of floats by a scalar float.
Definition: float_dsp.h:85
VMUL2
static float * VMUL2(float *dst, const float *v, unsigned idx, const float *scale)
Definition: aacdec.c:88
OCStatus
OCStatus
Output configuration status.
Definition: aac.h:116
AVCodecInternal::skip_samples
int skip_samples
Number of audio samples to skip at the start of the next decoded frame.
Definition: internal.h:164
MAX_CHANNELS
#define MAX_CHANNELS
Definition: aac.h:48
AOT_ER_BSAC
N Error Resilient Bit-Sliced Arithmetic Coding.
Definition: mpeg4audio.h:108
TNS_MAX_ORDER
#define TNS_MAX_ORDER
Definition: aac.h:51
FF_COMPLIANCE_STRICT
#define FF_COMPLIANCE_STRICT
Strictly conform to all the things in the spec no matter what consequences.
Definition: avcodec.h:1596
AACContext
main AAC context
Definition: aac.h:294
ff_aac_scalefactor_code
const uint32_t ff_aac_scalefactor_code[121]
Definition: aactab.c:92
IndividualChannelStream::ltp
LongTermPrediction ltp
Definition: aac.h:181
FFTContext::imdct_half
void(* imdct_half)(struct FFTContext *s, FFTSample *output, const FFTSample *input)
Definition: fft.h:103
ChannelElement::coup
ChannelCoupling coup
Definition: aac.h:287
OC_TRIAL_FRAME
Output configuration under trial specified by a frame header.
Definition: aac.h:119
convert_header.major
int major
Definition: convert_header.py:23
MPEG4AudioConfig::frame_length_short
int frame_length_short
Definition: mpeg4audio.h:45
decode_prediction
static int decode_prediction(AACContext *ac, IndividualChannelStream *ics, GetBitContext *gb)
Definition: aacdec_template.c:1365
ff_tns_max_bands_128
const uint8_t ff_tns_max_bands_128[]
Definition: aactab.c:1425
NOISE_OFFSET
#define NOISE_OFFSET
subtracted from global gain, used as offset for the preamble
Definition: aac.h:159
imdct_and_window
static void imdct_and_window(TwinVQContext *tctx, enum TwinVQFrameType ftype, int wtype, float *in, float *prev, int ch)
Definition: twinvq.c:327
av_frame_unref
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:553
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.
AV_CH_BOTTOM_FRONT_RIGHT
#define AV_CH_BOTTOM_FRONT_RIGHT
Definition: channel_layout.h:78
SingleChannelElement::band_type_run_end
int band_type_run_end[120]
band type run end points
Definition: aac.h:255
code
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some it can consider them to be part of the FIFO and delay acknowledging a status change accordingly Example code
Definition: filter_design.txt:172
decode_band_types
static int decode_band_types(AACContext *ac, enum BandType band_type[120], int band_type_run_end[120], GetBitContext *gb, IndividualChannelStream *ics)
Decode band types (section_data payload); reference: table 4.46.
Definition: aacdec_template.c:1527
AV_CH_BACK_CENTER
#define AV_CH_BACK_CENTER
Definition: channel_layout.h:57
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:328
DynamicRangeControl::band_top
int band_top[17]
Indicates the top of the i-th DRC band in units of 4 spectral lines.
Definition: aac.h:219
AV_CH_SIDE_RIGHT
#define AV_CH_SIDE_RIGHT
Definition: channel_layout.h:59
SingleChannelElement::coeffs
INTFLOAT coeffs[1024]
coefficients for IMDCT, maybe processed
Definition: aac.h:263
avpriv_alloc_fixed_dsp
AVFixedDSPContext * avpriv_alloc_fixed_dsp(int bit_exact)
Allocate and initialize a fixed DSP context.
Definition: fixed_dsp.c:149
vlc_spectral
static VLC vlc_spectral[11]
Definition: aacdec_template.c:95
OutputConfiguration::status
enum OCStatus status
Definition: aac.h:130
ChannelCoupling::gain
INTFLOAT gain[16][120]
Definition: aac.h:243
INTENSITY_BT2
Scalefactor data are intensity stereo positions (out of phase).
Definition: aac.h:89
AOT_ER_AAC_ELD
N Error Resilient Enhanced Low Delay.
Definition: mpeg4audio.h:125
M_SQRT2
#define M_SQRT2
Definition: mathematics.h:61
RANGE15
#define RANGE15(x)
Definition: aac_defines.h:99
TemporalNoiseShaping::coef
INTFLOAT coef[8][4][TNS_MAX_ORDER]
Definition: aac.h:206
LongTermPrediction::lag
int16_t lag
Definition: aac.h:166
ff_aac_num_swb_120
const uint8_t ff_aac_num_swb_120[]
Definition: aactab.c:84
AACContext::che_drc
DynamicRangeControl che_drc
Definition: aac.h:300
reset_predict_state
static av_always_inline void reset_predict_state(PredictorState *ps)
Definition: aacdec.c:77
AACContext::frame
AVFrame * frame
Definition: aac.h:297
AACContext::oc
OutputConfiguration oc[2]
Definition: aac.h:357
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:166
int
int
Definition: ffmpeg_filter.c:193
ff_aac_pred_sfb_max
const uint8_t ff_aac_pred_sfb_max[]
Definition: aactab.c:88
TemporalNoiseShaping::direction
int direction[8][4]
Definition: aac.h:203
IndividualChannelStream::prediction_used
uint8_t prediction_used[41]
Definition: aac.h:191
filt
static const int8_t filt[NUMTAPS *2]
Definition: af_earwax.c:39
ff_aac_eld_window_480
const float ff_aac_eld_window_480[1800]
Definition: aactab.c:2397
SingleChannelElement::saved
INTFLOAT saved[1536]
overlap
Definition: aac.h:264
SingleChannelElement
Single Channel Element - used for both SCE and LFE elements.
Definition: aac.h:249
ff_mdct_end
#define ff_mdct_end
Definition: fft.h:162
ff_aac_num_swb_480
const uint8_t ff_aac_num_swb_480[]
Definition: aactab.c:76
ff_swb_offset_1024
const uint16_t *const ff_swb_offset_1024[]
Definition: aactab.c:1355
AAC_SIGNE
unsigned AAC_SIGNE
Definition: aac_defines.h:93
AACContext::vector_pow43
void(* vector_pow43)(int *coefs, int len)
Definition: aac.h:371
TYPE_PCE
Definition: aac.h:62
IndividualChannelStream
Individual Channel Stream.
Definition: aac.h:175
LongTermPrediction::coef
INTFLOAT coef
Definition: aac.h:168
AVERROR_UNKNOWN
#define AVERROR_UNKNOWN
Unknown error, typically from an external library.
Definition: error.h:71
ff_aac_codebook_vector_idx
const uint16_t *const ff_aac_codebook_vector_idx[]
Definition: aactab.c:1102
AACContext::update_ltp
void(* update_ltp)(AACContext *ac, SingleChannelElement *sce)
Definition: aac.h:370
ff_mdct15_uninit
av_cold void ff_mdct15_uninit(MDCT15Context **ps)
Definition: mdct15.c:43
ChannelElement
channel element - generic struct for SCE/CPE/CCE/LFE
Definition: aac.h:276
decode_gain_control
static void decode_gain_control(SingleChannelElement *sce, GetBitContext *gb)
Definition: aacdec_template.c:2069
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:558
ff_aac_spectral_codes
const uint16_t *const ff_aac_spectral_codes[11]
Definition: aactab.c:436
subband_scale
static void subband_scale(int *dst, int *src, int scale, int offset, int len, void *log_context)
Definition: aacdec_fixed.c:168
AACContext::warned_gain_control
int warned_gain_control
Definition: aac.h:361
decode_ics
static int decode_ics(AACContext *ac, SingleChannelElement *sce, GetBitContext *gb, int common_window, int scale_flag)
Decode an individual_channel_stream payload; reference: table 4.44.
Definition: aacdec_template.c:2104
FF_DEBUG_STARTCODE
#define FF_DEBUG_STARTCODE
Definition: avcodec.h:1630
ff_tns_max_bands_512
const uint8_t ff_tns_max_bands_512[]
Definition: aactab.c:1417
len
int len
Definition: vorbis_enc_data.h:452
ZERO_BT
Scalefactors and spectral data are all zero.
Definition: aac.h:84
AVCodecContext::channels
int channels
number of audio channels
Definition: avcodec.h:1192
Pulse::num_pulse
int num_pulse
Definition: aac.h:226
DEC_SPAIR
static int * DEC_SPAIR(int *dst, unsigned idx)
Definition: aacdec_fixed.c:110
AVCodecContext::internal
struct AVCodecInternal * internal
Private context used for internal data.
Definition: avcodec.h:566
ff_thread_once
static int ff_thread_once(char *control, void(*routine)(void))
Definition: thread.h:175
VLC::table
VLC_TYPE(* table)[2]
code, bits
Definition: vlc.h:28
AOT_AAC_LTP
Y Long Term Prediction.
Definition: mpeg4audio.h:93
AACContext::subband_scale
void(* subband_scale)(int *dst, int *src, int scale, int offset, int len, void *log_context)
Definition: aac.h:372
AACADTSHeaderInfo::crc_absent
uint8_t crc_absent
Definition: adts_header.h:32
align_get_bits
static const uint8_t * align_get_bits(GetBitContext *s)
Definition: get_bits.h:693
FF_PROFILE_AAC_HE
#define FF_PROFILE_AAC_HE
Definition: avcodec.h:1879
SingleChannelElement::band_type
enum BandType band_type[128]
band types
Definition: aac.h:253
decode_dynamic_range
static int decode_dynamic_range(DynamicRangeControl *che_drc, GetBitContext *gb)
Decode dynamic range information; reference: table 4.52.
Definition: aacdec_template.c:2439
vlc_buf
static VLC_TYPE vlc_buf[16716][2]
Definition: clearvideo.c:86
AV_CH_FRONT_RIGHT
#define AV_CH_FRONT_RIGHT
Definition: channel_layout.h:50
POW_SF2_ZERO
#define POW_SF2_ZERO
ff_aac_pow2sf_tab index corresponding to pow(2, 0);
Definition: aac.h:155
imdct_and_windowing_ld
static void imdct_and_windowing_ld(AACContext *ac, SingleChannelElement *sce)
Definition: aacdec_template.c:2871
AACContext::windowing_and_mdct_ltp
void(* windowing_and_mdct_ltp)(AACContext *ac, INTFLOAT *out, INTFLOAT *in, IndividualChannelStream *ics)
Definition: aac.h:368
out
FILE * out
Definition: movenc.c:54
samples
Filter the word “frame” indicates either a video frame or a group of audio samples
Definition: filter_design.txt:2
AACContext::mdct
FFTContext mdct
Definition: aac.h:324
MPEG4AudioConfig::sbr
int sbr
-1 implicit, 1 presence
Definition: mpeg4audio.h:38
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
av_always_inline
#define av_always_inline
Definition: attributes.h:45
apply_mid_side_stereo
static void apply_mid_side_stereo(AACContext *ac, ChannelElement *cpe)
Mid/Side stereo decoding; reference: 4.6.8.1.3.
Definition: aacdec_template.c:2195
AACContext::imdct_and_windowing
void(* imdct_and_windowing)(AACContext *ac, SingleChannelElement *sce)
Definition: aac.h:364
VLC_TYPE
#define VLC_TYPE
Definition: vlc.h:24
AV_CH_SIDE_LEFT
#define AV_CH_SIDE_LEFT
Definition: channel_layout.h:58
FFSWAP
#define FFSWAP(type, a, b)
Definition: common.h:99
MPEG4AudioConfig::ps
int ps
-1 implicit, 1 presence
Definition: mpeg4audio.h:44
LongTermPrediction::used
int8_t used[MAX_LTP_LONG_SFB]
Definition: aac.h:169
ff_swb_offset_128
const uint16_t *const ff_swb_offset_128[]
Definition: aactab.c:1387
LongTermPrediction::present
int8_t present
Definition: aac.h:165
AACADTSHeaderInfo::sample_rate
uint32_t sample_rate
Definition: adts_header.h:29
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
aac_decoder_class
static const AVClass aac_decoder_class
Definition: aacdec_template.c:3550
AVFrame::extended_data
uint8_t ** extended_data
pointers to the data planes/channels.
Definition: frame.h:361
AVCodecContext::request_channel_layout
uint64_t request_channel_layout
Request decoder to use this channel layout if it can (0 for default)
Definition: avcodec.h:1249
OutputConfiguration::layout_map_tags
int layout_map_tags
Definition: aac.h:127
id
enum AVCodecID id
Definition: extract_extradata_bsf.c:325
INIT_VLC_STATIC_OVERLONG
#define INIT_VLC_STATIC_OVERLONG
Definition: vlc.h:96
AVPacket
This structure stores compressed data.
Definition: packet.h:340
mode
mode
Use these values in ebur128_init (or&#39;ed).
Definition: ebur128.h:83
AVFrame::nb_samples
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:380
AVCodecContext::strict_std_compliance
int strict_std_compliance
strictly follow the standard (MPEG-4, ...).
Definition: avcodec.h:1594
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:12
i
int i
Definition: input.c:407
ff_init_ff_sine_windows
void AAC_RENAME() ff_init_ff_sine_windows(int index)
initialize the specified entry of ff_sine_windows
Definition: sinewin_tablegen.h:111
DEC_UQUAD
static int * DEC_UQUAD(int *dst, unsigned idx, unsigned sign)
Definition: aacdec_fixed.c:136
AV_CH_BACK_RIGHT
#define AV_CH_BACK_RIGHT
Definition: channel_layout.h:54
AOT_AAC_LC
Y Low Complexity.
Definition: mpeg4audio.h:91
VMUL4
static float * VMUL4(float *dst, const float *v, unsigned idx, const float *scale)
Definition: aacdec.c:99
OC_NONE
Output unconfigured.
Definition: aac.h:117
RawDataBlockType
RawDataBlockType
Definition: aac.h:56
AVFloatDSPContext::vector_fmul_reverse
void(* vector_fmul_reverse)(float *dst, const float *src0, const float *src1, int len)
Calculate the entry wise product of two vectors of floats, and store the result in a vector of floats...
Definition: float_dsp.h:154
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:27
Generated on Tue Jan 19 2021 19:21:39 for FFmpeg by   doxygen 1.8.11