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) {
643  layout_map[2][2] = AAC_CHANNEL_SIDE;
644 
645  if (!ac || !ac->warned_71_wide++) {
646  av_log(avctx, AV_LOG_INFO, "Assuming an incorrectly encoded 7.1 channel layout"
647  " instead of a spec-compliant 7.1(wide) layout, use -strict %d to decode"
648  " according to the specification instead.\n", FF_COMPLIANCE_STRICT);
649  }
650  }
651 
652  return 0;
653 }
654 
655 static ChannelElement *get_che(AACContext *ac, int type, int elem_id)
656 {
657  /* For PCE based channel configurations map the channels solely based
658  * on tags. */
659  if (!ac->oc[1].m4ac.chan_config) {
660  return ac->tag_che_map[type][elem_id];
661  }
662  // Allow single CPE stereo files to be signalled with mono configuration.
663  if (!ac->tags_mapped && type == TYPE_CPE &&
664  ac->oc[1].m4ac.chan_config == 1) {
665  uint8_t layout_map[MAX_ELEM_ID*4][3];
666  int layout_map_tags;
667  push_output_configuration(ac);
668 
669  av_log(ac->avctx, AV_LOG_DEBUG, "mono with CPE\n");
670 
671  if (set_default_channel_config(ac, ac->avctx, layout_map,
672  &layout_map_tags, 2) < 0)
673  return NULL;
674  if (output_configure(ac, layout_map, layout_map_tags,
675  OC_TRIAL_FRAME, 1) < 0)
676  return NULL;
677 
678  ac->oc[1].m4ac.chan_config = 2;
679  ac->oc[1].m4ac.ps = 0;
680  }
681  // And vice-versa
682  if (!ac->tags_mapped && type == TYPE_SCE &&
683  ac->oc[1].m4ac.chan_config == 2) {
684  uint8_t layout_map[MAX_ELEM_ID * 4][3];
685  int layout_map_tags;
686  push_output_configuration(ac);
687 
688  av_log(ac->avctx, AV_LOG_DEBUG, "stereo with SCE\n");
689 
690  if (set_default_channel_config(ac, ac->avctx, layout_map,
691  &layout_map_tags, 1) < 0)
692  return NULL;
693  if (output_configure(ac, layout_map, layout_map_tags,
694  OC_TRIAL_FRAME, 1) < 0)
695  return NULL;
696 
697  ac->oc[1].m4ac.chan_config = 1;
698  if (ac->oc[1].m4ac.sbr)
699  ac->oc[1].m4ac.ps = -1;
700  }
701  /* For indexed channel configurations map the channels solely based
702  * on position. */
703  switch (ac->oc[1].m4ac.chan_config) {
704  case 13:
705  if (ac->tags_mapped > 3 && ((type == TYPE_CPE && elem_id < 8) ||
706  (type == TYPE_SCE && elem_id < 6) ||
707  (type == TYPE_LFE && elem_id < 2))) {
708  ac->tags_mapped++;
709  return ac->tag_che_map[type][elem_id] = ac->che[type][elem_id];
710  }
711  case 12:
712  case 7:
713  if (ac->tags_mapped == 3 && type == TYPE_CPE) {
714  ac->tags_mapped++;
715  return ac->tag_che_map[TYPE_CPE][elem_id] = ac->che[TYPE_CPE][2];
716  }
717  case 11:
718  if (ac->tags_mapped == 2 &&
719  ac->oc[1].m4ac.chan_config == 11 &&
720  type == TYPE_SCE) {
721  ac->tags_mapped++;
722  return ac->tag_che_map[TYPE_SCE][elem_id] = ac->che[TYPE_SCE][1];
723  }
724  case 6:
725  /* Some streams incorrectly code 5.1 audio as
726  * SCE[0] CPE[0] CPE[1] SCE[1]
727  * instead of
728  * SCE[0] CPE[0] CPE[1] LFE[0].
729  * If we seem to have encountered such a stream, transfer
730  * the LFE[0] element to the SCE[1]'s mapping */
731  if (ac->tags_mapped == tags_per_config[ac->oc[1].m4ac.chan_config] - 1 && (type == TYPE_LFE || type == TYPE_SCE)) {
732  if (!ac->warned_remapping_once && (type != TYPE_LFE || elem_id != 0)) {
733  av_log(ac->avctx, AV_LOG_WARNING,
734  "This stream seems to incorrectly report its last channel as %s[%d], mapping to LFE[0]\n",
735  type == TYPE_SCE ? "SCE" : "LFE", elem_id);
736  ac->warned_remapping_once++;
737  }
738  ac->tags_mapped++;
739  return ac->tag_che_map[type][elem_id] = ac->che[TYPE_LFE][0];
740  }
741  case 5:
742  if (ac->tags_mapped == 2 && type == TYPE_CPE) {
743  ac->tags_mapped++;
744  return ac->tag_che_map[TYPE_CPE][elem_id] = ac->che[TYPE_CPE][1];
745  }
746  case 4:
747  /* Some streams incorrectly code 4.0 audio as
748  * SCE[0] CPE[0] LFE[0]
749  * instead of
750  * SCE[0] CPE[0] SCE[1].
751  * If we seem to have encountered such a stream, transfer
752  * the SCE[1] element to the LFE[0]'s mapping */
753  if (ac->tags_mapped == tags_per_config[ac->oc[1].m4ac.chan_config] - 1 && (type == TYPE_LFE || type == TYPE_SCE)) {
754  if (!ac->warned_remapping_once && (type != TYPE_SCE || elem_id != 1)) {
755  av_log(ac->avctx, AV_LOG_WARNING,
756  "This stream seems to incorrectly report its last channel as %s[%d], mapping to SCE[1]\n",
757  type == TYPE_SCE ? "SCE" : "LFE", elem_id);
758  ac->warned_remapping_once++;
759  }
760  ac->tags_mapped++;
761  return ac->tag_che_map[type][elem_id] = ac->che[TYPE_SCE][1];
762  }
763  if (ac->tags_mapped == 2 &&
764  ac->oc[1].m4ac.chan_config == 4 &&
765  type == TYPE_SCE) {
766  ac->tags_mapped++;
767  return ac->tag_che_map[TYPE_SCE][elem_id] = ac->che[TYPE_SCE][1];
768  }
769  case 3:
770  case 2:
771  if (ac->tags_mapped == (ac->oc[1].m4ac.chan_config != 2) &&
772  type == TYPE_CPE) {
773  ac->tags_mapped++;
774  return ac->tag_che_map[TYPE_CPE][elem_id] = ac->che[TYPE_CPE][0];
775  } else if (ac->oc[1].m4ac.chan_config == 2) {
776  return NULL;
777  }
778  case 1:
779  if (!ac->tags_mapped && type == TYPE_SCE) {
780  ac->tags_mapped++;
781  return ac->tag_che_map[TYPE_SCE][elem_id] = ac->che[TYPE_SCE][0];
782  }
783  default:
784  return NULL;
785  }
786 }
787 
788 /**
789  * Decode an array of 4 bit element IDs, optionally interleaved with a
790  * stereo/mono switching bit.
791  *
792  * @param type speaker type/position for these channels
793  */
794 static void decode_channel_map(uint8_t layout_map[][3],
795  enum ChannelPosition type,
796  GetBitContext *gb, int n)
797 {
798  while (n--) {
799  enum RawDataBlockType syn_ele;
800  switch (type) {
801  case AAC_CHANNEL_FRONT:
802  case AAC_CHANNEL_BACK:
803  case AAC_CHANNEL_SIDE:
804  syn_ele = get_bits1(gb);
805  break;
806  case AAC_CHANNEL_CC:
807  skip_bits1(gb);
808  syn_ele = TYPE_CCE;
809  break;
810  case AAC_CHANNEL_LFE:
811  syn_ele = TYPE_LFE;
812  break;
813  default:
814  // AAC_CHANNEL_OFF has no channel map
815  av_assert0(0);
816  }
817  layout_map[0][0] = syn_ele;
818  layout_map[0][1] = get_bits(gb, 4);
819  layout_map[0][2] = type;
820  layout_map++;
821  }
822 }
823 
824 static inline void relative_align_get_bits(GetBitContext *gb,
825  int reference_position) {
826  int n = (reference_position - get_bits_count(gb) & 7);
827  if (n)
828  skip_bits(gb, n);
829 }
830 
831 /**
832  * Decode program configuration element; reference: table 4.2.
833  *
834  * @return Returns error status. 0 - OK, !0 - error
835  */
836 static int decode_pce(AVCodecContext *avctx, MPEG4AudioConfig *m4ac,
837  uint8_t (*layout_map)[3],
838  GetBitContext *gb, int byte_align_ref)
839 {
840  int num_front, num_side, num_back, num_lfe, num_assoc_data, num_cc;
841  int sampling_index;
842  int comment_len;
843  int tags;
844 
845  skip_bits(gb, 2); // object_type
846 
847  sampling_index = get_bits(gb, 4);
848  if (m4ac->sampling_index != sampling_index)
849  av_log(avctx, AV_LOG_WARNING,
850  "Sample rate index in program config element does not "
851  "match the sample rate index configured by the container.\n");
852 
853  num_front = get_bits(gb, 4);
854  num_side = get_bits(gb, 4);
855  num_back = get_bits(gb, 4);
856  num_lfe = get_bits(gb, 2);
857  num_assoc_data = get_bits(gb, 3);
858  num_cc = get_bits(gb, 4);
859 
860  if (get_bits1(gb))
861  skip_bits(gb, 4); // mono_mixdown_tag
862  if (get_bits1(gb))
863  skip_bits(gb, 4); // stereo_mixdown_tag
864 
865  if (get_bits1(gb))
866  skip_bits(gb, 3); // mixdown_coeff_index and pseudo_surround
867 
868  if (get_bits_left(gb) < 5 * (num_front + num_side + num_back + num_cc) + 4 *(num_lfe + num_assoc_data + num_cc)) {
869  av_log(avctx, AV_LOG_ERROR, "decode_pce: " overread_err);
870  return -1;
871  }
872  decode_channel_map(layout_map , AAC_CHANNEL_FRONT, gb, num_front);
873  tags = num_front;
874  decode_channel_map(layout_map + tags, AAC_CHANNEL_SIDE, gb, num_side);
875  tags += num_side;
876  decode_channel_map(layout_map + tags, AAC_CHANNEL_BACK, gb, num_back);
877  tags += num_back;
878  decode_channel_map(layout_map + tags, AAC_CHANNEL_LFE, gb, num_lfe);
879  tags += num_lfe;
880 
881  skip_bits_long(gb, 4 * num_assoc_data);
882 
883  decode_channel_map(layout_map + tags, AAC_CHANNEL_CC, gb, num_cc);
884  tags += num_cc;
885 
886  relative_align_get_bits(gb, byte_align_ref);
887 
888  /* comment field, first byte is length */
889  comment_len = get_bits(gb, 8) * 8;
890  if (get_bits_left(gb) < comment_len) {
891  av_log(avctx, AV_LOG_ERROR, "decode_pce: " overread_err);
892  return AVERROR_INVALIDDATA;
893  }
894  skip_bits_long(gb, comment_len);
895  return tags;
896 }
897 
898 /**
899  * Decode GA "General Audio" specific configuration; reference: table 4.1.
900  *
901  * @param ac pointer to AACContext, may be null
902  * @param avctx pointer to AVCCodecContext, used for logging
903  *
904  * @return Returns error status. 0 - OK, !0 - error
905  */
906 static int decode_ga_specific_config(AACContext *ac, AVCodecContext *avctx,
907  GetBitContext *gb,
908  int get_bit_alignment,
909  MPEG4AudioConfig *m4ac,
910  int channel_config)
911 {
912  int extension_flag, ret, ep_config, res_flags;
913  uint8_t layout_map[MAX_ELEM_ID*4][3];
914  int tags = 0;
915 
916 #if USE_FIXED
917  if (get_bits1(gb)) { // frameLengthFlag
918  avpriv_report_missing_feature(avctx, "Fixed point 960/120 MDCT window");
919  return AVERROR_PATCHWELCOME;
920  }
921  m4ac->frame_length_short = 0;
922 #else
923  m4ac->frame_length_short = get_bits1(gb);
924  if (m4ac->frame_length_short && m4ac->sbr == 1) {
925  avpriv_report_missing_feature(avctx, "SBR with 960 frame length");
926  if (ac) ac->warned_960_sbr = 1;
927  m4ac->sbr = 0;
928  m4ac->ps = 0;
929  }
930 #endif
931 
932  if (get_bits1(gb)) // dependsOnCoreCoder
933  skip_bits(gb, 14); // coreCoderDelay
934  extension_flag = get_bits1(gb);
935 
936  if (m4ac->object_type == AOT_AAC_SCALABLE ||
937  m4ac->object_type == AOT_ER_AAC_SCALABLE)
938  skip_bits(gb, 3); // layerNr
939 
940  if (channel_config == 0) {
941  skip_bits(gb, 4); // element_instance_tag
942  tags = decode_pce(avctx, m4ac, layout_map, gb, get_bit_alignment);
943  if (tags < 0)
944  return tags;
945  } else {
946  if ((ret = set_default_channel_config(ac, avctx, layout_map,
947  &tags, channel_config)))
948  return ret;
949  }
950 
951  if (count_channels(layout_map, tags) > 1) {
952  m4ac->ps = 0;
953  } else if (m4ac->sbr == 1 && m4ac->ps == -1)
954  m4ac->ps = 1;
955 
956  if (ac && (ret = output_configure(ac, layout_map, tags, OC_GLOBAL_HDR, 0)))
957  return ret;
958 
959  if (extension_flag) {
960  switch (m4ac->object_type) {
961  case AOT_ER_BSAC:
962  skip_bits(gb, 5); // numOfSubFrame
963  skip_bits(gb, 11); // layer_length
964  break;
965  case AOT_ER_AAC_LC:
966  case AOT_ER_AAC_LTP:
967  case AOT_ER_AAC_SCALABLE:
968  case AOT_ER_AAC_LD:
969  res_flags = get_bits(gb, 3);
970  if (res_flags) {
971  avpriv_report_missing_feature(avctx,
972  "AAC data resilience (flags %x)",
973  res_flags);
974  return AVERROR_PATCHWELCOME;
975  }
976  break;
977  }
978  skip_bits1(gb); // extensionFlag3 (TBD in version 3)
979  }
980  switch (m4ac->object_type) {
981  case AOT_ER_AAC_LC:
982  case AOT_ER_AAC_LTP:
983  case AOT_ER_AAC_SCALABLE:
984  case AOT_ER_AAC_LD:
985  ep_config = get_bits(gb, 2);
986  if (ep_config) {
987  avpriv_report_missing_feature(avctx,
988  "epConfig %d", ep_config);
989  return AVERROR_PATCHWELCOME;
990  }
991  }
992  return 0;
993 }
994 
995 static int decode_eld_specific_config(AACContext *ac, AVCodecContext *avctx,
996  GetBitContext *gb,
997  MPEG4AudioConfig *m4ac,
998  int channel_config)
999 {
1000  int ret, ep_config, res_flags;
1001  uint8_t layout_map[MAX_ELEM_ID*4][3];
1002  int tags = 0;
1003  const int ELDEXT_TERM = 0;
1004 
1005  m4ac->ps = 0;
1006  m4ac->sbr = 0;
1007 #if USE_FIXED
1008  if (get_bits1(gb)) { // frameLengthFlag
1009  avpriv_request_sample(avctx, "960/120 MDCT window");
1010  return AVERROR_PATCHWELCOME;
1011  }
1012 #else
1013  m4ac->frame_length_short = get_bits1(gb);
1014 #endif
1015  res_flags = get_bits(gb, 3);
1016  if (res_flags) {
1017  avpriv_report_missing_feature(avctx,
1018  "AAC data resilience (flags %x)",
1019  res_flags);
1020  return AVERROR_PATCHWELCOME;
1021  }
1022 
1023  if (get_bits1(gb)) { // ldSbrPresentFlag
1024  avpriv_report_missing_feature(avctx,
1025  "Low Delay SBR");
1026  return AVERROR_PATCHWELCOME;
1027  }
1028 
1029  while (get_bits(gb, 4) != ELDEXT_TERM) {
1030  int len = get_bits(gb, 4);
1031  if (len == 15)
1032  len += get_bits(gb, 8);
1033  if (len == 15 + 255)
1034  len += get_bits(gb, 16);
1035  if (get_bits_left(gb) < len * 8 + 4) {
1036  av_log(avctx, AV_LOG_ERROR, overread_err);
1037  return AVERROR_INVALIDDATA;
1038  }
1039  skip_bits_long(gb, 8 * len);
1040  }
1041 
1042  if ((ret = set_default_channel_config(ac, avctx, layout_map,
1043  &tags, channel_config)))
1044  return ret;
1045 
1046  if (ac && (ret = output_configure(ac, layout_map, tags, OC_GLOBAL_HDR, 0)))
1047  return ret;
1048 
1049  ep_config = get_bits(gb, 2);
1050  if (ep_config) {
1051  avpriv_report_missing_feature(avctx,
1052  "epConfig %d", ep_config);
1053  return AVERROR_PATCHWELCOME;
1054  }
1055  return 0;
1056 }
1057 
1058 /**
1059  * Decode audio specific configuration; reference: table 1.13.
1060  *
1061  * @param ac pointer to AACContext, may be null
1062  * @param avctx pointer to AVCCodecContext, used for logging
1063  * @param m4ac pointer to MPEG4AudioConfig, used for parsing
1064  * @param gb buffer holding an audio specific config
1065  * @param get_bit_alignment relative alignment for byte align operations
1066  * @param sync_extension look for an appended sync extension
1067  *
1068  * @return Returns error status or number of consumed bits. <0 - error
1069  */
1070 static int decode_audio_specific_config_gb(AACContext *ac,
1071  AVCodecContext *avctx,
1072  MPEG4AudioConfig *m4ac,
1073  GetBitContext *gb,
1074  int get_bit_alignment,
1075  int sync_extension)
1076 {
1077  int i, ret;
1078  GetBitContext gbc = *gb;
1079 
1080  if ((i = ff_mpeg4audio_get_config_gb(m4ac, &gbc, sync_extension, avctx)) < 0)
1081  return AVERROR_INVALIDDATA;
1082 
1083  if (m4ac->sampling_index > 12) {
1084  av_log(avctx, AV_LOG_ERROR,
1085  "invalid sampling rate index %d\n",
1086  m4ac->sampling_index);
1087  return AVERROR_INVALIDDATA;
1088  }
1089  if (m4ac->object_type == AOT_ER_AAC_LD &&
1090  (m4ac->sampling_index < 3 || m4ac->sampling_index > 7)) {
1091  av_log(avctx, AV_LOG_ERROR,
1092  "invalid low delay sampling rate index %d\n",
1093  m4ac->sampling_index);
1094  return AVERROR_INVALIDDATA;
1095  }
1096 
1097  skip_bits_long(gb, i);
1098 
1099  switch (m4ac->object_type) {
1100  case AOT_AAC_MAIN:
1101  case AOT_AAC_LC:
1102  case AOT_AAC_SSR:
1103  case AOT_AAC_LTP:
1104  case AOT_ER_AAC_LC:
1105  case AOT_ER_AAC_LD:
1106  if ((ret = decode_ga_specific_config(ac, avctx, gb, get_bit_alignment,
1107  m4ac, m4ac->chan_config)) < 0)
1108  return ret;
1109  break;
1110  case AOT_ER_AAC_ELD:
1111  if ((ret = decode_eld_specific_config(ac, avctx, gb,
1112  m4ac, m4ac->chan_config)) < 0)
1113  return ret;
1114  break;
1115  default:
1116  avpriv_report_missing_feature(avctx,
1117  "Audio object type %s%d",
1118  m4ac->sbr == 1 ? "SBR+" : "",
1119  m4ac->object_type);
1120  return AVERROR(ENOSYS);
1121  }
1122 
1123  ff_dlog(avctx,
1124  "AOT %d chan config %d sampling index %d (%d) SBR %d PS %d\n",
1125  m4ac->object_type, m4ac->chan_config, m4ac->sampling_index,
1126  m4ac->sample_rate, m4ac->sbr,
1127  m4ac->ps);
1128 
1129  return get_bits_count(gb);
1130 }
1131 
1132 static int decode_audio_specific_config(AACContext *ac,
1133  AVCodecContext *avctx,
1134  MPEG4AudioConfig *m4ac,
1135  const uint8_t *data, int64_t bit_size,
1136  int sync_extension)
1137 {
1138  int i, ret;
1139  GetBitContext gb;
1140 
1141  if (bit_size < 0 || bit_size > INT_MAX) {
1142  av_log(avctx, AV_LOG_ERROR, "Audio specific config size is invalid\n");
1143  return AVERROR_INVALIDDATA;
1144  }
1145 
1146  ff_dlog(avctx, "audio specific config size %d\n", (int)bit_size >> 3);
1147  for (i = 0; i < bit_size >> 3; i++)
1148  ff_dlog(avctx, "%02x ", data[i]);
1149  ff_dlog(avctx, "\n");
1150 
1151  if ((ret = init_get_bits(&gb, data, bit_size)) < 0)
1152  return ret;
1153 
1154  return decode_audio_specific_config_gb(ac, avctx, m4ac, &gb, 0,
1155  sync_extension);
1156 }
1157 
1158 /**
1159  * linear congruential pseudorandom number generator
1160  *
1161  * @param previous_val pointer to the current state of the generator
1162  *
1163  * @return Returns a 32-bit pseudorandom integer
1164  */
1165 static av_always_inline int lcg_random(unsigned previous_val)
1166 {
1167  union { unsigned u; int s; } v = { previous_val * 1664525u + 1013904223 };
1168  return v.s;
1169 }
1170 
1171 static void reset_all_predictors(PredictorState *ps)
1172 {
1173  int i;
1174  for (i = 0; i < MAX_PREDICTORS; i++)
1175  reset_predict_state(&ps[i]);
1176 }
1177 
1178 static int sample_rate_idx (int rate)
1179 {
1180  if (92017 <= rate) return 0;
1181  else if (75132 <= rate) return 1;
1182  else if (55426 <= rate) return 2;
1183  else if (46009 <= rate) return 3;
1184  else if (37566 <= rate) return 4;
1185  else if (27713 <= rate) return 5;
1186  else if (23004 <= rate) return 6;
1187  else if (18783 <= rate) return 7;
1188  else if (13856 <= rate) return 8;
1189  else if (11502 <= rate) return 9;
1190  else if (9391 <= rate) return 10;
1191  else return 11;
1192 }
1193 
1194 static void reset_predictor_group(PredictorState *ps, int group_num)
1195 {
1196  int i;
1197  for (i = group_num - 1; i < MAX_PREDICTORS; i += 30)
1198  reset_predict_state(&ps[i]);
1199 }
1200 
1201 static void aacdec_init(AACContext *ac);
1202 
1203 static av_cold void aac_static_table_init(void)
1204 {
1205  static VLC_TYPE vlc_buf[304 + 270 + 550 + 300 + 328 +
1206  294 + 306 + 268 + 510 + 366 + 462][2];
1207  for (unsigned i = 0, offset = 0; i < 11; i++) {
1208  vlc_spectral[i].table = &vlc_buf[offset];
1209  vlc_spectral[i].table_allocated = FF_ARRAY_ELEMS(vlc_buf) - offset;
1210  ff_init_vlc_sparse(&vlc_spectral[i], 8, ff_aac_spectral_sizes[i],
1211  ff_aac_spectral_bits[i], sizeof(ff_aac_spectral_bits[i][0]),
1212  sizeof(ff_aac_spectral_bits[i][0]),
1213  ff_aac_spectral_codes[i], sizeof(ff_aac_spectral_codes[i][0]),
1214  sizeof(ff_aac_spectral_codes[i][0]),
1215  ff_aac_codebook_vector_idx[i], sizeof(ff_aac_codebook_vector_idx[i][0]),
1216  sizeof(ff_aac_codebook_vector_idx[i][0]),
1217  INIT_VLC_STATIC_OVERLONG);
1218  offset += vlc_spectral[i].table_size;
1219  }
1220 
1221  AAC_RENAME(ff_aac_sbr_init)();
1222 
1223  ff_aac_tableinit();
1224 
1225  INIT_VLC_STATIC(&vlc_scalefactors, 7,
1226  FF_ARRAY_ELEMS(ff_aac_scalefactor_code),
1227  ff_aac_scalefactor_bits,
1228  sizeof(ff_aac_scalefactor_bits[0]),
1229  sizeof(ff_aac_scalefactor_bits[0]),
1230  ff_aac_scalefactor_code,
1231  sizeof(ff_aac_scalefactor_code[0]),
1232  sizeof(ff_aac_scalefactor_code[0]),
1233  352);
1234 
1235  // window initialization
1236 #if !USE_FIXED
1237  AAC_RENAME(ff_kbd_window_init)(AAC_RENAME(aac_kbd_long_960), 4.0, 960);
1238  AAC_RENAME(ff_kbd_window_init)(AAC_RENAME(aac_kbd_short_120), 6.0, 120);
1239  AAC_RENAME(ff_sine_window_init)(AAC_RENAME(sine_960), 960);
1240  AAC_RENAME(ff_sine_window_init)(AAC_RENAME(sine_120), 120);
1241  AAC_RENAME(ff_init_ff_sine_windows)(9);
1242  ff_aac_float_common_init();
1243 #else
1244  AAC_RENAME(ff_kbd_window_init)(AAC_RENAME2(aac_kbd_long_1024), 4.0, 1024);
1245  AAC_RENAME(ff_kbd_window_init)(AAC_RENAME2(aac_kbd_short_128), 6.0, 128);
1246  init_sine_windows_fixed();
1247 #endif
1248 
1249  AAC_RENAME(ff_cbrt_tableinit)();
1250 }
1251 
1252 static AVOnce aac_table_init = AV_ONCE_INIT;
1253 
1254 static av_cold int aac_decode_init(AVCodecContext *avctx)
1255 {
1256  AACContext *ac = avctx->priv_data;
1257  int ret;
1258 
1259  if (avctx->sample_rate > 96000)
1260  return AVERROR_INVALIDDATA;
1261 
1262  ret = ff_thread_once(&aac_table_init, &aac_static_table_init);
1263  if (ret != 0)
1264  return AVERROR_UNKNOWN;
1265 
1266  ac->avctx = avctx;
1267  ac->oc[1].m4ac.sample_rate = avctx->sample_rate;
1268 
1269  aacdec_init(ac);
1270 #if USE_FIXED
1271  avctx->sample_fmt = AV_SAMPLE_FMT_S32P;
1272 #else
1273  avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;
1274 #endif /* USE_FIXED */
1275 
1276  if (avctx->extradata_size > 0) {
1277  if ((ret = decode_audio_specific_config(ac, ac->avctx, &ac->oc[1].m4ac,
1278  avctx->extradata,
1279  avctx->extradata_size * 8LL,
1280  1)) < 0)
1281  return ret;
1282  } else {
1283  int sr, i;
1284  uint8_t layout_map[MAX_ELEM_ID*4][3];
1285  int layout_map_tags;
1286 
1287  sr = sample_rate_idx(avctx->sample_rate);
1288  ac->oc[1].m4ac.sampling_index = sr;
1289  ac->oc[1].m4ac.channels = avctx->channels;
1290  ac->oc[1].m4ac.sbr = -1;
1291  ac->oc[1].m4ac.ps = -1;
1292 
1293  for (i = 0; i < FF_ARRAY_ELEMS(ff_mpeg4audio_channels); i++)
1294  if (ff_mpeg4audio_channels[i] == avctx->channels)
1295  break;
1296  if (i == FF_ARRAY_ELEMS(ff_mpeg4audio_channels)) {
1297  i = 0;
1298  }
1299  ac->oc[1].m4ac.chan_config = i;
1300 
1301  if (ac->oc[1].m4ac.chan_config) {
1302  int ret = set_default_channel_config(ac, avctx, layout_map,
1303  &layout_map_tags, ac->oc[1].m4ac.chan_config);
1304  if (!ret)
1305  output_configure(ac, layout_map, layout_map_tags,
1306  OC_GLOBAL_HDR, 0);
1307  else if (avctx->err_recognition & AV_EF_EXPLODE)
1308  return AVERROR_INVALIDDATA;
1309  }
1310  }
1311 
1312  if (avctx->channels > MAX_CHANNELS) {
1313  av_log(avctx, AV_LOG_ERROR, "Too many channels\n");
1314  return AVERROR_INVALIDDATA;
1315  }
1316 
1317 #if USE_FIXED
1318  ac->fdsp = avpriv_alloc_fixed_dsp(avctx->flags & AV_CODEC_FLAG_BITEXACT);
1319 #else
1320  ac->fdsp = avpriv_float_dsp_alloc(avctx->flags & AV_CODEC_FLAG_BITEXACT);
1321 #endif /* USE_FIXED */
1322  if (!ac->fdsp) {
1323  return AVERROR(ENOMEM);
1324  }
1325 
1326  ac->random_state = 0x1f2e3d4c;
1327 
1328  AAC_RENAME_32(ff_mdct_init)(&ac->mdct, 11, 1, 1.0 / RANGE15(1024.0));
1329  AAC_RENAME_32(ff_mdct_init)(&ac->mdct_ld, 10, 1, 1.0 / RANGE15(512.0));
1330  AAC_RENAME_32(ff_mdct_init)(&ac->mdct_small, 8, 1, 1.0 / RANGE15(128.0));
1331  AAC_RENAME_32(ff_mdct_init)(&ac->mdct_ltp, 11, 0, RANGE15(-2.0));
1332 #if !USE_FIXED
1333  ret = ff_mdct15_init(&ac->mdct120, 1, 3, 1.0f/(16*1024*120*2));
1334  if (ret < 0)
1335  return ret;
1336  ret = ff_mdct15_init(&ac->mdct480, 1, 5, 1.0f/(16*1024*960));
1337  if (ret < 0)
1338  return ret;
1339  ret = ff_mdct15_init(&ac->mdct960, 1, 6, 1.0f/(16*1024*960*2));
1340  if (ret < 0)
1341  return ret;
1342 #endif
1343 
1344  return 0;
1345 }
1346 
1347 /**
1348  * Skip data_stream_element; reference: table 4.10.
1349  */
1350 static int skip_data_stream_element(AACContext *ac, GetBitContext *gb)
1351 {
1352  int byte_align = get_bits1(gb);
1353  int count = get_bits(gb, 8);
1354  if (count == 255)
1355  count += get_bits(gb, 8);
1356  if (byte_align)
1357  align_get_bits(gb);
1358 
1359  if (get_bits_left(gb) < 8 * count) {
1360  av_log(ac->avctx, AV_LOG_ERROR, "skip_data_stream_element: "overread_err);
1361  return AVERROR_INVALIDDATA;
1362  }
1363  skip_bits_long(gb, 8 * count);
1364  return 0;
1365 }
1366 
1367 static int decode_prediction(AACContext *ac, IndividualChannelStream *ics,
1368  GetBitContext *gb)
1369 {
1370  int sfb;
1371  if (get_bits1(gb)) {
1372  ics->predictor_reset_group = get_bits(gb, 5);
1373  if (ics->predictor_reset_group == 0 ||
1374  ics->predictor_reset_group > 30) {
1375  av_log(ac->avctx, AV_LOG_ERROR,
1376  "Invalid Predictor Reset Group.\n");
1377  return AVERROR_INVALIDDATA;
1378  }
1379  }
1380  for (sfb = 0; sfb < FFMIN(ics->max_sfb, ff_aac_pred_sfb_max[ac->oc[1].m4ac.sampling_index]); sfb++) {
1381  ics->prediction_used[sfb] = get_bits1(gb);
1382  }
1383  return 0;
1384 }
1385 
1386 /**
1387  * Decode Long Term Prediction data; reference: table 4.xx.
1388  */
1389 static void decode_ltp(LongTermPrediction *ltp,
1390  GetBitContext *gb, uint8_t max_sfb)
1391 {
1392  int sfb;
1393 
1394  ltp->lag = get_bits(gb, 11);
1395  ltp->coef = ltp_coef[get_bits(gb, 3)];
1396  for (sfb = 0; sfb < FFMIN(max_sfb, MAX_LTP_LONG_SFB); sfb++)
1397  ltp->used[sfb] = get_bits1(gb);
1398 }
1399 
1400 /**
1401  * Decode Individual Channel Stream info; reference: table 4.6.
1402  */
1403 static int decode_ics_info(AACContext *ac, IndividualChannelStream *ics,
1404  GetBitContext *gb)
1405 {
1406  const MPEG4AudioConfig *const m4ac = &ac->oc[1].m4ac;
1407  const int aot = m4ac->object_type;
1408  const int sampling_index = m4ac->sampling_index;
1409  int ret_fail = AVERROR_INVALIDDATA;
1410 
1411  if (aot != AOT_ER_AAC_ELD) {
1412  if (get_bits1(gb)) {
1413  av_log(ac->avctx, AV_LOG_ERROR, "Reserved bit set.\n");
1414  if (ac->avctx->err_recognition & AV_EF_BITSTREAM)
1415  return AVERROR_INVALIDDATA;
1416  }
1417  ics->window_sequence[1] = ics->window_sequence[0];
1418  ics->window_sequence[0] = get_bits(gb, 2);
1419  if (aot == AOT_ER_AAC_LD &&
1420  ics->window_sequence[0] != ONLY_LONG_SEQUENCE) {
1421  av_log(ac->avctx, AV_LOG_ERROR,
1422  "AAC LD is only defined for ONLY_LONG_SEQUENCE but "
1423  "window sequence %d found.\n", ics->window_sequence[0]);
1424  ics->window_sequence[0] = ONLY_LONG_SEQUENCE;
1425  return AVERROR_INVALIDDATA;
1426  }
1427  ics->use_kb_window[1] = ics->use_kb_window[0];
1428  ics->use_kb_window[0] = get_bits1(gb);
1429  }
1430  ics->num_window_groups = 1;
1431  ics->group_len[0] = 1;
1432  if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) {
1433  int i;
1434  ics->max_sfb = get_bits(gb, 4);
1435  for (i = 0; i < 7; i++) {
1436  if (get_bits1(gb)) {
1437  ics->group_len[ics->num_window_groups - 1]++;
1438  } else {
1439  ics->num_window_groups++;
1440  ics->group_len[ics->num_window_groups - 1] = 1;
1441  }
1442  }
1443  ics->num_windows = 8;
1444  if (m4ac->frame_length_short) {
1445  ics->swb_offset = ff_swb_offset_120[sampling_index];
1446  ics->num_swb = ff_aac_num_swb_120[sampling_index];
1447  } else {
1448  ics->swb_offset = ff_swb_offset_128[sampling_index];
1449  ics->num_swb = ff_aac_num_swb_128[sampling_index];
1450  }
1451  ics->tns_max_bands = ff_tns_max_bands_128[sampling_index];
1452  ics->predictor_present = 0;
1453  } else {
1454  ics->max_sfb = get_bits(gb, 6);
1455  ics->num_windows = 1;
1456  if (aot == AOT_ER_AAC_LD || aot == AOT_ER_AAC_ELD) {
1457  if (m4ac->frame_length_short) {
1458  ics->swb_offset = ff_swb_offset_480[sampling_index];
1459  ics->num_swb = ff_aac_num_swb_480[sampling_index];
1460  ics->tns_max_bands = ff_tns_max_bands_480[sampling_index];
1461  } else {
1462  ics->swb_offset = ff_swb_offset_512[sampling_index];
1463  ics->num_swb = ff_aac_num_swb_512[sampling_index];
1464  ics->tns_max_bands = ff_tns_max_bands_512[sampling_index];
1465  }
1466  if (!ics->num_swb || !ics->swb_offset) {
1467  ret_fail = AVERROR_BUG;
1468  goto fail;
1469  }
1470  } else {
1471  if (m4ac->frame_length_short) {
1472  ics->num_swb = ff_aac_num_swb_960[sampling_index];
1473  ics->swb_offset = ff_swb_offset_960[sampling_index];
1474  } else {
1475  ics->num_swb = ff_aac_num_swb_1024[sampling_index];
1476  ics->swb_offset = ff_swb_offset_1024[sampling_index];
1477  }
1478  ics->tns_max_bands = ff_tns_max_bands_1024[sampling_index];
1479  }
1480  if (aot != AOT_ER_AAC_ELD) {
1481  ics->predictor_present = get_bits1(gb);
1482  ics->predictor_reset_group = 0;
1483  }
1484  if (ics->predictor_present) {
1485  if (aot == AOT_AAC_MAIN) {
1486  if (decode_prediction(ac, ics, gb)) {
1487  goto fail;
1488  }
1489  } else if (aot == AOT_AAC_LC ||
1490  aot == AOT_ER_AAC_LC) {
1491  av_log(ac->avctx, AV_LOG_ERROR,
1492  "Prediction is not allowed in AAC-LC.\n");
1493  goto fail;
1494  } else {
1495  if (aot == AOT_ER_AAC_LD) {
1496  av_log(ac->avctx, AV_LOG_ERROR,
1497  "LTP in ER AAC LD not yet implemented.\n");
1498  ret_fail = AVERROR_PATCHWELCOME;
1499  goto fail;
1500  }
1501  if ((ics->ltp.present = get_bits(gb, 1)))
1502  decode_ltp(&ics->ltp, gb, ics->max_sfb);
1503  }
1504  }
1505  }
1506 
1507  if (ics->max_sfb > ics->num_swb) {
1508  av_log(ac->avctx, AV_LOG_ERROR,
1509  "Number of scalefactor bands in group (%d) "
1510  "exceeds limit (%d).\n",
1511  ics->max_sfb, ics->num_swb);
1512  goto fail;
1513  }
1514 
1515  return 0;
1516 fail:
1517  ics->max_sfb = 0;
1518  return ret_fail;
1519 }
1520 
1521 /**
1522  * Decode band types (section_data payload); reference: table 4.46.
1523  *
1524  * @param band_type array of the used band type
1525  * @param band_type_run_end array of the last scalefactor band of a band type run
1526  *
1527  * @return Returns error status. 0 - OK, !0 - error
1528  */
1529 static int decode_band_types(AACContext *ac, enum BandType band_type[120],
1530  int band_type_run_end[120], GetBitContext *gb,
1531  IndividualChannelStream *ics)
1532 {
1533  int g, idx = 0;
1534  const int bits = (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) ? 3 : 5;
1535  for (g = 0; g < ics->num_window_groups; g++) {
1536  int k = 0;
1537  while (k < ics->max_sfb) {
1538  uint8_t sect_end = k;
1539  int sect_len_incr;
1540  int sect_band_type = get_bits(gb, 4);
1541  if (sect_band_type == 12) {
1542  av_log(ac->avctx, AV_LOG_ERROR, "invalid band type\n");
1543  return AVERROR_INVALIDDATA;
1544  }
1545  do {
1546  sect_len_incr = get_bits(gb, bits);
1547  sect_end += sect_len_incr;
1548  if (get_bits_left(gb) < 0) {
1549  av_log(ac->avctx, AV_LOG_ERROR, "decode_band_types: "overread_err);
1550  return AVERROR_INVALIDDATA;
1551  }
1552  if (sect_end > ics->max_sfb) {
1553  av_log(ac->avctx, AV_LOG_ERROR,
1554  "Number of bands (%d) exceeds limit (%d).\n",
1555  sect_end, ics->max_sfb);
1556  return AVERROR_INVALIDDATA;
1557  }
1558  } while (sect_len_incr == (1 << bits) - 1);
1559  for (; k < sect_end; k++) {
1560  band_type [idx] = sect_band_type;
1561  band_type_run_end[idx++] = sect_end;
1562  }
1563  }
1564  }
1565  return 0;
1566 }
1567 
1568 /**
1569  * Decode scalefactors; reference: table 4.47.
1570  *
1571  * @param global_gain first scalefactor value as scalefactors are differentially coded
1572  * @param band_type array of the used band type
1573  * @param band_type_run_end array of the last scalefactor band of a band type run
1574  * @param sf array of scalefactors or intensity stereo positions
1575  *
1576  * @return Returns error status. 0 - OK, !0 - error
1577  */
1578 static int decode_scalefactors(AACContext *ac, INTFLOAT sf[120], GetBitContext *gb,
1579  unsigned int global_gain,
1580  IndividualChannelStream *ics,
1581  enum BandType band_type[120],
1582  int band_type_run_end[120])
1583 {
1584  int g, i, idx = 0;
1585  int offset[3] = { global_gain, global_gain - NOISE_OFFSET, 0 };
1586  int clipped_offset;
1587  int noise_flag = 1;
1588  for (g = 0; g < ics->num_window_groups; g++) {
1589  for (i = 0; i < ics->max_sfb;) {
1590  int run_end = band_type_run_end[idx];
1591  if (band_type[idx] == ZERO_BT) {
1592  for (; i < run_end; i++, idx++)
1593  sf[idx] = FIXR(0.);
1594  } else if ((band_type[idx] == INTENSITY_BT) ||
1595  (band_type[idx] == INTENSITY_BT2)) {
1596  for (; i < run_end; i++, idx++) {
1597  offset[2] += get_vlc2(gb, vlc_scalefactors.table, 7, 3) - SCALE_DIFF_ZERO;
1598  clipped_offset = av_clip(offset[2], -155, 100);
1599  if (offset[2] != clipped_offset) {
1600  avpriv_request_sample(ac->avctx,
1601  "If you heard an audible artifact, there may be a bug in the decoder. "
1602  "Clipped intensity stereo position (%d -> %d)",
1603  offset[2], clipped_offset);
1604  }
1605 #if USE_FIXED
1606  sf[idx] = 100 - clipped_offset;
1607 #else
1608  sf[idx] = ff_aac_pow2sf_tab[-clipped_offset + POW_SF2_ZERO];
1609 #endif /* USE_FIXED */
1610  }
1611  } else if (band_type[idx] == NOISE_BT) {
1612  for (; i < run_end; i++, idx++) {
1613  if (noise_flag-- > 0)
1614  offset[1] += get_bits(gb, NOISE_PRE_BITS) - NOISE_PRE;
1615  else
1616  offset[1] += get_vlc2(gb, vlc_scalefactors.table, 7, 3) - SCALE_DIFF_ZERO;
1617  clipped_offset = av_clip(offset[1], -100, 155);
1618  if (offset[1] != clipped_offset) {
1619  avpriv_request_sample(ac->avctx,
1620  "If you heard an audible artifact, there may be a bug in the decoder. "
1621  "Clipped noise gain (%d -> %d)",
1622  offset[1], clipped_offset);
1623  }
1624 #if USE_FIXED
1625  sf[idx] = -(100 + clipped_offset);
1626 #else
1627  sf[idx] = -ff_aac_pow2sf_tab[clipped_offset + POW_SF2_ZERO];
1628 #endif /* USE_FIXED */
1629  }
1630  } else {
1631  for (; i < run_end; i++, idx++) {
1632  offset[0] += get_vlc2(gb, vlc_scalefactors.table, 7, 3) - SCALE_DIFF_ZERO;
1633  if (offset[0] > 255U) {
1634  av_log(ac->avctx, AV_LOG_ERROR,
1635  "Scalefactor (%d) out of range.\n", offset[0]);
1636  return AVERROR_INVALIDDATA;
1637  }
1638 #if USE_FIXED
1639  sf[idx] = -offset[0];
1640 #else
1641  sf[idx] = -ff_aac_pow2sf_tab[offset[0] - 100 + POW_SF2_ZERO];
1642 #endif /* USE_FIXED */
1643  }
1644  }
1645  }
1646  }
1647  return 0;
1648 }
1649 
1650 /**
1651  * Decode pulse data; reference: table 4.7.
1652  */
1653 static int decode_pulses(Pulse *pulse, GetBitContext *gb,
1654  const uint16_t *swb_offset, int num_swb)
1655 {
1656  int i, pulse_swb;
1657  pulse->num_pulse = get_bits(gb, 2) + 1;
1658  pulse_swb = get_bits(gb, 6);
1659  if (pulse_swb >= num_swb)
1660  return -1;
1661  pulse->pos[0] = swb_offset[pulse_swb];
1662  pulse->pos[0] += get_bits(gb, 5);
1663  if (pulse->pos[0] >= swb_offset[num_swb])
1664  return -1;
1665  pulse->amp[0] = get_bits(gb, 4);
1666  for (i = 1; i < pulse->num_pulse; i++) {
1667  pulse->pos[i] = get_bits(gb, 5) + pulse->pos[i - 1];
1668  if (pulse->pos[i] >= swb_offset[num_swb])
1669  return -1;
1670  pulse->amp[i] = get_bits(gb, 4);
1671  }
1672  return 0;
1673 }
1674 
1675 /**
1676  * Decode Temporal Noise Shaping data; reference: table 4.48.
1677  *
1678  * @return Returns error status. 0 - OK, !0 - error
1679  */
1680 static int decode_tns(AACContext *ac, TemporalNoiseShaping *tns,
1681  GetBitContext *gb, const IndividualChannelStream *ics)
1682 {
1683  int w, filt, i, coef_len, coef_res, coef_compress;
1684  const int is8 = ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE;
1685  const int tns_max_order = is8 ? 7 : ac->oc[1].m4ac.object_type == AOT_AAC_MAIN ? 20 : 12;
1686  for (w = 0; w < ics->num_windows; w++) {
1687  if ((tns->n_filt[w] = get_bits(gb, 2 - is8))) {
1688  coef_res = get_bits1(gb);
1689 
1690  for (filt = 0; filt < tns->n_filt[w]; filt++) {
1691  int tmp2_idx;
1692  tns->length[w][filt] = get_bits(gb, 6 - 2 * is8);
1693 
1694  if ((tns->order[w][filt] = get_bits(gb, 5 - 2 * is8)) > tns_max_order) {
1695  av_log(ac->avctx, AV_LOG_ERROR,
1696  "TNS filter order %d is greater than maximum %d.\n",
1697  tns->order[w][filt], tns_max_order);
1698  tns->order[w][filt] = 0;
1699  return AVERROR_INVALIDDATA;
1700  }
1701  if (tns->order[w][filt]) {
1702  tns->direction[w][filt] = get_bits1(gb);
1703  coef_compress = get_bits1(gb);
1704  coef_len = coef_res + 3 - coef_compress;
1705  tmp2_idx = 2 * coef_compress + coef_res;
1706 
1707  for (i = 0; i < tns->order[w][filt]; i++)
1708  tns->coef[w][filt][i] = tns_tmp2_map[tmp2_idx][get_bits(gb, coef_len)];
1709  }
1710  }
1711  }
1712  }
1713  return 0;
1714 }
1715 
1716 /**
1717  * Decode Mid/Side data; reference: table 4.54.
1718  *
1719  * @param ms_present Indicates mid/side stereo presence. [0] mask is all 0s;
1720  * [1] mask is decoded from bitstream; [2] mask is all 1s;
1721  * [3] reserved for scalable AAC
1722  */
1723 static void decode_mid_side_stereo(ChannelElement *cpe, GetBitContext *gb,
1724  int ms_present)
1725 {
1726  int idx;
1727  int max_idx = cpe->ch[0].ics.num_window_groups * cpe->ch[0].ics.max_sfb;
1728  if (ms_present == 1) {
1729  for (idx = 0; idx < max_idx; idx++)
1730  cpe->ms_mask[idx] = get_bits1(gb);
1731  } else if (ms_present == 2) {
1732  memset(cpe->ms_mask, 1, max_idx * sizeof(cpe->ms_mask[0]));
1733  }
1734 }
1735 
1736 /**
1737  * Decode spectral data; reference: table 4.50.
1738  * Dequantize and scale spectral data; reference: 4.6.3.3.
1739  *
1740  * @param coef array of dequantized, scaled spectral data
1741  * @param sf array of scalefactors or intensity stereo positions
1742  * @param pulse_present set if pulses are present
1743  * @param pulse pointer to pulse data struct
1744  * @param band_type array of the used band type
1745  *
1746  * @return Returns error status. 0 - OK, !0 - error
1747  */
1748 static int decode_spectrum_and_dequant(AACContext *ac, INTFLOAT coef[1024],
1749  GetBitContext *gb, const INTFLOAT sf[120],
1750  int pulse_present, const Pulse *pulse,
1751  const IndividualChannelStream *ics,
1752  enum BandType band_type[120])
1753 {
1754  int i, k, g, idx = 0;
1755  const int c = 1024 / ics->num_windows;
1756  const uint16_t *offsets = ics->swb_offset;
1757  INTFLOAT *coef_base = coef;
1758 
1759  for (g = 0; g < ics->num_windows; g++)
1760  memset(coef + g * 128 + offsets[ics->max_sfb], 0,
1761  sizeof(INTFLOAT) * (c - offsets[ics->max_sfb]));
1762 
1763  for (g = 0; g < ics->num_window_groups; g++) {
1764  unsigned g_len = ics->group_len[g];
1765 
1766  for (i = 0; i < ics->max_sfb; i++, idx++) {
1767  const unsigned cbt_m1 = band_type[idx] - 1;
1768  INTFLOAT *cfo = coef + offsets[i];
1769  int off_len = offsets[i + 1] - offsets[i];
1770  int group;
1771 
1772  if (cbt_m1 >= INTENSITY_BT2 - 1) {
1773  for (group = 0; group < (AAC_SIGNE)g_len; group++, cfo+=128) {
1774  memset(cfo, 0, off_len * sizeof(*cfo));
1775  }
1776  } else if (cbt_m1 == NOISE_BT - 1) {
1777  for (group = 0; group < (AAC_SIGNE)g_len; group++, cfo+=128) {
1778  INTFLOAT band_energy;
1779 #if USE_FIXED
1780  for (k = 0; k < off_len; k++) {
1781  ac->random_state = lcg_random(ac->random_state);
1782  cfo[k] = ac->random_state >> 3;
1783  }
1784 
1785  band_energy = ac->fdsp->scalarproduct_fixed(cfo, cfo, off_len);
1786  band_energy = fixed_sqrt(band_energy, 31);
1787  noise_scale(cfo, sf[idx], band_energy, off_len);
1788 #else
1789  float scale;
1790 
1791  for (k = 0; k < off_len; k++) {
1792  ac->random_state = lcg_random(ac->random_state);
1793  cfo[k] = ac->random_state;
1794  }
1795 
1796  band_energy = ac->fdsp->scalarproduct_float(cfo, cfo, off_len);
1797  scale = sf[idx] / sqrtf(band_energy);
1798  ac->fdsp->vector_fmul_scalar(cfo, cfo, scale, off_len);
1799 #endif /* USE_FIXED */
1800  }
1801  } else {
1802 #if !USE_FIXED
1803  const float *vq = ff_aac_codebook_vector_vals[cbt_m1];
1804 #endif /* !USE_FIXED */
1805  VLC_TYPE (*vlc_tab)[2] = vlc_spectral[cbt_m1].table;
1806  OPEN_READER(re, gb);
1807 
1808  switch (cbt_m1 >> 1) {
1809  case 0:
1810  for (group = 0; group < (AAC_SIGNE)g_len; group++, cfo+=128) {
1811  INTFLOAT *cf = cfo;
1812  int len = off_len;
1813 
1814  do {
1815  int code;
1816  unsigned cb_idx;
1817 
1818  UPDATE_CACHE(re, gb);
1819  GET_VLC(code, re, gb, vlc_tab, 8, 2);
1820  cb_idx = code;
1821 #if USE_FIXED
1822  cf = DEC_SQUAD(cf, cb_idx);
1823 #else
1824  cf = VMUL4(cf, vq, cb_idx, sf + idx);
1825 #endif /* USE_FIXED */
1826  } while (len -= 4);
1827  }
1828  break;
1829 
1830  case 1:
1831  for (group = 0; group < (AAC_SIGNE)g_len; group++, cfo+=128) {
1832  INTFLOAT *cf = cfo;
1833  int len = off_len;
1834 
1835  do {
1836  int code;
1837  unsigned nnz;
1838  unsigned cb_idx;
1839  uint32_t bits;
1840 
1841  UPDATE_CACHE(re, gb);
1842  GET_VLC(code, re, gb, vlc_tab, 8, 2);
1843  cb_idx = code;
1844  nnz = cb_idx >> 8 & 15;
1845  bits = nnz ? GET_CACHE(re, gb) : 0;
1846  LAST_SKIP_BITS(re, gb, nnz);
1847 #if USE_FIXED
1848  cf = DEC_UQUAD(cf, cb_idx, bits);
1849 #else
1850  cf = VMUL4S(cf, vq, cb_idx, bits, sf + idx);
1851 #endif /* USE_FIXED */
1852  } while (len -= 4);
1853  }
1854  break;
1855 
1856  case 2:
1857  for (group = 0; group < (AAC_SIGNE)g_len; group++, cfo+=128) {
1858  INTFLOAT *cf = cfo;
1859  int len = off_len;
1860 
1861  do {
1862  int code;
1863  unsigned cb_idx;
1864 
1865  UPDATE_CACHE(re, gb);
1866  GET_VLC(code, re, gb, vlc_tab, 8, 2);
1867  cb_idx = code;
1868 #if USE_FIXED
1869  cf = DEC_SPAIR(cf, cb_idx);
1870 #else
1871  cf = VMUL2(cf, vq, cb_idx, sf + idx);
1872 #endif /* USE_FIXED */
1873  } while (len -= 2);
1874  }
1875  break;
1876 
1877  case 3:
1878  case 4:
1879  for (group = 0; group < (AAC_SIGNE)g_len; group++, cfo+=128) {
1880  INTFLOAT *cf = cfo;
1881  int len = off_len;
1882 
1883  do {
1884  int code;
1885  unsigned nnz;
1886  unsigned cb_idx;
1887  unsigned sign;
1888 
1889  UPDATE_CACHE(re, gb);
1890  GET_VLC(code, re, gb, vlc_tab, 8, 2);
1891  cb_idx = code;
1892  nnz = cb_idx >> 8 & 15;
1893  sign = nnz ? SHOW_UBITS(re, gb, nnz) << (cb_idx >> 12) : 0;
1894  LAST_SKIP_BITS(re, gb, nnz);
1895 #if USE_FIXED
1896  cf = DEC_UPAIR(cf, cb_idx, sign);
1897 #else
1898  cf = VMUL2S(cf, vq, cb_idx, sign, sf + idx);
1899 #endif /* USE_FIXED */
1900  } while (len -= 2);
1901  }
1902  break;
1903 
1904  default:
1905  for (group = 0; group < (AAC_SIGNE)g_len; group++, cfo+=128) {
1906 #if USE_FIXED
1907  int *icf = cfo;
1908  int v;
1909 #else
1910  float *cf = cfo;
1911  uint32_t *icf = (uint32_t *) cf;
1912 #endif /* USE_FIXED */
1913  int len = off_len;
1914 
1915  do {
1916  int code;
1917  unsigned nzt, nnz;
1918  unsigned cb_idx;
1919  uint32_t bits;
1920  int j;
1921 
1922  UPDATE_CACHE(re, gb);
1923  GET_VLC(code, re, gb, vlc_tab, 8, 2);
1924  cb_idx = code;
1925 
1926  if (cb_idx == 0x0000) {
1927  *icf++ = 0;
1928  *icf++ = 0;
1929  continue;
1930  }
1931 
1932  nnz = cb_idx >> 12;
1933  nzt = cb_idx >> 8;
1934  bits = SHOW_UBITS(re, gb, nnz) << (32-nnz);
1935  LAST_SKIP_BITS(re, gb, nnz);
1936 
1937  for (j = 0; j < 2; j++) {
1938  if (nzt & 1<<j) {
1939  uint32_t b;
1940  int n;
1941  /* The total length of escape_sequence must be < 22 bits according
1942  to the specification (i.e. max is 111111110xxxxxxxxxxxx). */
1943  UPDATE_CACHE(re, gb);
1944  b = GET_CACHE(re, gb);
1945  b = 31 - av_log2(~b);
1946 
1947  if (b > 8) {
1948  av_log(ac->avctx, AV_LOG_ERROR, "error in spectral data, ESC overflow\n");
1949  return AVERROR_INVALIDDATA;
1950  }
1951 
1952  SKIP_BITS(re, gb, b + 1);
1953  b += 4;
1954  n = (1 << b) + SHOW_UBITS(re, gb, b);
1955  LAST_SKIP_BITS(re, gb, b);
1956 #if USE_FIXED
1957  v = n;
1958  if (bits & 1U<<31)
1959  v = -v;
1960  *icf++ = v;
1961 #else
1962  *icf++ = ff_cbrt_tab[n] | (bits & 1U<<31);
1963 #endif /* USE_FIXED */
1964  bits <<= 1;
1965  } else {
1966 #if USE_FIXED
1967  v = cb_idx & 15;
1968  if (bits & 1U<<31)
1969  v = -v;
1970  *icf++ = v;
1971 #else
1972  unsigned v = ((const uint32_t*)vq)[cb_idx & 15];
1973  *icf++ = (bits & 1U<<31) | v;
1974 #endif /* USE_FIXED */
1975  bits <<= !!v;
1976  }
1977  cb_idx >>= 4;
1978  }
1979  } while (len -= 2);
1980 #if !USE_FIXED
1981  ac->fdsp->vector_fmul_scalar(cfo, cfo, sf[idx], off_len);
1982 #endif /* !USE_FIXED */
1983  }
1984  }
1985 
1986  CLOSE_READER(re, gb);
1987  }
1988  }
1989  coef += g_len << 7;
1990  }
1991 
1992  if (pulse_present) {
1993  idx = 0;
1994  for (i = 0; i < pulse->num_pulse; i++) {
1995  INTFLOAT co = coef_base[ pulse->pos[i] ];
1996  while (offsets[idx + 1] <= pulse->pos[i])
1997  idx++;
1998  if (band_type[idx] != NOISE_BT && sf[idx]) {
1999  INTFLOAT ico = -pulse->amp[i];
2000 #if USE_FIXED
2001  if (co) {
2002  ico = co + (co > 0 ? -ico : ico);
2003  }
2004  coef_base[ pulse->pos[i] ] = ico;
2005 #else
2006  if (co) {
2007  co /= sf[idx];
2008  ico = co / sqrtf(sqrtf(fabsf(co))) + (co > 0 ? -ico : ico);
2009  }
2010  coef_base[ pulse->pos[i] ] = cbrtf(fabsf(ico)) * ico * sf[idx];
2011 #endif /* USE_FIXED */
2012  }
2013  }
2014  }
2015 #if USE_FIXED
2016  coef = coef_base;
2017  idx = 0;
2018  for (g = 0; g < ics->num_window_groups; g++) {
2019  unsigned g_len = ics->group_len[g];
2020 
2021  for (i = 0; i < ics->max_sfb; i++, idx++) {
2022  const unsigned cbt_m1 = band_type[idx] - 1;
2023  int *cfo = coef + offsets[i];
2024  int off_len = offsets[i + 1] - offsets[i];
2025  int group;
2026 
2027  if (cbt_m1 < NOISE_BT - 1) {
2028  for (group = 0; group < (int)g_len; group++, cfo+=128) {
2029  ac->vector_pow43(cfo, off_len);
2030  ac->subband_scale(cfo, cfo, sf[idx], 34, off_len, ac->avctx);
2031  }
2032  }
2033  }
2034  coef += g_len << 7;
2035  }
2036 #endif /* USE_FIXED */
2037  return 0;
2038 }
2039 
2040 /**
2041  * Apply AAC-Main style frequency domain prediction.
2042  */
2043 static void apply_prediction(AACContext *ac, SingleChannelElement *sce)
2044 {
2045  int sfb, k;
2046 
2047  if (!sce->ics.predictor_initialized) {
2048  reset_all_predictors(sce->predictor_state);
2049  sce->ics.predictor_initialized = 1;
2050  }
2051 
2052  if (sce->ics.window_sequence[0] != EIGHT_SHORT_SEQUENCE) {
2053  for (sfb = 0;
2054  sfb < ff_aac_pred_sfb_max[ac->oc[1].m4ac.sampling_index];
2055  sfb++) {
2056  for (k = sce->ics.swb_offset[sfb];
2057  k < sce->ics.swb_offset[sfb + 1];
2058  k++) {
2059  predict(&sce->predictor_state[k], &sce->coeffs[k],
2060  sce->ics.predictor_present &&
2061  sce->ics.prediction_used[sfb]);
2062  }
2063  }
2064  if (sce->ics.predictor_reset_group)
2065  reset_predictor_group(sce->predictor_state,
2066  sce->ics.predictor_reset_group);
2067  } else
2068  reset_all_predictors(sce->predictor_state);
2069 }
2070 
2071 static void decode_gain_control(SingleChannelElement * sce, GetBitContext * gb)
2072 {
2073  // wd_num, wd_test, aloc_size
2074  static const uint8_t gain_mode[4][3] = {
2075  {1, 0, 5}, // ONLY_LONG_SEQUENCE = 0,
2076  {2, 1, 2}, // LONG_START_SEQUENCE,
2077  {8, 0, 2}, // EIGHT_SHORT_SEQUENCE,
2078  {2, 1, 5}, // LONG_STOP_SEQUENCE
2079  };
2080 
2081  const int mode = sce->ics.window_sequence[0];
2082  uint8_t bd, wd, ad;
2083 
2084  // FIXME: Store the gain control data on |sce| and do something with it.
2085  uint8_t max_band = get_bits(gb, 2);
2086  for (bd = 0; bd < max_band; bd++) {
2087  for (wd = 0; wd < gain_mode[mode][0]; wd++) {
2088  uint8_t adjust_num = get_bits(gb, 3);
2089  for (ad = 0; ad < adjust_num; ad++) {
2090  skip_bits(gb, 4 + ((wd == 0 && gain_mode[mode][1])
2091  ? 4
2092  : gain_mode[mode][2]));
2093  }
2094  }
2095  }
2096 }
2097 
2098 /**
2099  * Decode an individual_channel_stream payload; reference: table 4.44.
2100  *
2101  * @param common_window Channels have independent [0], or shared [1], Individual Channel Stream information.
2102  * @param scale_flag scalable [1] or non-scalable [0] AAC (Unused until scalable AAC is implemented.)
2103  *
2104  * @return Returns error status. 0 - OK, !0 - error
2105  */
2106 static int decode_ics(AACContext *ac, SingleChannelElement *sce,
2107  GetBitContext *gb, int common_window, int scale_flag)
2108 {
2109  Pulse pulse;
2110  TemporalNoiseShaping *tns = &sce->tns;
2111  IndividualChannelStream *ics = &sce->ics;
2112  INTFLOAT *out = sce->coeffs;
2113  int global_gain, eld_syntax, er_syntax, pulse_present = 0;
2114  int ret;
2115 
2116  eld_syntax = ac->oc[1].m4ac.object_type == AOT_ER_AAC_ELD;
2117  er_syntax = ac->oc[1].m4ac.object_type == AOT_ER_AAC_LC ||
2118  ac->oc[1].m4ac.object_type == AOT_ER_AAC_LTP ||
2119  ac->oc[1].m4ac.object_type == AOT_ER_AAC_LD ||
2120  ac->oc[1].m4ac.object_type == AOT_ER_AAC_ELD;
2121 
2122  /* This assignment is to silence a GCC warning about the variable being used
2123  * uninitialized when in fact it always is.
2124  */
2125  pulse.num_pulse = 0;
2126 
2127  global_gain = get_bits(gb, 8);
2128 
2129  if (!common_window && !scale_flag) {
2130  ret = decode_ics_info(ac, ics, gb);
2131  if (ret < 0)
2132  goto fail;
2133  }
2134 
2135  if ((ret = decode_band_types(ac, sce->band_type,
2136  sce->band_type_run_end, gb, ics)) < 0)
2137  goto fail;
2138  if ((ret = decode_scalefactors(ac, sce->sf, gb, global_gain, ics,
2139  sce->band_type, sce->band_type_run_end)) < 0)
2140  goto fail;
2141 
2142  pulse_present = 0;
2143  if (!scale_flag) {
2144  if (!eld_syntax && (pulse_present = get_bits1(gb))) {
2145  if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) {
2146  av_log(ac->avctx, AV_LOG_ERROR,
2147  "Pulse tool not allowed in eight short sequence.\n");
2148  ret = AVERROR_INVALIDDATA;
2149  goto fail;
2150  }
2151  if (decode_pulses(&pulse, gb, ics->swb_offset, ics->num_swb)) {
2152  av_log(ac->avctx, AV_LOG_ERROR,
2153  "Pulse data corrupt or invalid.\n");
2154  ret = AVERROR_INVALIDDATA;
2155  goto fail;
2156  }
2157  }
2158  tns->present = get_bits1(gb);
2159  if (tns->present && !er_syntax) {
2160  ret = decode_tns(ac, tns, gb, ics);
2161  if (ret < 0)
2162  goto fail;
2163  }
2164  if (!eld_syntax && get_bits1(gb)) {
2165  decode_gain_control(sce, gb);
2166  if (!ac->warned_gain_control) {
2167  avpriv_report_missing_feature(ac->avctx, "Gain control");
2168  ac->warned_gain_control = 1;
2169  }
2170  }
2171  // I see no textual basis in the spec for this occurring after SSR gain
2172  // control, but this is what both reference and real implmentations do
2173  if (tns->present && er_syntax) {
2174  ret = decode_tns(ac, tns, gb, ics);
2175  if (ret < 0)
2176  goto fail;
2177  }
2178  }
2179 
2180  ret = decode_spectrum_and_dequant(ac, out, gb, sce->sf, pulse_present,
2181  &pulse, ics, sce->band_type);
2182  if (ret < 0)
2183  goto fail;
2184 
2185  if (ac->oc[1].m4ac.object_type == AOT_AAC_MAIN && !common_window)
2186  apply_prediction(ac, sce);
2187 
2188  return 0;
2189 fail:
2190  tns->present = 0;
2191  return ret;
2192 }
2193 
2194 /**
2195  * Mid/Side stereo decoding; reference: 4.6.8.1.3.
2196  */
2197 static void apply_mid_side_stereo(AACContext *ac, ChannelElement *cpe)
2198 {
2199  const IndividualChannelStream *ics = &cpe->ch[0].ics;
2200  INTFLOAT *ch0 = cpe->ch[0].coeffs;
2201  INTFLOAT *ch1 = cpe->ch[1].coeffs;
2202  int g, i, group, idx = 0;
2203  const uint16_t *offsets = ics->swb_offset;
2204  for (g = 0; g < ics->num_window_groups; g++) {
2205  for (i = 0; i < ics->max_sfb; i++, idx++) {
2206  if (cpe->ms_mask[idx] &&
2207  cpe->ch[0].band_type[idx] < NOISE_BT &&
2208  cpe->ch[1].band_type[idx] < NOISE_BT) {
2209 #if USE_FIXED
2210  for (group = 0; group < ics->group_len[g]; group++) {
2211  ac->fdsp->butterflies_fixed(ch0 + group * 128 + offsets[i],
2212  ch1 + group * 128 + offsets[i],
2213  offsets[i+1] - offsets[i]);
2214 #else
2215  for (group = 0; group < ics->group_len[g]; group++) {
2216  ac->fdsp->butterflies_float(ch0 + group * 128 + offsets[i],
2217  ch1 + group * 128 + offsets[i],
2218  offsets[i+1] - offsets[i]);
2219 #endif /* USE_FIXED */
2220  }
2221  }
2222  }
2223  ch0 += ics->group_len[g] * 128;
2224  ch1 += ics->group_len[g] * 128;
2225  }
2226 }
2227 
2228 /**
2229  * intensity stereo decoding; reference: 4.6.8.2.3
2230  *
2231  * @param ms_present Indicates mid/side stereo presence. [0] mask is all 0s;
2232  * [1] mask is decoded from bitstream; [2] mask is all 1s;
2233  * [3] reserved for scalable AAC
2234  */
2235 static void apply_intensity_stereo(AACContext *ac,
2236  ChannelElement *cpe, int ms_present)
2237 {
2238  const IndividualChannelStream *ics = &cpe->ch[1].ics;
2239  SingleChannelElement *sce1 = &cpe->ch[1];
2240  INTFLOAT *coef0 = cpe->ch[0].coeffs, *coef1 = cpe->ch[1].coeffs;
2241  const uint16_t *offsets = ics->swb_offset;
2242  int g, group, i, idx = 0;
2243  int c;
2244  INTFLOAT scale;
2245  for (g = 0; g < ics->num_window_groups; g++) {
2246  for (i = 0; i < ics->max_sfb;) {
2247  if (sce1->band_type[idx] == INTENSITY_BT ||
2248  sce1->band_type[idx] == INTENSITY_BT2) {
2249  const int bt_run_end = sce1->band_type_run_end[idx];
2250  for (; i < bt_run_end; i++, idx++) {
2251  c = -1 + 2 * (sce1->band_type[idx] - 14);
2252  if (ms_present)
2253  c *= 1 - 2 * cpe->ms_mask[idx];
2254  scale = c * sce1->sf[idx];
2255  for (group = 0; group < ics->group_len[g]; group++)
2256 #if USE_FIXED
2257  ac->subband_scale(coef1 + group * 128 + offsets[i],
2258  coef0 + group * 128 + offsets[i],
2259  scale,
2260  23,
2261  offsets[i + 1] - offsets[i] ,ac->avctx);
2262 #else
2263  ac->fdsp->vector_fmul_scalar(coef1 + group * 128 + offsets[i],
2264  coef0 + group * 128 + offsets[i],
2265  scale,
2266  offsets[i + 1] - offsets[i]);
2267 #endif /* USE_FIXED */
2268  }
2269  } else {
2270  int bt_run_end = sce1->band_type_run_end[idx];
2271  idx += bt_run_end - i;
2272  i = bt_run_end;
2273  }
2274  }
2275  coef0 += ics->group_len[g] * 128;
2276  coef1 += ics->group_len[g] * 128;
2277  }
2278 }
2279 
2280 /**
2281  * Decode a channel_pair_element; reference: table 4.4.
2282  *
2283  * @return Returns error status. 0 - OK, !0 - error
2284  */
2285 static int decode_cpe(AACContext *ac, GetBitContext *gb, ChannelElement *cpe)
2286 {
2287  int i, ret, common_window, ms_present = 0;
2288  int eld_syntax = ac->oc[1].m4ac.object_type == AOT_ER_AAC_ELD;
2289 
2290  common_window = eld_syntax || get_bits1(gb);
2291  if (common_window) {
2292  if (decode_ics_info(ac, &cpe->ch[0].ics, gb))
2293  return AVERROR_INVALIDDATA;
2294  i = cpe->ch[1].ics.use_kb_window[0];
2295  cpe->ch[1].ics = cpe->ch[0].ics;
2296  cpe->ch[1].ics.use_kb_window[1] = i;
2297  if (cpe->ch[1].ics.predictor_present &&
2298  (ac->oc[1].m4ac.object_type != AOT_AAC_MAIN))
2299  if ((cpe->ch[1].ics.ltp.present = get_bits(gb, 1)))
2300  decode_ltp(&cpe->ch[1].ics.ltp, gb, cpe->ch[1].ics.max_sfb);
2301  ms_present = get_bits(gb, 2);
2302  if (ms_present == 3) {
2303  av_log(ac->avctx, AV_LOG_ERROR, "ms_present = 3 is reserved.\n");
2304  return AVERROR_INVALIDDATA;
2305  } else if (ms_present)
2306  decode_mid_side_stereo(cpe, gb, ms_present);
2307  }
2308  if ((ret = decode_ics(ac, &cpe->ch[0], gb, common_window, 0)))
2309  return ret;
2310  if ((ret = decode_ics(ac, &cpe->ch[1], gb, common_window, 0)))
2311  return ret;
2312 
2313  if (common_window) {
2314  if (ms_present)
2315  apply_mid_side_stereo(ac, cpe);
2316  if (ac->oc[1].m4ac.object_type == AOT_AAC_MAIN) {
2317  apply_prediction(ac, &cpe->ch[0]);
2318  apply_prediction(ac, &cpe->ch[1]);
2319  }
2320  }
2321 
2322  apply_intensity_stereo(ac, cpe, ms_present);
2323  return 0;
2324 }
2325 
2326 static const float cce_scale[] = {
2327  1.09050773266525765921, //2^(1/8)
2328  1.18920711500272106672, //2^(1/4)
2329  M_SQRT2,
2330  2,
2331 };
2332 
2333 /**
2334  * Decode coupling_channel_element; reference: table 4.8.
2335  *
2336  * @return Returns error status. 0 - OK, !0 - error
2337  */
2338 static int decode_cce(AACContext *ac, GetBitContext *gb, ChannelElement *che)
2339 {
2340  int num_gain = 0;
2341  int c, g, sfb, ret;
2342  int sign;
2343  INTFLOAT scale;
2344  SingleChannelElement *sce = &che->ch[0];
2345  ChannelCoupling *coup = &che->coup;
2346 
2347  coup->coupling_point = 2 * get_bits1(gb);
2348  coup->num_coupled = get_bits(gb, 3);
2349  for (c = 0; c <= coup->num_coupled; c++) {
2350  num_gain++;
2351  coup->type[c] = get_bits1(gb) ? TYPE_CPE : TYPE_SCE;
2352  coup->id_select[c] = get_bits(gb, 4);
2353  if (coup->type[c] == TYPE_CPE) {
2354  coup->ch_select[c] = get_bits(gb, 2);
2355  if (coup->ch_select[c] == 3)
2356  num_gain++;
2357  } else
2358  coup->ch_select[c] = 2;
2359  }
2360  coup->coupling_point += get_bits1(gb) || (coup->coupling_point >> 1);
2361 
2362  sign = get_bits(gb, 1);
2363 #if USE_FIXED
2364  scale = get_bits(gb, 2);
2365 #else
2366  scale = cce_scale[get_bits(gb, 2)];
2367 #endif
2368 
2369  if ((ret = decode_ics(ac, sce, gb, 0, 0)))
2370  return ret;
2371 
2372  for (c = 0; c < num_gain; c++) {
2373  int idx = 0;
2374  int cge = 1;
2375  int gain = 0;
2376  INTFLOAT gain_cache = FIXR10(1.);
2377  if (c) {
2378  cge = coup->coupling_point == AFTER_IMDCT ? 1 : get_bits1(gb);
2379  gain = cge ? get_vlc2(gb, vlc_scalefactors.table, 7, 3) - 60: 0;
2380  gain_cache = GET_GAIN(scale, gain);
2381 #if USE_FIXED
2382  if ((abs(gain_cache)-1024) >> 3 > 30)
2383  return AVERROR(ERANGE);
2384 #endif
2385  }
2386  if (coup->coupling_point == AFTER_IMDCT) {
2387  coup->gain[c][0] = gain_cache;
2388  } else {
2389  for (g = 0; g < sce->ics.num_window_groups; g++) {
2390  for (sfb = 0; sfb < sce->ics.max_sfb; sfb++, idx++) {
2391  if (sce->band_type[idx] != ZERO_BT) {
2392  if (!cge) {
2393  int t = get_vlc2(gb, vlc_scalefactors.table, 7, 3) - 60;
2394  if (t) {
2395  int s = 1;
2396  t = gain += t;
2397  if (sign) {
2398  s -= 2 * (t & 0x1);
2399  t >>= 1;
2400  }
2401  gain_cache = GET_GAIN(scale, t) * s;
2402 #if USE_FIXED
2403  if ((abs(gain_cache)-1024) >> 3 > 30)
2404  return AVERROR(ERANGE);
2405 #endif
2406  }
2407  }
2408  coup->gain[c][idx] = gain_cache;
2409  }
2410  }
2411  }
2412  }
2413  }
2414  return 0;
2415 }
2416 
2417 /**
2418  * Parse whether channels are to be excluded from Dynamic Range Compression; reference: table 4.53.
2419  *
2420  * @return Returns number of bytes consumed.
2421  */
2422 static int decode_drc_channel_exclusions(DynamicRangeControl *che_drc,
2423  GetBitContext *gb)
2424 {
2425  int i;
2426  int num_excl_chan = 0;
2427 
2428  do {
2429  for (i = 0; i < 7; i++)
2430  che_drc->exclude_mask[num_excl_chan++] = get_bits1(gb);
2431  } while (num_excl_chan < MAX_CHANNELS - 7 && get_bits1(gb));
2432 
2433  return num_excl_chan / 7;
2434 }
2435 
2436 /**
2437  * Decode dynamic range information; reference: table 4.52.
2438  *
2439  * @return Returns number of bytes consumed.
2440  */
2441 static int decode_dynamic_range(DynamicRangeControl *che_drc,
2442  GetBitContext *gb)
2443 {
2444  int n = 1;
2445  int drc_num_bands = 1;
2446  int i;
2447 
2448  /* pce_tag_present? */
2449  if (get_bits1(gb)) {
2450  che_drc->pce_instance_tag = get_bits(gb, 4);
2451  skip_bits(gb, 4); // tag_reserved_bits
2452  n++;
2453  }
2454 
2455  /* excluded_chns_present? */
2456  if (get_bits1(gb)) {
2457  n += decode_drc_channel_exclusions(che_drc, gb);
2458  }
2459 
2460  /* drc_bands_present? */
2461  if (get_bits1(gb)) {
2462  che_drc->band_incr = get_bits(gb, 4);
2463  che_drc->interpolation_scheme = get_bits(gb, 4);
2464  n++;
2465  drc_num_bands += che_drc->band_incr;
2466  for (i = 0; i < drc_num_bands; i++) {
2467  che_drc->band_top[i] = get_bits(gb, 8);
2468  n++;
2469  }
2470  }
2471 
2472  /* prog_ref_level_present? */
2473  if (get_bits1(gb)) {
2474  che_drc->prog_ref_level = get_bits(gb, 7);
2475  skip_bits1(gb); // prog_ref_level_reserved_bits
2476  n++;
2477  }
2478 
2479  for (i = 0; i < drc_num_bands; i++) {
2480  che_drc->dyn_rng_sgn[i] = get_bits1(gb);
2481  che_drc->dyn_rng_ctl[i] = get_bits(gb, 7);
2482  n++;
2483  }
2484 
2485  return n;
2486 }
2487 
2488 static int decode_fill(AACContext *ac, GetBitContext *gb, int len) {
2489  uint8_t buf[256];
2490  int i, major, minor;
2491 
2492  if (len < 13+7*8)
2493  goto unknown;
2494 
2495  get_bits(gb, 13); len -= 13;
2496 
2497  for(i=0; i+1<sizeof(buf) && len>=8; i++, len-=8)
2498  buf[i] = get_bits(gb, 8);
2499 
2500  buf[i] = 0;
2501  if (ac->avctx->debug & FF_DEBUG_PICT_INFO)
2502  av_log(ac->avctx, AV_LOG_DEBUG, "FILL:%s\n", buf);
2503 
2504  if (sscanf(buf, "libfaac %d.%d", &major, &minor) == 2){
2505  ac->avctx->internal->skip_samples = 1024;
2506  }
2507 
2508 unknown:
2509  skip_bits_long(gb, len);
2510 
2511  return 0;
2512 }
2513 
2514 /**
2515  * Decode extension data (incomplete); reference: table 4.51.
2516  *
2517  * @param cnt length of TYPE_FIL syntactic element in bytes
2518  *
2519  * @return Returns number of bytes consumed
2520  */
2521 static int decode_extension_payload(AACContext *ac, GetBitContext *gb, int cnt,
2522  ChannelElement *che, enum RawDataBlockType elem_type)
2523 {
2524  int crc_flag = 0;
2525  int res = cnt;
2526  int type = get_bits(gb, 4);
2527 
2528  if (ac->avctx->debug & FF_DEBUG_STARTCODE)
2529  av_log(ac->avctx, AV_LOG_DEBUG, "extension type: %d len:%d\n", type, cnt);
2530 
2531  switch (type) { // extension type
2532  case EXT_SBR_DATA_CRC:
2533  crc_flag++;
2534  case EXT_SBR_DATA:
2535  if (!che) {
2536  av_log(ac->avctx, AV_LOG_ERROR, "SBR was found before the first channel element.\n");
2537  return res;
2538  } else if (ac->oc[1].m4ac.frame_length_short) {
2539  if (!ac->warned_960_sbr)
2540  avpriv_report_missing_feature(ac->avctx,
2541  "SBR with 960 frame length");
2542  ac->warned_960_sbr = 1;
2543  skip_bits_long(gb, 8 * cnt - 4);
2544  return res;
2545  } else if (!ac->oc[1].m4ac.sbr) {
2546  av_log(ac->avctx, AV_LOG_ERROR, "SBR signaled to be not-present but was found in the bitstream.\n");
2547  skip_bits_long(gb, 8 * cnt - 4);
2548  return res;
2549  } else if (ac->oc[1].m4ac.sbr == -1 && ac->oc[1].status == OC_LOCKED) {
2550  av_log(ac->avctx, AV_LOG_ERROR, "Implicit SBR was found with a first occurrence after the first frame.\n");
2551  skip_bits_long(gb, 8 * cnt - 4);
2552  return res;
2553  } else if (ac->oc[1].m4ac.ps == -1 && ac->oc[1].status < OC_LOCKED && ac->avctx->channels == 1) {
2554  ac->oc[1].m4ac.sbr = 1;
2555  ac->oc[1].m4ac.ps = 1;
2556  ac->avctx->profile = FF_PROFILE_AAC_HE_V2;
2557  output_configure(ac, ac->oc[1].layout_map, ac->oc[1].layout_map_tags,
2558  ac->oc[1].status, 1);
2559  } else {
2560  ac->oc[1].m4ac.sbr = 1;
2561  ac->avctx->profile = FF_PROFILE_AAC_HE;
2562  }
2563  res = AAC_RENAME(ff_decode_sbr_extension)(ac, &che->sbr, gb, crc_flag, cnt, elem_type);
2564  break;
2565  case EXT_DYNAMIC_RANGE:
2566  res = decode_dynamic_range(&ac->che_drc, gb);
2567  break;
2568  case EXT_FILL:
2569  decode_fill(ac, gb, 8 * cnt - 4);
2570  break;
2571  case EXT_FILL_DATA:
2572  case EXT_DATA_ELEMENT:
2573  default:
2574  skip_bits_long(gb, 8 * cnt - 4);
2575  break;
2576  };
2577  return res;
2578 }
2579 
2580 /**
2581  * Decode Temporal Noise Shaping filter coefficients and apply all-pole filters; reference: 4.6.9.3.
2582  *
2583  * @param decode 1 if tool is used normally, 0 if tool is used in LTP.
2584  * @param coef spectral coefficients
2585  */
2586 static void apply_tns(INTFLOAT coef_param[1024], TemporalNoiseShaping *tns,
2587  IndividualChannelStream *ics, int decode)
2588 {
2589  const int mmm = FFMIN(ics->tns_max_bands, ics->max_sfb);
2590  int w, filt, m, i;
2591  int bottom, top, order, start, end, size, inc;
2592  INTFLOAT lpc[TNS_MAX_ORDER];
2593  INTFLOAT tmp[TNS_MAX_ORDER+1];
2594  UINTFLOAT *coef = coef_param;
2595 
2596  if(!mmm)
2597  return;
2598 
2599  for (w = 0; w < ics->num_windows; w++) {
2600  bottom = ics->num_swb;
2601  for (filt = 0; filt < tns->n_filt[w]; filt++) {
2602  top = bottom;
2603  bottom = FFMAX(0, top - tns->length[w][filt]);
2604  order = tns->order[w][filt];
2605  if (order == 0)
2606  continue;
2607 
2608  // tns_decode_coef
2609  AAC_RENAME(compute_lpc_coefs)(tns->coef[w][filt], order, lpc, 0, 0, 0);
2610 
2611  start = ics->swb_offset[FFMIN(bottom, mmm)];
2612  end = ics->swb_offset[FFMIN( top, mmm)];
2613  if ((size = end - start) <= 0)
2614  continue;
2615  if (tns->direction[w][filt]) {
2616  inc = -1;
2617  start = end - 1;
2618  } else {
2619  inc = 1;
2620  }
2621  start += w * 128;
2622 
2623  if (decode) {
2624  // ar filter
2625  for (m = 0; m < size; m++, start += inc)
2626  for (i = 1; i <= FFMIN(m, order); i++)
2627  coef[start] -= AAC_MUL26((INTFLOAT)coef[start - i * inc], lpc[i - 1]);
2628  } else {
2629  // ma filter
2630  for (m = 0; m < size; m++, start += inc) {
2631  tmp[0] = coef[start];
2632  for (i = 1; i <= FFMIN(m, order); i++)
2633  coef[start] += AAC_MUL26(tmp[i], lpc[i - 1]);
2634  for (i = order; i > 0; i--)
2635  tmp[i] = tmp[i - 1];
2636  }
2637  }
2638  }
2639  }
2640 }
2641 
2642 /**
2643  * Apply windowing and MDCT to obtain the spectral
2644  * coefficient from the predicted sample by LTP.
2645  */
2646 static void windowing_and_mdct_ltp(AACContext *ac, INTFLOAT *out,
2647  INTFLOAT *in, IndividualChannelStream *ics)
2648 {
2649  const INTFLOAT *lwindow = ics->use_kb_window[0] ? AAC_RENAME2(aac_kbd_long_1024) : AAC_RENAME2(sine_1024);
2650  const INTFLOAT *swindow = ics->use_kb_window[0] ? AAC_RENAME2(aac_kbd_short_128) : AAC_RENAME2(sine_128);
2651  const INTFLOAT *lwindow_prev = ics->use_kb_window[1] ? AAC_RENAME2(aac_kbd_long_1024) : AAC_RENAME2(sine_1024);
2652  const INTFLOAT *swindow_prev = ics->use_kb_window[1] ? AAC_RENAME2(aac_kbd_short_128) : AAC_RENAME2(sine_128);
2653 
2654  if (ics->window_sequence[0] != LONG_STOP_SEQUENCE) {
2655  ac->fdsp->vector_fmul(in, in, lwindow_prev, 1024);
2656  } else {
2657  memset(in, 0, 448 * sizeof(*in));
2658  ac->fdsp->vector_fmul(in + 448, in + 448, swindow_prev, 128);
2659  }
2660  if (ics->window_sequence[0] != LONG_START_SEQUENCE) {
2661  ac->fdsp->vector_fmul_reverse(in + 1024, in + 1024, lwindow, 1024);
2662  } else {
2663  ac->fdsp->vector_fmul_reverse(in + 1024 + 448, in + 1024 + 448, swindow, 128);
2664  memset(in + 1024 + 576, 0, 448 * sizeof(*in));
2665  }
2666  ac->mdct_ltp.mdct_calc(&ac->mdct_ltp, out, in);
2667 }
2668 
2669 /**
2670  * Apply the long term prediction
2671  */
2672 static void apply_ltp(AACContext *ac, SingleChannelElement *sce)
2673 {
2674  const LongTermPrediction *ltp = &sce->ics.ltp;
2675  const uint16_t *offsets = sce->ics.swb_offset;
2676  int i, sfb;
2677 
2678  if (sce->ics.window_sequence[0] != EIGHT_SHORT_SEQUENCE) {
2679  INTFLOAT *predTime = sce->ret;
2680  INTFLOAT *predFreq = ac->buf_mdct;
2681  int16_t num_samples = 2048;
2682 
2683  if (ltp->lag < 1024)
2684  num_samples = ltp->lag + 1024;
2685  for (i = 0; i < num_samples; i++)
2686  predTime[i] = AAC_MUL30(sce->ltp_state[i + 2048 - ltp->lag], ltp->coef);
2687  memset(&predTime[i], 0, (2048 - i) * sizeof(*predTime));
2688 
2689  ac->windowing_and_mdct_ltp(ac, predFreq, predTime, &sce->ics);
2690 
2691  if (sce->tns.present)
2692  ac->apply_tns(predFreq, &sce->tns, &sce->ics, 0);
2693 
2694  for (sfb = 0; sfb < FFMIN(sce->ics.max_sfb, MAX_LTP_LONG_SFB); sfb++)
2695  if (ltp->used[sfb])
2696  for (i = offsets[sfb]; i < offsets[sfb + 1]; i++)
2697  sce->coeffs[i] += (UINTFLOAT)predFreq[i];
2698  }
2699 }
2700 
2701 /**
2702  * Update the LTP buffer for next frame
2703  */
2704 static void update_ltp(AACContext *ac, SingleChannelElement *sce)
2705 {
2706  IndividualChannelStream *ics = &sce->ics;
2707  INTFLOAT *saved = sce->saved;
2708  INTFLOAT *saved_ltp = sce->coeffs;
2709  const INTFLOAT *lwindow = ics->use_kb_window[0] ? AAC_RENAME2(aac_kbd_long_1024) : AAC_RENAME2(sine_1024);
2710  const INTFLOAT *swindow = ics->use_kb_window[0] ? AAC_RENAME2(aac_kbd_short_128) : AAC_RENAME2(sine_128);
2711  int i;
2712 
2713  if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) {
2714  memcpy(saved_ltp, saved, 512 * sizeof(*saved_ltp));
2715  memset(saved_ltp + 576, 0, 448 * sizeof(*saved_ltp));
2716  ac->fdsp->vector_fmul_reverse(saved_ltp + 448, ac->buf_mdct + 960, &swindow[64], 64);
2717 
2718  for (i = 0; i < 64; i++)
2719  saved_ltp[i + 512] = AAC_MUL31(ac->buf_mdct[1023 - i], swindow[63 - i]);
2720  } else if (ics->window_sequence[0] == LONG_START_SEQUENCE) {
2721  memcpy(saved_ltp, ac->buf_mdct + 512, 448 * sizeof(*saved_ltp));
2722  memset(saved_ltp + 576, 0, 448 * sizeof(*saved_ltp));
2723  ac->fdsp->vector_fmul_reverse(saved_ltp + 448, ac->buf_mdct + 960, &swindow[64], 64);
2724 
2725  for (i = 0; i < 64; i++)
2726  saved_ltp[i + 512] = AAC_MUL31(ac->buf_mdct[1023 - i], swindow[63 - i]);
2727  } else { // LONG_STOP or ONLY_LONG
2728  ac->fdsp->vector_fmul_reverse(saved_ltp, ac->buf_mdct + 512, &lwindow[512], 512);
2729 
2730  for (i = 0; i < 512; i++)
2731  saved_ltp[i + 512] = AAC_MUL31(ac->buf_mdct[1023 - i], lwindow[511 - i]);
2732  }
2733 
2734  memcpy(sce->ltp_state, sce->ltp_state+1024, 1024 * sizeof(*sce->ltp_state));
2735  memcpy(sce->ltp_state+1024, sce->ret, 1024 * sizeof(*sce->ltp_state));
2736  memcpy(sce->ltp_state+2048, saved_ltp, 1024 * sizeof(*sce->ltp_state));
2737 }
2738 
2739 /**
2740  * Conduct IMDCT and windowing.
2741  */
2742 static void imdct_and_windowing(AACContext *ac, SingleChannelElement *sce)
2743 {
2744  IndividualChannelStream *ics = &sce->ics;
2745  INTFLOAT *in = sce->coeffs;
2746  INTFLOAT *out = sce->ret;
2747  INTFLOAT *saved = sce->saved;
2748  const INTFLOAT *swindow = ics->use_kb_window[0] ? AAC_RENAME2(aac_kbd_short_128) : AAC_RENAME2(sine_128);
2749  const INTFLOAT *lwindow_prev = ics->use_kb_window[1] ? AAC_RENAME2(aac_kbd_long_1024) : AAC_RENAME2(sine_1024);
2750  const INTFLOAT *swindow_prev = ics->use_kb_window[1] ? AAC_RENAME2(aac_kbd_short_128) : AAC_RENAME2(sine_128);
2751  INTFLOAT *buf = ac->buf_mdct;
2752  INTFLOAT *temp = ac->temp;
2753  int i;
2754 
2755  // imdct
2756  if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) {
2757  for (i = 0; i < 1024; i += 128)
2758  ac->mdct_small.imdct_half(&ac->mdct_small, buf + i, in + i);
2759  } else {
2760  ac->mdct.imdct_half(&ac->mdct, buf, in);
2761 #if USE_FIXED
2762  for (i=0; i<1024; i++)
2763  buf[i] = (buf[i] + 4LL) >> 3;
2764 #endif /* USE_FIXED */
2765  }
2766 
2767  /* window overlapping
2768  * NOTE: To simplify the overlapping code, all 'meaningless' short to long
2769  * and long to short transitions are considered to be short to short
2770  * transitions. This leaves just two cases (long to long and short to short)
2771  * with a little special sauce for EIGHT_SHORT_SEQUENCE.
2772  */
2773  if ((ics->window_sequence[1] == ONLY_LONG_SEQUENCE || ics->window_sequence[1] == LONG_STOP_SEQUENCE) &&
2774  (ics->window_sequence[0] == ONLY_LONG_SEQUENCE || ics->window_sequence[0] == LONG_START_SEQUENCE)) {
2775  ac->fdsp->vector_fmul_window( out, saved, buf, lwindow_prev, 512);
2776  } else {
2777  memcpy( out, saved, 448 * sizeof(*out));
2778 
2779  if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) {
2780  ac->fdsp->vector_fmul_window(out + 448 + 0*128, saved + 448, buf + 0*128, swindow_prev, 64);
2781  ac->fdsp->vector_fmul_window(out + 448 + 1*128, buf + 0*128 + 64, buf + 1*128, swindow, 64);
2782  ac->fdsp->vector_fmul_window(out + 448 + 2*128, buf + 1*128 + 64, buf + 2*128, swindow, 64);
2783  ac->fdsp->vector_fmul_window(out + 448 + 3*128, buf + 2*128 + 64, buf + 3*128, swindow, 64);
2784  ac->fdsp->vector_fmul_window(temp, buf + 3*128 + 64, buf + 4*128, swindow, 64);
2785  memcpy( out + 448 + 4*128, temp, 64 * sizeof(*out));
2786  } else {
2787  ac->fdsp->vector_fmul_window(out + 448, saved + 448, buf, swindow_prev, 64);
2788  memcpy( out + 576, buf + 64, 448 * sizeof(*out));
2789  }
2790  }
2791 
2792  // buffer update
2793  if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) {
2794  memcpy( saved, temp + 64, 64 * sizeof(*saved));
2795  ac->fdsp->vector_fmul_window(saved + 64, buf + 4*128 + 64, buf + 5*128, swindow, 64);
2796  ac->fdsp->vector_fmul_window(saved + 192, buf + 5*128 + 64, buf + 6*128, swindow, 64);
2797  ac->fdsp->vector_fmul_window(saved + 320, buf + 6*128 + 64, buf + 7*128, swindow, 64);
2798  memcpy( saved + 448, buf + 7*128 + 64, 64 * sizeof(*saved));
2799  } else if (ics->window_sequence[0] == LONG_START_SEQUENCE) {
2800  memcpy( saved, buf + 512, 448 * sizeof(*saved));
2801  memcpy( saved + 448, buf + 7*128 + 64, 64 * sizeof(*saved));
2802  } else { // LONG_STOP or ONLY_LONG
2803  memcpy( saved, buf + 512, 512 * sizeof(*saved));
2804  }
2805 }
2806 
2807 /**
2808  * Conduct IMDCT and windowing.
2809  */
2810 static void imdct_and_windowing_960(AACContext *ac, SingleChannelElement *sce)
2811 {
2812 #if !USE_FIXED
2813  IndividualChannelStream *ics = &sce->ics;
2814  INTFLOAT *in = sce->coeffs;
2815  INTFLOAT *out = sce->ret;
2816  INTFLOAT *saved = sce->saved;
2817  const INTFLOAT *swindow = ics->use_kb_window[0] ? AAC_RENAME(aac_kbd_short_120) : AAC_RENAME(sine_120);
2818  const INTFLOAT *lwindow_prev = ics->use_kb_window[1] ? AAC_RENAME(aac_kbd_long_960) : AAC_RENAME(sine_960);
2819  const INTFLOAT *swindow_prev = ics->use_kb_window[1] ? AAC_RENAME(aac_kbd_short_120) : AAC_RENAME(sine_120);
2820  INTFLOAT *buf = ac->buf_mdct;
2821  INTFLOAT *temp = ac->temp;
2822  int i;
2823 
2824  // imdct
2825  if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) {
2826  for (i = 0; i < 8; i++)
2827  ac->mdct120->imdct_half(ac->mdct120, buf + i * 120, in + i * 128, 1);
2828  } else {
2829  ac->mdct960->imdct_half(ac->mdct960, buf, in, 1);
2830  }
2831 
2832  /* window overlapping
2833  * NOTE: To simplify the overlapping code, all 'meaningless' short to long
2834  * and long to short transitions are considered to be short to short
2835  * transitions. This leaves just two cases (long to long and short to short)
2836  * with a little special sauce for EIGHT_SHORT_SEQUENCE.
2837  */
2838 
2839  if ((ics->window_sequence[1] == ONLY_LONG_SEQUENCE || ics->window_sequence[1] == LONG_STOP_SEQUENCE) &&
2840  (ics->window_sequence[0] == ONLY_LONG_SEQUENCE || ics->window_sequence[0] == LONG_START_SEQUENCE)) {
2841  ac->fdsp->vector_fmul_window( out, saved, buf, lwindow_prev, 480);
2842  } else {
2843  memcpy( out, saved, 420 * sizeof(*out));
2844 
2845  if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) {
2846  ac->fdsp->vector_fmul_window(out + 420 + 0*120, saved + 420, buf + 0*120, swindow_prev, 60);
2847  ac->fdsp->vector_fmul_window(out + 420 + 1*120, buf + 0*120 + 60, buf + 1*120, swindow, 60);
2848  ac->fdsp->vector_fmul_window(out + 420 + 2*120, buf + 1*120 + 60, buf + 2*120, swindow, 60);
2849  ac->fdsp->vector_fmul_window(out + 420 + 3*120, buf + 2*120 + 60, buf + 3*120, swindow, 60);
2850  ac->fdsp->vector_fmul_window(temp, buf + 3*120 + 60, buf + 4*120, swindow, 60);
2851  memcpy( out + 420 + 4*120, temp, 60 * sizeof(*out));
2852  } else {
2853  ac->fdsp->vector_fmul_window(out + 420, saved + 420, buf, swindow_prev, 60);
2854  memcpy( out + 540, buf + 60, 420 * sizeof(*out));
2855  }
2856  }
2857 
2858  // buffer update
2859  if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) {
2860  memcpy( saved, temp + 60, 60 * sizeof(*saved));
2861  ac->fdsp->vector_fmul_window(saved + 60, buf + 4*120 + 60, buf + 5*120, swindow, 60);
2862  ac->fdsp->vector_fmul_window(saved + 180, buf + 5*120 + 60, buf + 6*120, swindow, 60);
2863  ac->fdsp->vector_fmul_window(saved + 300, buf + 6*120 + 60, buf + 7*120, swindow, 60);
2864  memcpy( saved + 420, buf + 7*120 + 60, 60 * sizeof(*saved));
2865  } else if (ics->window_sequence[0] == LONG_START_SEQUENCE) {
2866  memcpy( saved, buf + 480, 420 * sizeof(*saved));
2867  memcpy( saved + 420, buf + 7*120 + 60, 60 * sizeof(*saved));
2868  } else { // LONG_STOP or ONLY_LONG
2869  memcpy( saved, buf + 480, 480 * sizeof(*saved));
2870  }
2871 #endif
2872 }
2873 static void imdct_and_windowing_ld(AACContext *ac, SingleChannelElement *sce)
2874 {
2875  IndividualChannelStream *ics = &sce->ics;
2876  INTFLOAT *in = sce->coeffs;
2877  INTFLOAT *out = sce->ret;
2878  INTFLOAT *saved = sce->saved;
2879  INTFLOAT *buf = ac->buf_mdct;
2880 #if USE_FIXED
2881  int i;
2882 #endif /* USE_FIXED */
2883 
2884  // imdct
2885  ac->mdct.imdct_half(&ac->mdct_ld, buf, in);
2886 
2887 #if USE_FIXED
2888  for (i = 0; i < 1024; i++)
2889  buf[i] = (buf[i] + 2) >> 2;
2890 #endif /* USE_FIXED */
2891 
2892  // window overlapping
2893  if (ics->use_kb_window[1]) {
2894  // AAC LD uses a low overlap sine window instead of a KBD window
2895  memcpy(out, saved, 192 * sizeof(*out));
2896  ac->fdsp->vector_fmul_window(out + 192, saved + 192, buf, AAC_RENAME2(sine_128), 64);
2897  memcpy( out + 320, buf + 64, 192 * sizeof(*out));
2898  } else {
2899  ac->fdsp->vector_fmul_window(out, saved, buf, AAC_RENAME2(sine_512), 256);
2900  }
2901 
2902  // buffer update
2903  memcpy(saved, buf + 256, 256 * sizeof(*saved));
2904 }
2905 
2906 static void imdct_and_windowing_eld(AACContext *ac, SingleChannelElement *sce)
2907 {
2908  INTFLOAT *in = sce->coeffs;
2909  INTFLOAT *out = sce->ret;
2910  INTFLOAT *saved = sce->saved;
2911  INTFLOAT *buf = ac->buf_mdct;
2912  int i;
2913  const int n = ac->oc[1].m4ac.frame_length_short ? 480 : 512;
2914  const int n2 = n >> 1;
2915  const int n4 = n >> 2;
2916  const INTFLOAT *const window = n == 480 ? AAC_RENAME(ff_aac_eld_window_480) :
2917  AAC_RENAME(ff_aac_eld_window_512);
2918 
2919  // Inverse transform, mapped to the conventional IMDCT by
2920  // Chivukula, R.K.; Reznik, Y.A.; Devarajan, V.,
2921  // "Efficient algorithms for MPEG-4 AAC-ELD, AAC-LD and AAC-LC filterbanks,"
2922  // International Conference on Audio, Language and Image Processing, ICALIP 2008.
2923  // URL: http://ieeexplore.ieee.org/stamp/stamp.jsp?tp=&arnumber=4590245&isnumber=4589950
2924  for (i = 0; i < n2; i+=2) {
2925  INTFLOAT temp;
2926  temp = in[i ]; in[i ] = -in[n - 1 - i]; in[n - 1 - i] = temp;
2927  temp = -in[i + 1]; in[i + 1] = in[n - 2 - i]; in[n - 2 - i] = temp;
2928  }
2929 #if !USE_FIXED
2930  if (n == 480)
2931  ac->mdct480->imdct_half(ac->mdct480, buf, in, 1);
2932  else
2933 #endif
2934  ac->mdct.imdct_half(&ac->mdct_ld, buf, in);
2935 
2936 #if USE_FIXED
2937  for (i = 0; i < 1024; i++)
2938  buf[i] = (buf[i] + 1) >> 1;
2939 #endif /* USE_FIXED */
2940 
2941  for (i = 0; i < n; i+=2) {
2942  buf[i] = -buf[i];
2943  }
2944  // Like with the regular IMDCT at this point we still have the middle half
2945  // of a transform but with even symmetry on the left and odd symmetry on
2946  // the right
2947 
2948  // window overlapping
2949  // The spec says to use samples [0..511] but the reference decoder uses
2950  // samples [128..639].
2951  for (i = n4; i < n2; i ++) {
2952  out[i - n4] = AAC_MUL31( buf[ n2 - 1 - i] , window[i - n4]) +
2953  AAC_MUL31( saved[ i + n2] , window[i + n - n4]) +
2954  AAC_MUL31(-saved[n + n2 - 1 - i] , window[i + 2*n - n4]) +
2955  AAC_MUL31(-saved[ 2*n + n2 + i] , window[i + 3*n - n4]);
2956  }
2957  for (i = 0; i < n2; i ++) {
2958  out[n4 + i] = AAC_MUL31( buf[ i] , window[i + n2 - n4]) +
2959  AAC_MUL31(-saved[ n - 1 - i] , window[i + n2 + n - n4]) +
2960  AAC_MUL31(-saved[ n + i] , window[i + n2 + 2*n - n4]) +
2961  AAC_MUL31( saved[2*n + n - 1 - i] , window[i + n2 + 3*n - n4]);
2962  }
2963  for (i = 0; i < n4; i ++) {
2964  out[n2 + n4 + i] = AAC_MUL31( buf[ i + n2] , window[i + n - n4]) +
2965  AAC_MUL31(-saved[n2 - 1 - i] , window[i + 2*n - n4]) +
2966  AAC_MUL31(-saved[n + n2 + i] , window[i + 3*n - n4]);
2967  }
2968 
2969  // buffer update
2970  memmove(saved + n, saved, 2 * n * sizeof(*saved));
2971  memcpy( saved, buf, n * sizeof(*saved));
2972 }
2973 
2974 /**
2975  * channel coupling transformation interface
2976  *
2977  * @param apply_coupling_method pointer to (in)dependent coupling function
2978  */
2979 static void apply_channel_coupling(AACContext *ac, ChannelElement *cc,
2980  enum RawDataBlockType type, int elem_id,
2981  enum CouplingPoint coupling_point,
2982  void (*apply_coupling_method)(AACContext *ac, SingleChannelElement *target, ChannelElement *cce, int index))
2983 {
2984  int i, c;
2985 
2986  for (i = 0; i < MAX_ELEM_ID; i++) {
2987  ChannelElement *cce = ac->che[TYPE_CCE][i];
2988  int index = 0;
2989 
2990  if (cce && cce->coup.coupling_point == coupling_point) {
2991  ChannelCoupling *coup = &cce->coup;
2992 
2993  for (c = 0; c <= coup->num_coupled; c++) {
2994  if (coup->type[c] == type && coup->id_select[c] == elem_id) {
2995  if (coup->ch_select[c] != 1) {
2996  apply_coupling_method(ac, &cc->ch[0], cce, index);
2997  if (coup->ch_select[c] != 0)
2998  index++;
2999  }
3000  if (coup->ch_select[c] != 2)
3001  apply_coupling_method(ac, &cc->ch[1], cce, index++);
3002  } else
3003  index += 1 + (coup->ch_select[c] == 3);
3004  }
3005  }
3006  }
3007 }
3008 
3009 /**
3010  * Convert spectral data to samples, applying all supported tools as appropriate.
3011  */
3012 static void spectral_to_sample(AACContext *ac, int samples)
3013 {
3014  int i, type;
3015  void (*imdct_and_window)(AACContext *ac, SingleChannelElement *sce);
3016  switch (ac->oc[1].m4ac.object_type) {
3017  case AOT_ER_AAC_LD:
3018  imdct_and_window = imdct_and_windowing_ld;
3019  break;
3020  case AOT_ER_AAC_ELD:
3021  imdct_and_window = imdct_and_windowing_eld;
3022  break;
3023  default:
3024  if (ac->oc[1].m4ac.frame_length_short)
3025  imdct_and_window = imdct_and_windowing_960;
3026  else
3027  imdct_and_window = ac->imdct_and_windowing;
3028  }
3029  for (type = 3; type >= 0; type--) {
3030  for (i = 0; i < MAX_ELEM_ID; i++) {
3031  ChannelElement *che = ac->che[type][i];
3032  if (che && che->present) {
3033  if (type <= TYPE_CPE)
3034  apply_channel_coupling(ac, che, type, i, BEFORE_TNS, AAC_RENAME(apply_dependent_coupling));
3035  if (ac->oc[1].m4ac.object_type == AOT_AAC_LTP) {
3036  if (che->ch[0].ics.predictor_present) {
3037  if (che->ch[0].ics.ltp.present)
3038  ac->apply_ltp(ac, &che->ch[0]);
3039  if (che->ch[1].ics.ltp.present && type == TYPE_CPE)
3040  ac->apply_ltp(ac, &che->ch[1]);
3041  }
3042  }
3043  if (che->ch[0].tns.present)
3044  ac->apply_tns(che->ch[0].coeffs, &che->ch[0].tns, &che->ch[0].ics, 1);
3045  if (che->ch[1].tns.present)
3046  ac->apply_tns(che->ch[1].coeffs, &che->ch[1].tns, &che->ch[1].ics, 1);
3047  if (type <= TYPE_CPE)
3048  apply_channel_coupling(ac, che, type, i, BETWEEN_TNS_AND_IMDCT, AAC_RENAME(apply_dependent_coupling));
3049  if (type != TYPE_CCE || che->coup.coupling_point == AFTER_IMDCT) {
3050  imdct_and_window(ac, &che->ch[0]);
3051  if (ac->oc[1].m4ac.object_type == AOT_AAC_LTP)
3052  ac->update_ltp(ac, &che->ch[0]);
3053  if (type == TYPE_CPE) {
3054  imdct_and_window(ac, &che->ch[1]);
3055  if (ac->oc[1].m4ac.object_type == AOT_AAC_LTP)
3056  ac->update_ltp(ac, &che->ch[1]);
3057  }
3058  if (ac->oc[1].m4ac.sbr > 0) {
3059  AAC_RENAME(ff_sbr_apply)(ac, &che->sbr, type, che->ch[0].ret, che->ch[1].ret);
3060  }
3061  }
3062  if (type <= TYPE_CCE)
3063  apply_channel_coupling(ac, che, type, i, AFTER_IMDCT, AAC_RENAME(apply_independent_coupling));
3064 
3065 #if USE_FIXED
3066  {
3067  int j;
3068  /* preparation for resampler */
3069  for(j = 0; j<samples; j++){
3070  che->ch[0].ret[j] = (int32_t)av_clip64((int64_t)che->ch[0].ret[j]*128, INT32_MIN, INT32_MAX-0x8000)+0x8000;
3071  if(type == TYPE_CPE)
3072  che->ch[1].ret[j] = (int32_t)av_clip64((int64_t)che->ch[1].ret[j]*128, INT32_MIN, INT32_MAX-0x8000)+0x8000;
3073  }
3074  }
3075 #endif /* USE_FIXED */
3076  che->present = 0;
3077  } else if (che) {
3078  av_log(ac->avctx, AV_LOG_VERBOSE, "ChannelElement %d.%d missing \n", type, i);
3079  }
3080  }
3081  }
3082 }
3083 
3084 static int parse_adts_frame_header(AACContext *ac, GetBitContext *gb)
3085 {
3086  int size;
3087  AACADTSHeaderInfo hdr_info;
3088  uint8_t layout_map[MAX_ELEM_ID*4][3];
3089  int layout_map_tags, ret;
3090 
3091  size = ff_adts_header_parse(gb, &hdr_info);
3092  if (size > 0) {
3093  if (!ac->warned_num_aac_frames && hdr_info.num_aac_frames != 1) {
3094  // This is 2 for "VLB " audio in NSV files.
3095  // See samples/nsv/vlb_audio.
3096  avpriv_report_missing_feature(ac->avctx,
3097  "More than one AAC RDB per ADTS frame");
3098  ac->warned_num_aac_frames = 1;
3099  }
3100  push_output_configuration(ac);
3101  if (hdr_info.chan_config) {
3102  ac->oc[1].m4ac.chan_config = hdr_info.chan_config;
3103  if ((ret = set_default_channel_config(ac, ac->avctx,
3104  layout_map,
3105  &layout_map_tags,
3106  hdr_info.chan_config)) < 0)
3107  return ret;
3108  if ((ret = output_configure(ac, layout_map, layout_map_tags,
3109  FFMAX(ac->oc[1].status,
3110  OC_TRIAL_FRAME), 0)) < 0)
3111  return ret;
3112  } else {
3113  ac->oc[1].m4ac.chan_config = 0;
3114  /**
3115  * dual mono frames in Japanese DTV can have chan_config 0
3116  * WITHOUT specifying PCE.
3117  * thus, set dual mono as default.
3118  */
3119  if (ac->dmono_mode && ac->oc[0].status == OC_NONE) {
3120  layout_map_tags = 2;
3121  layout_map[0][0] = layout_map[1][0] = TYPE_SCE;
3122  layout_map[0][2] = layout_map[1][2] = AAC_CHANNEL_FRONT;
3123  layout_map[0][1] = 0;
3124  layout_map[1][1] = 1;
3125  if (output_configure(ac, layout_map, layout_map_tags,
3126  OC_TRIAL_FRAME, 0))
3127  return -7;
3128  }
3129  }
3130  ac->oc[1].m4ac.sample_rate = hdr_info.sample_rate;
3131  ac->oc[1].m4ac.sampling_index = hdr_info.sampling_index;
3132  ac->oc[1].m4ac.object_type = hdr_info.object_type;
3133  ac->oc[1].m4ac.frame_length_short = 0;
3134  if (ac->oc[0].status != OC_LOCKED ||
3135  ac->oc[0].m4ac.chan_config != hdr_info.chan_config ||
3136  ac->oc[0].m4ac.sample_rate != hdr_info.sample_rate) {
3137  ac->oc[1].m4ac.sbr = -1;
3138  ac->oc[1].m4ac.ps = -1;
3139  }
3140  if (!hdr_info.crc_absent)
3141  skip_bits(gb, 16);
3142  }
3143  return size;
3144 }
3145 
3146 static int aac_decode_er_frame(AVCodecContext *avctx, void *data,
3147  int *got_frame_ptr, GetBitContext *gb)
3148 {
3149  AACContext *ac = avctx->priv_data;
3150  const MPEG4AudioConfig *const m4ac = &ac->oc[1].m4ac;
3151  ChannelElement *che;
3152  int err, i;
3153  int samples = m4ac->frame_length_short ? 960 : 1024;
3154  int chan_config = m4ac->chan_config;
3155  int aot = m4ac->object_type;
3156 
3157  if (aot == AOT_ER_AAC_LD || aot == AOT_ER_AAC_ELD)
3158  samples >>= 1;
3159 
3160  ac->frame = data;
3161 
3162  if ((err = frame_configure_elements(avctx)) < 0)
3163  return err;
3164 
3165  // The FF_PROFILE_AAC_* defines are all object_type - 1
3166  // This may lead to an undefined profile being signaled
3167  ac->avctx->profile = aot - 1;
3168 
3169  ac->tags_mapped = 0;
3170 
3171  if (chan_config < 0 || (chan_config >= 8 && chan_config < 11) || chan_config >= 13) {
3172  avpriv_request_sample(avctx, "Unknown ER channel configuration %d",
3173  chan_config);
3174  return AVERROR_INVALIDDATA;
3175  }
3176  for (i = 0; i < tags_per_config[chan_config]; i++) {
3177  const int elem_type = aac_channel_layout_map[chan_config-1][i][0];
3178  const int elem_id = aac_channel_layout_map[chan_config-1][i][1];
3179  if (!(che=get_che(ac, elem_type, elem_id))) {
3180  av_log(ac->avctx, AV_LOG_ERROR,
3181  "channel element %d.%d is not allocated\n",
3182  elem_type, elem_id);
3183  return AVERROR_INVALIDDATA;
3184  }
3185  che->present = 1;
3186  if (aot != AOT_ER_AAC_ELD)
3187  skip_bits(gb, 4);
3188  switch (elem_type) {
3189  case TYPE_SCE:
3190  err = decode_ics(ac, &che->ch[0], gb, 0, 0);
3191  break;
3192  case TYPE_CPE:
3193  err = decode_cpe(ac, gb, che);
3194  break;
3195  case TYPE_LFE:
3196  err = decode_ics(ac, &che->ch[0], gb, 0, 0);
3197  break;
3198  }
3199  if (err < 0)
3200  return err;
3201  }
3202 
3203  spectral_to_sample(ac, samples);
3204 
3205  if (!ac->frame->data[0] && samples) {
3206  av_log(avctx, AV_LOG_ERROR, "no frame data found\n");
3207  return AVERROR_INVALIDDATA;
3208  }
3209 
3210  ac->frame->nb_samples = samples;
3211  ac->frame->sample_rate = avctx->sample_rate;
3212  *got_frame_ptr = 1;
3213 
3214  skip_bits_long(gb, get_bits_left(gb));
3215  return 0;
3216 }
3217 
3218 static int aac_decode_frame_int(AVCodecContext *avctx, void *data,
3219  int *got_frame_ptr, GetBitContext *gb, AVPacket *avpkt)
3220 {
3221  AACContext *ac = avctx->priv_data;
3222  ChannelElement *che = NULL, *che_prev = NULL;
3223  enum RawDataBlockType elem_type, che_prev_type = TYPE_END;
3224  int err, elem_id;
3225  int samples = 0, multiplier, audio_found = 0, pce_found = 0;
3226  int is_dmono, sce_count = 0;
3227  int payload_alignment;
3228  uint8_t che_presence[4][MAX_ELEM_ID] = {{0}};
3229 
3230  ac->frame = data;
3231 
3232  if (show_bits(gb, 12) == 0xfff) {
3233  if ((err = parse_adts_frame_header(ac, gb)) < 0) {
3234  av_log(avctx, AV_LOG_ERROR, "Error decoding AAC frame header.\n");
3235  goto fail;
3236  }
3237  if (ac->oc[1].m4ac.sampling_index > 12) {
3238  av_log(ac->avctx, AV_LOG_ERROR, "invalid sampling rate index %d\n", ac->oc[1].m4ac.sampling_index);
3239  err = AVERROR_INVALIDDATA;
3240  goto fail;
3241  }
3242  }
3243 
3244  if ((err = frame_configure_elements(avctx)) < 0)
3245  goto fail;
3246 
3247  // The FF_PROFILE_AAC_* defines are all object_type - 1
3248  // This may lead to an undefined profile being signaled
3249  ac->avctx->profile = ac->oc[1].m4ac.object_type - 1;
3250 
3251  payload_alignment = get_bits_count(gb);
3252  ac->tags_mapped = 0;
3253  // parse
3254  while ((elem_type = get_bits(gb, 3)) != TYPE_END) {
3255  elem_id = get_bits(gb, 4);
3256 
3257  if (avctx->debug & FF_DEBUG_STARTCODE)
3258  av_log(avctx, AV_LOG_DEBUG, "Elem type:%x id:%x\n", elem_type, elem_id);
3259 
3260  if (!avctx->channels && elem_type != TYPE_PCE) {
3261  err = AVERROR_INVALIDDATA;
3262  goto fail;
3263  }
3264 
3265  if (elem_type < TYPE_DSE) {
3266  if (che_presence[elem_type][elem_id]) {
3267  int error = che_presence[elem_type][elem_id] > 1;
3268  av_log(ac->avctx, error ? AV_LOG_ERROR : AV_LOG_DEBUG, "channel element %d.%d duplicate\n",
3269  elem_type, elem_id);
3270  if (error) {
3271  err = AVERROR_INVALIDDATA;
3272  goto fail;
3273  }
3274  }
3275  che_presence[elem_type][elem_id]++;
3276 
3277  if (!(che=get_che(ac, elem_type, elem_id))) {
3278  av_log(ac->avctx, AV_LOG_ERROR, "channel element %d.%d is not allocated\n",
3279  elem_type, elem_id);
3280  err = AVERROR_INVALIDDATA;
3281  goto fail;
3282  }
3283  samples = ac->oc[1].m4ac.frame_length_short ? 960 : 1024;
3284  che->present = 1;
3285  }
3286 
3287  switch (elem_type) {
3288 
3289  case TYPE_SCE:
3290  err = decode_ics(ac, &che->ch[0], gb, 0, 0);
3291  audio_found = 1;
3292  sce_count++;
3293  break;
3294 
3295  case TYPE_CPE:
3296  err = decode_cpe(ac, gb, che);
3297  audio_found = 1;
3298  break;
3299 
3300  case TYPE_CCE:
3301  err = decode_cce(ac, gb, che);
3302  break;
3303 
3304  case TYPE_LFE:
3305  err = decode_ics(ac, &che->ch[0], gb, 0, 0);
3306  audio_found = 1;
3307  break;
3308 
3309  case TYPE_DSE:
3310  err = skip_data_stream_element(ac, gb);
3311  break;
3312 
3313  case TYPE_PCE: {
3314  uint8_t layout_map[MAX_ELEM_ID*4][3] = {{0}};
3315  int tags;
3316 
3317  int pushed = push_output_configuration(ac);
3318  if (pce_found && !pushed) {
3319  err = AVERROR_INVALIDDATA;
3320  goto fail;
3321  }
3322 
3323  tags = decode_pce(avctx, &ac->oc[1].m4ac, layout_map, gb,
3324  payload_alignment);
3325  if (tags < 0) {
3326  err = tags;
3327  break;
3328  }
3329  if (pce_found) {
3330  av_log(avctx, AV_LOG_ERROR,
3331  "Not evaluating a further program_config_element as this construct is dubious at best.\n");
3332  pop_output_configuration(ac);
3333  } else {
3334  err = output_configure(ac, layout_map, tags, OC_TRIAL_PCE, 1);
3335  if (!err)
3336  ac->oc[1].m4ac.chan_config = 0;
3337  pce_found = 1;
3338  }
3339  break;
3340  }
3341 
3342  case TYPE_FIL:
3343  if (elem_id == 15)
3344  elem_id += get_bits(gb, 8) - 1;
3345  if (get_bits_left(gb) < 8 * elem_id) {
3346  av_log(avctx, AV_LOG_ERROR, "TYPE_FIL: "overread_err);
3347  err = AVERROR_INVALIDDATA;
3348  goto fail;
3349  }
3350  err = 0;
3351  while (elem_id > 0) {
3352  int ret = decode_extension_payload(ac, gb, elem_id, che_prev, che_prev_type);
3353  if (ret < 0) {
3354  err = ret;
3355  break;
3356  }
3357  elem_id -= ret;
3358  }
3359  break;
3360 
3361  default:
3362  err = AVERROR_BUG; /* should not happen, but keeps compiler happy */
3363  break;
3364  }
3365 
3366  if (elem_type < TYPE_DSE) {
3367  che_prev = che;
3368  che_prev_type = elem_type;
3369  }
3370 
3371  if (err)
3372  goto fail;
3373 
3374  if (get_bits_left(gb) < 3) {
3375  av_log(avctx, AV_LOG_ERROR, overread_err);
3376  err = AVERROR_INVALIDDATA;
3377  goto fail;
3378  }
3379  }
3380 
3381  if (!avctx->channels) {
3382  *got_frame_ptr = 0;
3383  return 0;
3384  }
3385 
3386  multiplier = (ac->oc[1].m4ac.sbr == 1) ? ac->oc[1].m4ac.ext_sample_rate > ac->oc[1].m4ac.sample_rate : 0;
3387  samples <<= multiplier;
3388 
3389  spectral_to_sample(ac, samples);
3390 
3391  if (ac->oc[1].status && audio_found) {
3392  avctx->sample_rate = ac->oc[1].m4ac.sample_rate << multiplier;
3393  avctx->frame_size = samples;
3394  ac->oc[1].status = OC_LOCKED;
3395  }
3396 
3397  if (multiplier)
3398  avctx->internal->skip_samples_multiplier = 2;
3399 
3400  if (!ac->frame->data[0] && samples) {
3401  av_log(avctx, AV_LOG_ERROR, "no frame data found\n");
3402  err = AVERROR_INVALIDDATA;
3403  goto fail;
3404  }
3405 
3406  if (samples) {
3407  ac->frame->nb_samples = samples;
3408  ac->frame->sample_rate = avctx->sample_rate;
3409  } else
3410  av_frame_unref(ac->frame);
3411  *got_frame_ptr = !!samples;
3412 
3413  /* for dual-mono audio (SCE + SCE) */
3414  is_dmono = ac->dmono_mode && sce_count == 2 &&
3415  ac->oc[1].channel_layout == (AV_CH_FRONT_LEFT | AV_CH_FRONT_RIGHT);
3416  if (is_dmono) {
3417  if (ac->dmono_mode == 1)
3418  ((AVFrame *)data)->data[1] =((AVFrame *)data)->data[0];
3419  else if (ac->dmono_mode == 2)
3420  ((AVFrame *)data)->data[0] =((AVFrame *)data)->data[1];
3421  }
3422 
3423  return 0;
3424 fail:
3425  pop_output_configuration(ac);
3426  return err;
3427 }
3428 
3429 static int aac_decode_frame(AVCodecContext *avctx, void *data,
3430  int *got_frame_ptr, AVPacket *avpkt)
3431 {
3432  AACContext *ac = avctx->priv_data;
3433  const uint8_t *buf = avpkt->data;
3434  int buf_size = avpkt->size;
3435  GetBitContext gb;
3436  int buf_consumed;
3437  int buf_offset;
3438  int err;
3439  int new_extradata_size;
3440  const uint8_t *new_extradata = av_packet_get_side_data(avpkt,
3441  AV_PKT_DATA_NEW_EXTRADATA,
3442  &new_extradata_size);
3443  int jp_dualmono_size;
3444  const uint8_t *jp_dualmono = av_packet_get_side_data(avpkt,
3445  AV_PKT_DATA_JP_DUALMONO,
3446  &jp_dualmono_size);
3447 
3448  if (new_extradata) {
3449  /* discard previous configuration */
3450  ac->oc[1].status = OC_NONE;
3451  err = decode_audio_specific_config(ac, ac->avctx, &ac->oc[1].m4ac,
3452  new_extradata,
3453  new_extradata_size * 8LL, 1);
3454  if (err < 0) {
3455  return err;
3456  }
3457  }
3458 
3459  ac->dmono_mode = 0;
3460  if (jp_dualmono && jp_dualmono_size > 0)
3461  ac->dmono_mode = 1 + *jp_dualmono;
3462  if (ac->force_dmono_mode >= 0)
3463  ac->dmono_mode = ac->force_dmono_mode;
3464 
3465  if (INT_MAX / 8 <= buf_size)
3466  return AVERROR_INVALIDDATA;
3467 
3468  if ((err = init_get_bits8(&gb, buf, buf_size)) < 0)
3469  return err;
3470 
3471  switch (ac->oc[1].m4ac.object_type) {
3472  case AOT_ER_AAC_LC:
3473  case AOT_ER_AAC_LTP:
3474  case AOT_ER_AAC_LD:
3475  case AOT_ER_AAC_ELD:
3476  err = aac_decode_er_frame(avctx, data, got_frame_ptr, &gb);
3477  break;
3478  default:
3479  err = aac_decode_frame_int(avctx, data, got_frame_ptr, &gb, avpkt);
3480  }
3481  if (err < 0)
3482  return err;
3483 
3484  buf_consumed = (get_bits_count(&gb) + 7) >> 3;
3485  for (buf_offset = buf_consumed; buf_offset < buf_size; buf_offset++)
3486  if (buf[buf_offset])
3487  break;
3488 
3489  return buf_size > buf_offset ? buf_consumed : buf_size;
3490 }
3491 
3492 static av_cold int aac_decode_close(AVCodecContext *avctx)
3493 {
3494  AACContext *ac = avctx->priv_data;
3495  int i, type;
3496 
3497  for (i = 0; i < MAX_ELEM_ID; i++) {
3498  for (type = 0; type < 4; type++) {
3499  if (ac->che[type][i])
3500  AAC_RENAME(ff_aac_sbr_ctx_close)(&ac->che[type][i]->sbr);
3501  av_freep(&ac->che[type][i]);
3502  }
3503  }
3504 
3505  ff_mdct_end(&ac->mdct);
3506  ff_mdct_end(&ac->mdct_small);
3507  ff_mdct_end(&ac->mdct_ld);
3508  ff_mdct_end(&ac->mdct_ltp);
3509 #if !USE_FIXED
3510  ff_mdct15_uninit(&ac->mdct120);
3511  ff_mdct15_uninit(&ac->mdct480);
3512  ff_mdct15_uninit(&ac->mdct960);
3513 #endif
3514  av_freep(&ac->fdsp);
3515  return 0;
3516 }
3517 
3518 static void aacdec_init(AACContext *c)
3519 {
3520  c->imdct_and_windowing = imdct_and_windowing;
3521  c->apply_ltp = apply_ltp;
3522  c->apply_tns = apply_tns;
3523  c->windowing_and_mdct_ltp = windowing_and_mdct_ltp;
3524  c->update_ltp = update_ltp;
3525 #if USE_FIXED
3526  c->vector_pow43 = vector_pow43;
3527  c->subband_scale = subband_scale;
3528 #endif
3529 
3530 #if !USE_FIXED
3531  if(ARCH_MIPS)
3532  ff_aacdec_init_mips(c);
3533 #endif /* !USE_FIXED */
3534 }
3535 /**
3536  * AVOptions for Japanese DTV specific extensions (ADTS only)
3537  */
3538 #define AACDEC_FLAGS AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM
3539 static const AVOption options[] = {
3540  {"dual_mono_mode", "Select the channel to decode for dual mono",
3541  offsetof(AACContext, force_dmono_mode), AV_OPT_TYPE_INT, {.i64=-1}, -1, 2,
3542  AACDEC_FLAGS, "dual_mono_mode"},
3543 
3544  {"auto", "autoselection", 0, AV_OPT_TYPE_CONST, {.i64=-1}, INT_MIN, INT_MAX, AACDEC_FLAGS, "dual_mono_mode"},
3545  {"main", "Select Main/Left channel", 0, AV_OPT_TYPE_CONST, {.i64= 1}, INT_MIN, INT_MAX, AACDEC_FLAGS, "dual_mono_mode"},
3546  {"sub" , "Select Sub/Right channel", 0, AV_OPT_TYPE_CONST, {.i64= 2}, INT_MIN, INT_MAX, AACDEC_FLAGS, "dual_mono_mode"},
3547  {"both", "Select both channels", 0, AV_OPT_TYPE_CONST, {.i64= 0}, INT_MIN, INT_MAX, AACDEC_FLAGS, "dual_mono_mode"},
3548 
3549  {NULL},
3550 };
3551 
3552 static const AVClass aac_decoder_class = {
3553  .class_name = "AAC decoder",
3554  .item_name = av_default_item_name,
3555  .option = options,
3556  .version = LIBAVUTIL_VERSION_INT,
3557 };
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:2043
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:2742
apply_ltp
static void apply_ltp(AACContext *ac, SingleChannelElement *sce)
Apply the long term prediction.
Definition: aacdec_template.c:2672
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
init_sine_windows_fixed
static av_cold void init_sine_windows_fixed(void)
Definition: sinewin_fixed_tablegen.h:60
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:1653
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:1252
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:2326
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:117
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:3538
imdct_and_windowing_eld
static void imdct_and_windowing_eld(AACContext *ac, SingleChannelElement *sce)
Definition: aacdec_template.c:2906
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:3518
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:1070
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:2704
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:1649
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:906
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
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:1858
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:1849
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:794
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:3146
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:2338
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:1165
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:1403
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
offsets
static const int offsets[]
Definition: hevc_pel.c:34
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:1619
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
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:2521
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:264
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:1254
av_clip
#define av_clip
Definition: common.h:122
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:1178
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:1680
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
AAC_RENAME2
#define AAC_RENAME2(x)
Definition: aac_defines.h:87
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:3012
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:3084
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:2488
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:824
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:2810
pos
unsigned int pos
Definition: spdifenc.c:412
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:995
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:103
fail
#define fail()
Definition: checkasm.h:133
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:366
reset_predictor_group
static void reset_predictor_group(PredictorState *ps, int group_num)
Definition: aacdec_template.c:1194
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:655
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:1640
aac_decode_frame
static int aac_decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)
Definition: aacdec_template.c:3429
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:105
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:1723
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:2235
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
av_clip64
#define av_clip64
Definition: common.h:125
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:1203
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:2979
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:1651
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:1389
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:3218
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:1748
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:2646
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
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
ff_sine_window_init
void ff_sine_window_init(float *window, int n)
Generate a sine window.
Definition: sinewin_tablegen.h:59
AACContext::tags_mapped
int tags_mapped
Definition: aac.h:308
reset_all_predictors
static void reset_all_predictors(PredictorState *ps)
Definition: aacdec_template.c:1171
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:1350
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
options
static const AVOption options[]
Definition: aacdec_template.c:3539
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:1578
AVCodecContext::debug
int debug
debug
Definition: avcodec.h:1618
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:2285
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:2586
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:199
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:1884
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:3492
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:1132
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
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:2422
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:836
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:166
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:1598
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:1367
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:1529
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:170
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:2071
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:2106
FF_DEBUG_STARTCODE
#define FF_DEBUG_STARTCODE
Definition: avcodec.h:1626
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:1857
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:2441
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:2873
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:2197
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:108
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:3552
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:1596
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
ff_init_ff_sine_windows
void ff_init_ff_sine_windows(int index)
initialize the specified entry of ff_sine_windows
Definition: sinewin_tablegen.h:101
i
int i
Definition: input.c:407
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 Mar 2 2021 19:21:27 for FFmpeg by   doxygen 1.8.11