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