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