FFmpeg
aacdec_usac.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2024 Lynne <dev@lynne.ee>
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * FFmpeg is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with FFmpeg; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20 
21 #include "aacdec_usac.h"
22 #include "aacdec_tab.h"
23 #include "aacdec_lpd.h"
24 #include "aacdec_ac.h"
25 
26 #include "libavcodec/aacsbr.h"
27 
28 #include "libavcodec/aactab.h"
29 #include "libavutil/mem.h"
30 #include "libavcodec/mpeg4audio.h"
31 #include "libavcodec/unary.h"
32 
33 /* Number of scalefactor bands per complex prediction band, equal to 2. */
34 #define SFB_PER_PRED_BAND 2
35 
36 static inline uint32_t get_escaped_value(GetBitContext *gb, int nb1, int nb2, int nb3)
37 {
38  uint32_t val = get_bits(gb, nb1), val2;
39  if (val < ((1 << nb1) - 1))
40  return val;
41 
42  val += val2 = get_bits(gb, nb2);
43  if (nb3 && (val2 == ((1 << nb2) - 1)))
44  val += get_bits(gb, nb3);
45 
46  return val;
47 }
48 
49 /* ISO/IEC 23003-3, Table 74 — bsOutputChannelPos */
50 static const enum AVChannel usac_ch_pos_to_av[64] = {
51  [0] = AV_CHAN_FRONT_LEFT,
52  [1] = AV_CHAN_FRONT_RIGHT,
55  [4] = AV_CHAN_SIDE_LEFT, // +110 degrees, Ls|LS|kAudioChannelLabel_LeftSurround
56  [5] = AV_CHAN_SIDE_RIGHT, // -110 degrees, Rs|RS|kAudioChannelLabel_RightSurround
59  [8] = AV_CHAN_BACK_LEFT, // +135 degrees, Lsr|BL|kAudioChannelLabel_RearSurroundLeft
60  [9] = AV_CHAN_BACK_RIGHT, // -135 degrees, Rsr|BR|kAudioChannelLabel_RearSurroundRight
61  [10] = AV_CHAN_BACK_CENTER,
64  [13] = AV_CHAN_SIDE_SURROUND_LEFT, // +90 degrees, Lss|SL|kAudioChannelLabel_LeftSideSurround
65  [14] = AV_CHAN_SIDE_SURROUND_RIGHT, // -90 degrees, Rss|SR|kAudioChannelLabel_RightSideSurround
66  [15] = AV_CHAN_WIDE_LEFT, // +60 degrees, Lw|FLw|kAudioChannelLabel_LeftWide
67  [16] = AV_CHAN_WIDE_RIGHT, // -60 degrees, Rw|FRw|kAudioChannelLabel_RightWide
71  [20] = AV_CHAN_TOP_BACK_LEFT,
74  [23] = AV_CHAN_TOP_SIDE_LEFT,
76  [25] = AV_CHAN_TOP_CENTER,
81  [30] = AV_CHAN_TOP_SURROUND_LEFT, ///< +110 degrees, Lvs, TpLS
82  [31] = AV_CHAN_TOP_SURROUND_RIGHT, ///< -110 degrees, Rvs, TpRS
83 };
84 
86  GetBitContext *gb)
87 {
88  info->drc_set_id = get_bits(gb, 6);
89  info->downmix_id = get_bits(gb, 7);
90 
91  if ((info->sample_peak.present = get_bits1(gb))) /* samplePeakLevelPresent */
92  info->sample_peak.lvl = get_bits(gb, 12);
93 
94  if ((info->true_peak.present = get_bits1(gb))) { /* truePeakLevelPresent */
95  info->true_peak.lvl = get_bits(gb, 12);
96  info->true_peak.measurement = get_bits(gb, 4);
97  info->true_peak.reliability = get_bits(gb, 2);
98  }
99 
100  info->nb_measurements = get_bits(gb, 4);
101  for (int i = 0; i < info->nb_measurements; i++) {
102  info->measurements[i].method_def = get_bits(gb, 4);
103  info->measurements[i].method_val = get_unary(gb, 0, 8);
104  info->measurements[i].measurement = get_bits(gb, 4);
105  info->measurements[i].reliability = get_bits(gb, 2);
106  }
107 
108  return 0;
109 }
110 
112  GetBitContext *gb)
113 {
114  int ret;
115 
116  usac->loudness.nb_album = get_bits(gb, 6); /* loudnessInfoAlbumCount */
117  usac->loudness.nb_info = get_bits(gb, 6); /* loudnessInfoCount */
118 
119  for (int i = 0; i < usac->loudness.nb_album; i++) {
120  ret = decode_loudness_info(ac, &usac->loudness.album_info[i], gb);
121  if (ret < 0)
122  return ret;
123  }
124 
125  for (int i = 0; i < usac->loudness.nb_info; i++) {
126  ret = decode_loudness_info(ac, &usac->loudness.info[i], gb);
127  if (ret < 0)
128  return ret;
129  }
130 
131  if (get_bits1(gb)) { /* loudnessInfoSetExtPresent */
133  while ((type = get_bits(gb, 4)) != UNIDRCLOUDEXT_TERM) {
134  uint8_t size_bits = get_bits(gb, 4) + 4;
135  uint8_t bit_size = get_bits(gb, size_bits) + 1;
136  switch (type) {
137  case UNIDRCLOUDEXT_EQ:
138  avpriv_report_missing_feature(ac->avctx, "loudnessInfoV1");
139  return AVERROR_PATCHWELCOME;
140  default:
141  for (int i = 0; i < bit_size; i++)
142  skip_bits1(gb);
143  }
144  }
145  }
146 
147  return 0;
148 }
149 
152 {
153  uint8_t header_extra1;
154  uint8_t header_extra2;
155 
156  e->sbr.harmonic_sbr = get_bits1(gb); /* harmonicSBR */
157  e->sbr.bs_intertes = get_bits1(gb); /* bs_interTes */
158  e->sbr.bs_pvc = get_bits1(gb); /* bs_pvc */
159  if (e->sbr.harmonic_sbr || e->sbr.bs_intertes || e->sbr.bs_pvc) {
160  avpriv_report_missing_feature(ac->avctx, "AAC USAC eSBR");
161  return AVERROR_PATCHWELCOME;
162  }
163 
164  e->sbr.dflt.start_freq = get_bits(gb, 4); /* dflt_start_freq */
165  e->sbr.dflt.stop_freq = get_bits(gb, 4); /* dflt_stop_freq */
166 
167  header_extra1 = get_bits1(gb); /* dflt_header_extra1 */
168  header_extra2 = get_bits1(gb); /* dflt_header_extra2 */
169 
170  e->sbr.dflt.freq_scale = 2;
171  e->sbr.dflt.alter_scale = 1;
172  e->sbr.dflt.noise_bands = 2;
173  if (header_extra1) {
174  e->sbr.dflt.freq_scale = get_bits(gb, 2); /* dflt_freq_scale */
175  e->sbr.dflt.alter_scale = get_bits1(gb); /* dflt_alter_scale */
176  e->sbr.dflt.noise_bands = get_bits(gb, 2); /* dflt_noise_bands */
177  }
178 
179  e->sbr.dflt.limiter_bands = 2;
180  e->sbr.dflt.limiter_gains = 2;
181  e->sbr.dflt.interpol_freq = 1;
182  e->sbr.dflt.smoothing_mode = 1;
183  if (header_extra2) {
184  e->sbr.dflt.limiter_bands = get_bits(gb, 2); /* dflt_limiter_bands */
185  e->sbr.dflt.limiter_gains = get_bits(gb, 2); /* dflt_limiter_gains */
186  e->sbr.dflt.interpol_freq = get_bits1(gb); /* dflt_interpol_freq */
187  e->sbr.dflt.smoothing_mode = get_bits1(gb); /* dflt_smoothing_mode */
188  }
189 
190  return 0;
191 }
192 
194  GetBitContext *gb,
195  int sbr_ratio)
196 {
197  e->tw_mdct = get_bits1(gb); /* tw_mdct */
198  e->noise_fill = get_bits1(gb);
199  e->sbr.ratio = sbr_ratio;
200 }
201 
204 {
205  e->stereo_config_index = 0;
206  if (e->sbr.ratio) {
207  int ret = decode_usac_sbr_data(ac, e, gb);
208  if (ret < 0)
209  return ret;
210  e->stereo_config_index = get_bits(gb, 2);
211  }
212 
213  if (e->stereo_config_index) {
214  e->mps.freq_res = get_bits(gb, 3); /* bsFreqRes */
215  e->mps.fixed_gain = get_bits(gb, 3); /* bsFixedGainDMX */
216  e->mps.temp_shape_config = get_bits(gb, 2); /* bsTempShapeConfig */
217  e->mps.decorr_config = get_bits(gb, 2); /* bsDecorrConfig */
218  e->mps.high_rate_mode = get_bits1(gb); /* bsHighRateMode */
219  e->mps.phase_coding = get_bits1(gb); /* bsPhaseCoding */
220 
221  if (get_bits1(gb)) /* bsOttBandsPhasePresent */
222  e->mps.otts_bands_phase = get_bits(gb, 5); /* bsOttBandsPhase */
223 
224  e->mps.residual_coding = e->stereo_config_index >= 2; /* bsResidualCoding */
225  if (e->mps.residual_coding) {
226  e->mps.residual_bands = get_bits(gb, 5); /* bsResidualBands */
227  e->mps.pseudo_lr = get_bits1(gb); /* bsPseudoLr */
228  }
229  if (e->mps.temp_shape_config == 2)
230  e->mps.env_quant_mode = get_bits1(gb); /* bsEnvQuantMode */
231  }
232 
233  return 0;
234 }
235 
237  GetBitContext *gb)
238 {
239  int len = 0, ext_config_len;
240 
241  e->ext.type = get_escaped_value(gb, 4, 8, 16); /* usacExtElementType */
242  ext_config_len = get_escaped_value(gb, 4, 8, 16); /* usacExtElementConfigLength */
243 
244  if (get_bits1(gb)) /* usacExtElementDefaultLengthPresent */
245  len = get_escaped_value(gb, 8, 16, 0) + 1;
246 
247  e->ext.default_len = len;
248  e->ext.payload_frag = get_bits1(gb); /* usacExtElementPayloadFrag */
249 
250  av_log(ac->avctx, AV_LOG_DEBUG, "Extension present: type %i, len %i\n",
251  e->ext.type, ext_config_len);
252 
253  switch (e->ext.type) {
254 #if 0 /* Skip unsupported values */
255  case ID_EXT_ELE_MPEGS:
256  break;
257  case ID_EXT_ELE_SAOC:
258  break;
259  case ID_EXT_ELE_UNI_DRC:
260  break;
261 #endif
262  case ID_EXT_ELE_FILL:
263  break; /* This is what the spec does */
265  /* No configuration needed - fallthrough (len should be 0) */
266  default:
267  skip_bits(gb, 8*ext_config_len);
268  break;
269  };
270 
271  return 0;
272 }
273 
275 {
276  AACUSACConfig *usac = &oc->usac;
277  int elem_id[3 /* SCE, CPE, LFE */] = { 0, 0, 0 };
278 
279  ChannelElement *che;
280  enum RawDataBlockType type;
281  int id, ch;
282 
283  /* Initialize state */
284  for (int i = 0; i < usac->nb_elems; i++) {
285  AACUsacElemConfig *e = &usac->elems[i];
286  if (e->type == ID_USAC_EXT)
287  continue;
288 
289  switch (e->type) {
290  case ID_USAC_SCE:
291  ch = 1;
292  type = TYPE_SCE;
293  id = elem_id[0]++;
294  break;
295  case ID_USAC_CPE:
296  ch = 2;
297  type = TYPE_CPE;
298  id = elem_id[1]++;
299  break;
300  case ID_USAC_LFE:
301  ch = 1;
302  type = TYPE_LFE;
303  id = elem_id[2]++;
304  break;
305  }
306 
307  che = ff_aac_get_che(ac, type, id);
308  if (che) {
309  AACUsacStereo *us = &che->us;
310  memset(us, 0, sizeof(*us));
311 
312  if (e->sbr.ratio)
313  ff_aac_sbr_config_usac(ac, che, e);
314 
315  for (int j = 0; j < ch; j++) {
316  SingleChannelElement *sce = &che->ch[ch];
317  AACUsacElemData *ue = &sce->ue;
318 
319  memset(ue, 0, sizeof(*ue));
320 
321  if (!ch)
322  ue->noise.seed = 0x3039;
323  else
324  che->ch[1].ue.noise.seed = 0x10932;
325  }
326  }
327  }
328 
329  return 0;
330 }
331 
332 /* UsacConfig */
335  int channel_config)
336 {
337  int ret;
338  uint8_t freq_idx;
339  uint8_t channel_config_idx;
340  int nb_channels = 0;
341  int ratio_mult, ratio_dec;
342  int samplerate;
343  int sbr_ratio;
344  MPEG4AudioConfig *m4ac = &oc->m4ac;
345  AACUSACConfig *usac = &oc->usac;
346  int elem_id[3 /* SCE, CPE, LFE */];
347 
348  int map_pos_set = 0;
349  uint8_t layout_map[MAX_ELEM_ID*4][3] = { 0 };
350 
351  if (!ac)
352  return AVERROR_PATCHWELCOME;
353 
354  memset(usac, 0, sizeof(*usac));
355 
356  freq_idx = get_bits(gb, 5); /* usacSamplingFrequencyIndex */
357  if (freq_idx == 0x1f) {
358  samplerate = get_bits(gb, 24); /* usacSamplingFrequency */
359  } else {
360  samplerate = ff_aac_usac_samplerate[freq_idx];
361  if (samplerate < 0)
362  return AVERROR(EINVAL);
363  }
364 
365  usac->core_sbr_frame_len_idx = get_bits(gb, 3); /* coreSbrFrameLengthIndex */
366  m4ac->frame_length_short = usac->core_sbr_frame_len_idx == 0 ||
367  usac->core_sbr_frame_len_idx == 2;
368 
369  usac->core_frame_len = (usac->core_sbr_frame_len_idx == 0 ||
370  usac->core_sbr_frame_len_idx == 2) ? 768 : 1024;
371 
372  sbr_ratio = usac->core_sbr_frame_len_idx == 2 ? 2 :
373  usac->core_sbr_frame_len_idx == 3 ? 3 :
374  usac->core_sbr_frame_len_idx == 4 ? 1 :
375  0;
376 
377  if (sbr_ratio == 2) {
378  ratio_mult = 8;
379  ratio_dec = 3;
380  } else if (sbr_ratio == 3) {
381  ratio_mult = 2;
382  ratio_dec = 1;
383  } else if (sbr_ratio == 4) {
384  ratio_mult = 4;
385  ratio_dec = 1;
386  } else {
387  ratio_mult = 1;
388  ratio_dec = 1;
389  }
390 
391  avctx->sample_rate = samplerate;
392  m4ac->ext_sample_rate = samplerate;
393  m4ac->sample_rate = (samplerate * ratio_dec) / ratio_mult;
394 
396  m4ac->sbr = sbr_ratio > 0;
397 
398  channel_config_idx = get_bits(gb, 5); /* channelConfigurationIndex */
399  if (!channel_config_idx) {
400  /* UsacChannelConfig() */
401  nb_channels = get_escaped_value(gb, 5, 8, 16); /* numOutChannels */
402  if (nb_channels > 64)
403  return AVERROR(EINVAL);
404 
406 
407  ret = av_channel_layout_custom_init(&ac->oc[1].ch_layout, nb_channels);
408  if (ret < 0)
409  return ret;
410 
411  for (int i = 0; i < nb_channels; i++) {
412  AVChannelCustom *cm = &ac->oc[1].ch_layout.u.map[i];
413  cm->id = usac_ch_pos_to_av[get_bits(gb, 5)]; /* bsOutputChannelPos */
414  }
415 
419  if (ret < 0)
420  return ret;
421 
422  ret = av_channel_layout_copy(&avctx->ch_layout, &ac->oc[1].ch_layout);
423  if (ret < 0)
424  return ret;
425  } else {
426  int nb_elements;
427  if ((ret = ff_aac_set_default_channel_config(ac, avctx, layout_map,
428  &nb_elements, channel_config_idx)))
429  return ret;
430 
431  /* Fill in the number of expected channels */
432  for (int i = 0; i < nb_elements; i++)
433  nb_channels += layout_map[i][0] == TYPE_CPE ? 2 : 1;
434 
435  map_pos_set = 1;
436  }
437 
438  /* UsacDecoderConfig */
439  elem_id[0] = elem_id[1] = elem_id[2] = 0;
440  usac->nb_elems = get_escaped_value(gb, 4, 8, 16) + 1;
441  if (usac->nb_elems > 64) {
442  av_log(ac->avctx, AV_LOG_ERROR, "Too many elements: %i\n",
443  usac->nb_elems);
444  usac->nb_elems = 0;
445  return AVERROR(EINVAL);
446  }
447 
448  for (int i = 0; i < usac->nb_elems; i++) {
449  int map_count = elem_id[0] + elem_id[1] + elem_id[2];
450  AACUsacElemConfig *e = &usac->elems[i];
451  memset(e, 0, sizeof(*e));
452 
453  e->type = get_bits(gb, 2); /* usacElementType */
454  if (e->type != ID_USAC_EXT && (map_count + 1) > nb_channels) {
455  av_log(ac->avctx, AV_LOG_ERROR, "Too many channels for the channel "
456  "configuration\n");
457  usac->nb_elems = 0;
458  return AVERROR(EINVAL);
459  }
460 
461  av_log(ac->avctx, AV_LOG_DEBUG, "Element present: idx %i, type %i\n",
462  i, e->type);
463 
464  switch (e->type) {
465  case ID_USAC_SCE: /* SCE */
466  /* UsacCoreConfig */
467  decode_usac_element_core(e, gb, sbr_ratio);
468  if (e->sbr.ratio > 0) {
469  ret = decode_usac_sbr_data(ac, e, gb);
470  if (ret < 0)
471  return ret;
472  }
473  layout_map[map_count][0] = TYPE_SCE;
474  layout_map[map_count][1] = elem_id[0]++;
475  if (!map_pos_set)
476  layout_map[map_count][2] = AAC_CHANNEL_FRONT;
477 
478  break;
479  case ID_USAC_CPE: /* UsacChannelPairElementConf */
480  /* UsacCoreConfig */
481  decode_usac_element_core(e, gb, sbr_ratio);
482  ret = decode_usac_element_pair(ac, e, gb);
483  if (ret < 0)
484  return ret;
485  layout_map[map_count][0] = TYPE_CPE;
486  layout_map[map_count][1] = elem_id[1]++;
487  if (!map_pos_set)
488  layout_map[map_count][2] = AAC_CHANNEL_FRONT;
489 
490  break;
491  case ID_USAC_LFE: /* LFE */
492  /* LFE has no need for any configuration */
493  e->tw_mdct = 0;
494  e->noise_fill = 0;
495  layout_map[map_count][0] = TYPE_LFE;
496  layout_map[map_count][1] = elem_id[2]++;
497  if (!map_pos_set)
498  layout_map[map_count][2] = AAC_CHANNEL_LFE;
499 
500  break;
501  case ID_USAC_EXT: /* EXT */
502  ret = decode_usac_extension(ac, e, gb);
503  if (ret < 0)
504  return ret;
505  break;
506  };
507  }
508 
509  ret = ff_aac_output_configure(ac, layout_map, elem_id[0] + elem_id[1] + elem_id[2],
510  OC_GLOBAL_HDR, 0);
511  if (ret < 0) {
512  av_log(avctx, AV_LOG_ERROR, "Unable to parse channel config!\n");
513  usac->nb_elems = 0;
514  return ret;
515  }
516 
517  if (get_bits1(gb)) { /* usacConfigExtensionPresent */
518  int invalid;
519  int nb_extensions = get_escaped_value(gb, 2, 4, 8) + 1; /* numConfigExtensions */
520  for (int i = 0; i < nb_extensions; i++) {
521  int type = get_escaped_value(gb, 4, 8, 16);
522  int len = get_escaped_value(gb, 4, 8, 16);
523  switch (type) {
525  ret = decode_loudness_set(ac, usac, gb);
526  if (ret < 0)
527  return ret;
528  break;
530  usac->stream_identifier = get_bits(gb, 16);
531  break;
532  case ID_CONFIG_EXT_FILL: /* fallthrough */
533  invalid = 0;
534  while (len--) {
535  if (get_bits(gb, 8) != 0xA5)
536  invalid++;
537  }
538  if (invalid)
539  av_log(avctx, AV_LOG_WARNING, "Invalid fill bytes: %i\n",
540  invalid);
541  break;
542  default:
543  while (len--)
544  skip_bits(gb, 8);
545  break;
546  }
547  }
548  }
549 
551 
552  ret = ff_aac_usac_reset_state(ac, oc);
553  if (ret < 0)
554  return ret;
555 
556  return 0;
557 }
558 
561  GetBitContext *gb, uint8_t global_gain)
562 {
563  IndividualChannelStream *ics = &sce->ics;
564 
565  /* Decode all scalefactors. */
566  int offset_sf = global_gain;
567  for (int g = 0; g < ics->num_window_groups; g++) {
568  for (int sfb = 0; sfb < ics->max_sfb; sfb++) {
569  /* First coefficient is just the global gain */
570  if (!g && !sfb) {
571  /* The cannonical representation of quantized scalefactors
572  * in the spec is with 100 subtracted. */
573  sce->sfo[0] = offset_sf - 100;
574  continue;
575  }
576 
577  offset_sf += get_vlc2(gb, ff_vlc_scalefactors, 7, 3) - SCALE_DIFF_ZERO;
578  if (offset_sf > 255U) {
580  "Scalefactor (%d) out of range.\n", offset_sf);
581  return AVERROR_INVALIDDATA;
582  }
583 
584  sce->sfo[g*ics->max_sfb + sfb] = offset_sf - 100;
585  }
586  }
587 
588  return 0;
589 }
590 
591 /**
592  * Decode and dequantize arithmetically coded, uniformly quantized value
593  *
594  * @param coef array of dequantized, scaled spectral data
595  * @param sf array of scalefactors or intensity stereo positions
596  *
597  * @return Returns error status. 0 - OK, !0 - error
598  */
599 static int decode_spectrum_ac(AACDecContext *s, float coef[1024],
601  int reset, uint16_t len, uint16_t N)
602 {
603  AACArith ac;
604  int i, a, b;
605  uint32_t c;
606 
607  int gb_count;
608  GetBitContext gb2;
609 
610  c = ff_aac_ac_map_process(state, reset, N);
611 
612  if (!len) {
613  ff_aac_ac_finish(state, 0, N);
614  return 0;
615  }
616 
617  ff_aac_ac_init(&ac, gb);
618 
619  /* Backup reader for rolling back by 14 bits at the end */
620  gb2 = *gb;
621  gb_count = get_bits_count(&gb2);
622 
623  for (i = 0; i < len/2; i++) {
624  /* MSB */
625  int lvl, esc_nb, m;
627  for (lvl=esc_nb=0;;) {
628  uint32_t pki = ff_aac_ac_get_pk(c + (esc_nb << 17));
629  m = ff_aac_ac_decode(&ac, &gb2, ff_aac_ac_msb_cdfs[pki],
631  if (m < FF_AAC_AC_ESCAPE)
632  break;
633  lvl++;
634 
635  /* Cargo-culted value. */
636  if (lvl > 23)
637  return AVERROR(EINVAL);
638 
639  if ((esc_nb = lvl) > 7)
640  esc_nb = 7;
641  }
642 
643  b = m >> 2;
644  a = m - (b << 2);
645 
646  /* ARITH_STOP detection */
647  if (!m) {
648  if (esc_nb)
649  break;
650  a = b = 0;
651  }
652 
653  /* LSB */
654  for (int l = lvl; l > 0; l--) {
655  int lsbidx = !a ? 1 : (!b ? 0 : 2);
656  uint8_t r = ff_aac_ac_decode(&ac, &gb2, ff_aac_ac_lsb_cdfs[lsbidx],
658  a = (a << 1) | (r & 1);
659  b = (b << 1) | ((r >> 1) & 1);
660  }
661 
662  /* Dequantize coeffs here */
663  coef[2*i + 0] = a * cbrt(a);
664  coef[2*i + 1] = b * cbrt(b);
666  }
667 
668  if (len > 1) {
669  /* "Rewind" bitstream back by 14 bits */
670  int gb_count2 = get_bits_count(&gb2);
671  skip_bits(gb, gb_count2 - gb_count - 14);
672  } else {
673  *gb = gb2;
674  }
675 
677 
678  for (; i < N/2; i++) {
679  coef[2*i + 0] = 0;
680  coef[2*i + 1] = 0;
681  }
682 
683  /* Signs */
684  for (i = 0; i < len; i++) {
685  if (coef[i]) {
686  if (!get_bits1(gb)) /* s */
687  coef[i] *= -1;
688  }
689  }
690 
691  return 0;
692 }
693 
695  ChannelElement *cpe, GetBitContext *gb,
696  int num_window_groups,
697  int prev_num_window_groups,
698  int indep_flag)
699 {
700  int delta_code_time;
701  IndividualChannelStream *ics = &cpe->ch[0].ics;
702 
703  if (!get_bits1(gb)) { /* cplx_pred_all */
704  for (int g = 0; g < num_window_groups; g++) {
705  for (int sfb = 0; sfb < cpe->max_sfb_ste; sfb += SFB_PER_PRED_BAND) {
706  const uint8_t val = get_bits1(gb);
707  us->pred_used[g*cpe->max_sfb_ste + sfb] = val;
708  if ((sfb + 1) < cpe->max_sfb_ste)
709  us->pred_used[g*cpe->max_sfb_ste + sfb + 1] = val;
710  }
711  }
712  } else {
713  for (int g = 0; g < num_window_groups; g++)
714  for (int sfb = 0; sfb < cpe->max_sfb_ste; sfb++)
715  us->pred_used[g*cpe->max_sfb_ste + sfb] = 1;
716  }
717 
718  us->pred_dir = get_bits1(gb);
719  us->complex_coef = get_bits1(gb);
720 
721  us->use_prev_frame = 0;
722  if (us->complex_coef && !indep_flag)
723  us->use_prev_frame = get_bits1(gb);
724 
725  delta_code_time = 0;
726  if (!indep_flag)
727  delta_code_time = get_bits1(gb);
728 
729  /* TODO: shouldn't be needed */
730  for (int g = 0; g < num_window_groups; g++) {
731  for (int sfb = 0; sfb < cpe->max_sfb_ste; sfb += SFB_PER_PRED_BAND) {
732  float last_alpha_q_re = 0;
733  float last_alpha_q_im = 0;
734  if (delta_code_time) {
735  if (g) {
736  /* Transient, after the first group - use the current frame,
737  * previous window, alpha values. */
738  last_alpha_q_re = us->alpha_q_re[(g - 1)*cpe->max_sfb_ste + sfb];
739  last_alpha_q_im = us->alpha_q_im[(g - 1)*cpe->max_sfb_ste + sfb];
740  } else if (!g &&
741  (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) &&
742  (ics->window_sequence[1] == EIGHT_SHORT_SEQUENCE)) {
743  /* The spec doesn't explicitly mention this, but it doesn't make
744  * any other sense otherwise! */
745  const int wg = prev_num_window_groups - 1;
746  last_alpha_q_re = us->prev_alpha_q_re[wg*cpe->max_sfb_ste + sfb];
747  last_alpha_q_im = us->prev_alpha_q_im[wg*cpe->max_sfb_ste + sfb];
748  } else {
749  last_alpha_q_re = us->prev_alpha_q_re[g*cpe->max_sfb_ste + sfb];
750  last_alpha_q_im = us->prev_alpha_q_im[g*cpe->max_sfb_ste + sfb];
751  }
752  } else {
753  if (sfb) {
754  last_alpha_q_re = us->alpha_q_re[g*cpe->max_sfb_ste + sfb - 1];
755  last_alpha_q_im = us->alpha_q_im[g*cpe->max_sfb_ste + sfb - 1];
756  }
757  }
758 
759  if (us->pred_used[g*cpe->max_sfb_ste + sfb]) {
760  int val = -get_vlc2(gb, ff_vlc_scalefactors, 7, 3) + 60;
761  last_alpha_q_re += val * 0.1f;
762  if (us->complex_coef) {
763  val = -get_vlc2(gb, ff_vlc_scalefactors, 7, 3) + 60;
764  last_alpha_q_im += val * 0.1f;
765  }
766  us->alpha_q_re[g*cpe->max_sfb_ste + sfb] = last_alpha_q_re;
767  us->alpha_q_im[g*cpe->max_sfb_ste + sfb] = last_alpha_q_im;
768  } else {
769  us->alpha_q_re[g*cpe->max_sfb_ste + sfb] = 0;
770  us->alpha_q_im[g*cpe->max_sfb_ste + sfb] = 0;
771  }
772 
773  if ((sfb + 1) < cpe->max_sfb_ste) {
774  us->alpha_q_re[g*cpe->max_sfb_ste + sfb + 1] =
775  us->alpha_q_re[g*cpe->max_sfb_ste + sfb];
776  us->alpha_q_im[g*cpe->max_sfb_ste + sfb + 1] =
777  us->alpha_q_im[g*cpe->max_sfb_ste + sfb];
778  }
779  }
780  }
781 
782  return 0;
783 }
784 
786  AACUSACConfig *usac)
787 {
788  AACUsacElemData *ue = &sce->ue;
789  IndividualChannelStream *ics = &sce->ics;
790  const int sampling_index = ac->oc[1].m4ac.sampling_index;
791 
792  /* Setup window parameters */
794  if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) {
795  if (usac->core_frame_len == 768) {
796  ics->swb_offset = ff_swb_offset_96[sampling_index];
797  ics->num_swb = ff_aac_num_swb_96[sampling_index];
798  } else {
799  ics->swb_offset = ff_swb_offset_128[sampling_index];
800  ics->num_swb = ff_aac_num_swb_128[sampling_index];
801  }
802  ics->tns_max_bands = ff_tns_max_bands_usac_128[sampling_index];
803 
804  /* Setup scalefactor grouping. 7 bit mask. */
805  ics->num_window_groups = 0;
806  for (int j = 0; j < 7; j++) {
807  ics->group_len[j] = 1;
808  if (ue->scale_factor_grouping & (1 << (6 - j)))
809  ics->group_len[ics->num_window_groups] += 1;
810  else
811  ics->num_window_groups++;
812  }
813 
814  ics->group_len[7] = 1;
815  ics->num_window_groups++;
816  ics->num_windows = 8;
817  } else {
818  if (usac->core_frame_len == 768) {
819  ics->swb_offset = ff_swb_offset_768[sampling_index];
820  ics->num_swb = ff_aac_num_swb_768[sampling_index];
821  } else {
822  ics->swb_offset = ff_swb_offset_1024[sampling_index];
823  ics->num_swb = ff_aac_num_swb_1024[sampling_index];
824  }
825  ics->tns_max_bands = ff_tns_max_bands_usac_1024[sampling_index];
826 
827  ics->group_len[0] = 1;
828  ics->num_window_groups = 1;
829  ics->num_windows = 1;
830  }
831 
832  if (ics->max_sfb > ics->num_swb) {
834  "Number of scalefactor bands in group (%d) "
835  "exceeds limit (%d).\n",
836  ics->max_sfb, ics->num_swb);
837  return AVERROR(EINVAL);
838  }
839 
840  /* Just some defaults for the band types */
841  for (int i = 0; i < FF_ARRAY_ELEMS(sce->band_type); i++)
842  sce->band_type[i] = ESC_BT;
843 
844  return 0;
845 }
846 
849  GetBitContext *gb, int indep_flag)
850 {
851  int ret, tns_active;
852 
853  AACUsacStereo *us = &cpe->us;
854  SingleChannelElement *sce1 = &cpe->ch[0];
855  SingleChannelElement *sce2 = &cpe->ch[1];
856  IndividualChannelStream *ics1 = &sce1->ics;
857  IndividualChannelStream *ics2 = &sce2->ics;
858  AACUsacElemData *ue1 = &sce1->ue;
859  AACUsacElemData *ue2 = &sce2->ue;
860 
861  us->common_window = 0;
862  us->common_tw = 0;
863 
864  /* Alpha values must always be zeroed out for the current frame,
865  * as they are propagated to the next frame and may be used. */
866  memset(us->alpha_q_re, 0, sizeof(us->alpha_q_re));
867  memset(us->alpha_q_im, 0, sizeof(us->alpha_q_im));
868 
869  if (!(!ue1->core_mode && !ue2->core_mode))
870  return 0;
871 
872  tns_active = get_bits1(gb);
873  us->common_window = get_bits1(gb);
874 
875  if (!us->common_window || indep_flag) {
876  memset(us->prev_alpha_q_re, 0, sizeof(us->prev_alpha_q_re));
877  memset(us->prev_alpha_q_im, 0, sizeof(us->prev_alpha_q_im));
878  }
879 
880  if (us->common_window) {
881  /* ics_info() */
882  ics1->window_sequence[1] = ics1->window_sequence[0];
883  ics2->window_sequence[1] = ics2->window_sequence[0];
884  ics1->window_sequence[0] = ics2->window_sequence[0] = get_bits(gb, 2);
885 
886  ics1->use_kb_window[1] = ics1->use_kb_window[0];
887  ics2->use_kb_window[1] = ics2->use_kb_window[0];
888  ics1->use_kb_window[0] = ics2->use_kb_window[0] = get_bits1(gb);
889 
890  /* If there's a change in the transform sequence, zero out last frame's
891  * stereo prediction coefficients */
892  if ((ics1->window_sequence[0] == EIGHT_SHORT_SEQUENCE &&
893  ics1->window_sequence[1] != EIGHT_SHORT_SEQUENCE) ||
894  (ics1->window_sequence[1] == EIGHT_SHORT_SEQUENCE &&
895  ics1->window_sequence[0] != EIGHT_SHORT_SEQUENCE) ||
896  (ics2->window_sequence[0] == EIGHT_SHORT_SEQUENCE &&
897  ics2->window_sequence[1] != EIGHT_SHORT_SEQUENCE) ||
898  (ics2->window_sequence[1] == EIGHT_SHORT_SEQUENCE &&
899  ics2->window_sequence[0] != EIGHT_SHORT_SEQUENCE)) {
900  memset(us->prev_alpha_q_re, 0, sizeof(us->prev_alpha_q_re));
901  memset(us->prev_alpha_q_im, 0, sizeof(us->prev_alpha_q_im));
902  }
903 
904  if (ics1->window_sequence[0] == EIGHT_SHORT_SEQUENCE) {
905  ics1->max_sfb = ics2->max_sfb = get_bits(gb, 4);
907  } else {
908  ics1->max_sfb = ics2->max_sfb = get_bits(gb, 6);
909  }
910 
911  if (!get_bits1(gb)) { /* common_max_sfb */
912  if (ics2->window_sequence[0] == EIGHT_SHORT_SEQUENCE)
913  ics2->max_sfb = get_bits(gb, 4);
914  else
915  ics2->max_sfb = get_bits(gb, 6);
916  }
917 
918  ret = setup_sce(ac, sce1, usac);
919  if (ret < 0)
920  return ret;
921 
922  ret = setup_sce(ac, sce2, usac);
923  if (ret < 0)
924  return ret;
925 
926  cpe->max_sfb_ste = FFMAX(ics1->max_sfb, ics2->max_sfb);
927 
928  us->ms_mask_mode = get_bits(gb, 2); /* ms_mask_present */
929  memset(cpe->ms_mask, 0, sizeof(cpe->ms_mask));
930  if (us->ms_mask_mode == 1) {
931  for (int g = 0; g < ics1->num_window_groups; g++)
932  for (int sfb = 0; sfb < cpe->max_sfb_ste; sfb++)
933  cpe->ms_mask[g*cpe->max_sfb_ste + sfb] = get_bits1(gb);
934  } else if (us->ms_mask_mode == 2) {
935  memset(cpe->ms_mask, 0xFF, sizeof(cpe->ms_mask));
936  } else if ((us->ms_mask_mode == 3) && !ec->stereo_config_index) {
937  ret = decode_usac_stereo_cplx(ac, us, cpe, gb,
938  ics1->num_window_groups,
940  indep_flag);
941  if (ret < 0)
942  return ret;
943  }
944  }
945 
946  if (ec->tw_mdct) {
947  us->common_tw = get_bits1(gb);
949  "AAC USAC timewarping");
950  return AVERROR_PATCHWELCOME;
951  }
952 
953  us->tns_on_lr = 0;
954  ue1->tns_data_present = ue2->tns_data_present = 0;
955  if (tns_active) {
956  int common_tns = 0;
957  if (us->common_window)
958  common_tns = get_bits1(gb);
959 
960  us->tns_on_lr = get_bits1(gb);
961  if (common_tns) {
962  ret = ff_aac_decode_tns(ac, &sce1->tns, gb, ics1);
963  if (ret < 0)
964  return ret;
965  memcpy(&sce2->tns, &sce1->tns, sizeof(sce1->tns));
966  sce2->tns.present = 1;
967  sce1->tns.present = 1;
968  ue1->tns_data_present = 0;
969  ue2->tns_data_present = 0;
970  } else {
971  if (get_bits1(gb)) {
972  ue1->tns_data_present = 1;
973  ue2->tns_data_present = 1;
974  } else {
975  ue2->tns_data_present = get_bits1(gb);
976  ue1->tns_data_present = !ue2->tns_data_present;
977  }
978  }
979  }
980 
981  return 0;
982 }
983 
984 /* 7.2.4 Generation of random signs for spectral noise filling
985  * This function is exactly defined, though we've helped the definition
986  * along with being slightly faster. */
987 static inline float noise_random_sign(unsigned int *seed)
988 {
989  unsigned int new_seed = *seed = ((*seed) * 69069) + 5;
990  if (((new_seed) & 0x10000) > 0)
991  return -1.f;
992  return +1.f;
993 }
994 
997 {
998  float *coef;
999  IndividualChannelStream *ics = &sce->ics;
1000 
1001  float noise_val = powf(2, ((float)ue->noise.level - 14.0f)/3.0f);
1002  int noise_offset = ue->noise.offset - 16;
1003  int band_off;
1004 
1007 
1008  coef = sce->coeffs;
1009  for (int g = 0; g < ics->num_window_groups; g++) {
1010  unsigned g_len = ics->group_len[g];
1011 
1012  for (int sfb = 0; sfb < ics->max_sfb; sfb++) {
1013  float *cb = coef + ics->swb_offset[sfb];
1014  int cb_len = ics->swb_offset[sfb + 1] - ics->swb_offset[sfb];
1015  int band_quantized_to_zero = 1;
1016 
1017  if (ics->swb_offset[sfb] < band_off)
1018  continue;
1019 
1020  for (int group = 0; group < (unsigned)g_len; group++, cb += 128) {
1021  for (int z = 0; z < cb_len; z++) {
1022  if (cb[z] == 0)
1023  cb[z] = noise_random_sign(&sce->ue.noise.seed) * noise_val;
1024  else
1025  band_quantized_to_zero = 0;
1026  }
1027  }
1028 
1029  if (band_quantized_to_zero)
1030  sce->sfo[g*ics->max_sfb + sfb] += noise_offset;
1031  }
1032  coef += g_len << 7;
1033  }
1034 }
1035 
1038 {
1039  IndividualChannelStream *ics = &sce->ics;
1040  float *coef;
1041 
1042  /* Synthesise noise */
1043  if (ue->noise.level)
1044  apply_noise_fill(ac, sce, ue);
1045 
1046  /* Noise filling may apply an offset to the scalefactor offset */
1047  ac->dsp.dequant_scalefactors(sce);
1048 
1049  /* Apply scalefactors */
1050  coef = sce->coeffs;
1051  for (int g = 0; g < ics->num_window_groups; g++) {
1052  unsigned g_len = ics->group_len[g];
1053 
1054  for (int sfb = 0; sfb < ics->max_sfb; sfb++) {
1055  float *cb = coef + ics->swb_offset[sfb];
1056  int cb_len = ics->swb_offset[sfb + 1] - ics->swb_offset[sfb];
1057  float sf = sce->sf[g*ics->max_sfb + sfb];
1058 
1059  for (int group = 0; group < (unsigned)g_len; group++, cb += 128)
1060  ac->fdsp->vector_fmul_scalar(cb, cb, sf, cb_len);
1061  }
1062  coef += g_len << 7;
1063  }
1064 }
1065 
1067  float *dmix_re)
1068 {
1069  IndividualChannelStream *ics = &cpe->ch[0].ics;
1070  int sign = !cpe->us.pred_dir ? +1 : -1;
1071  float *coef1 = cpe->ch[0].coeffs;
1072  float *coef2 = cpe->ch[1].coeffs;
1073 
1074  for (int g = 0; g < ics->num_window_groups; g++) {
1075  unsigned g_len = ics->group_len[g];
1076  for (int sfb = 0; sfb < cpe->max_sfb_ste; sfb++) {
1077  int off = ics->swb_offset[sfb];
1078  int cb_len = ics->swb_offset[sfb + 1] - off;
1079 
1080  float *c1 = coef1 + off;
1081  float *c2 = coef2 + off;
1082  float *dm = dmix_re + off;
1083 
1084  for (int group = 0; group < (unsigned)g_len;
1085  group++, c1 += 128, c2 += 128, dm += 128) {
1086  for (int z = 0; z < cb_len; z++)
1087  dm[z] = 0.5*(c1[z] + sign*c2[z]);
1088  }
1089  }
1090 
1091  coef1 += g_len << 7;
1092  coef2 += g_len << 7;
1093  dmix_re += g_len << 7;
1094  }
1095 }
1096 
1098  float *dmix_re)
1099 {
1100  AACUsacStereo *us = &cpe->us;
1101  IndividualChannelStream *ics = &cpe->ch[0].ics;
1102  int sign = !cpe->us.pred_dir ? +1 : -1;
1103  float *coef1 = cpe->ch[0].coeffs;
1104  float *coef2 = cpe->ch[1].coeffs;
1105 
1106  for (int g = 0; g < ics->num_window_groups; g++) {
1107  unsigned g_len = ics->group_len[g];
1108  for (int sfb = 0; sfb < cpe->max_sfb_ste; sfb++) {
1109  int off = ics->swb_offset[sfb];
1110  int cb_len = ics->swb_offset[sfb + 1] - off;
1111 
1112  float *c1 = coef1 + off;
1113  float *c2 = coef2 + off;
1114  float *dm = dmix_re + off;
1115 
1116  if (us->pred_used[g*cpe->max_sfb_ste + sfb]) {
1117  for (int group = 0; group < (unsigned)g_len;
1118  group++, c1 += 128, c2 += 128, dm += 128) {
1119  for (int z = 0; z < cb_len; z++)
1120  dm[z] = 0.5*(c1[z] + sign*c2[z]);
1121  }
1122  } else {
1123  for (int group = 0; group < (unsigned)g_len;
1124  group++, c1 += 128, c2 += 128, dm += 128) {
1125  for (int z = 0; z < cb_len; z++)
1126  dm[z] = c1[z];
1127  }
1128  }
1129  }
1130 
1131  coef1 += g_len << 7;
1132  coef2 += g_len << 7;
1133  dmix_re += g_len << 7;
1134  }
1135 }
1136 
1137 static void complex_stereo_interpolate_imag(float *im, float *re, const float f[7],
1138  int len, int factor_even, int factor_odd)
1139 {
1140  int i = 0;
1141  float s;
1142 
1143  s = f[6]*re[2] + f[5]*re[1] + f[4]*re[0] +
1144  f[3]*re[0] +
1145  f[2]*re[1] + f[1]*re[2] + f[0]*re[3];
1146  im[i] += s*factor_even;
1147 
1148  i = 1;
1149  s = f[6]*re[1] + f[5]*re[0] + f[4]*re[0] +
1150  f[3]*re[1] +
1151  f[2]*re[2] + f[1]*re[3] + f[0]*re[4];
1152  im[i] += s*factor_odd;
1153 
1154  i = 2;
1155  s = f[6]*re[0] + f[5]*re[0] + f[4]*re[1] +
1156  f[3]*re[2] +
1157  f[2]*re[3] + f[1]*re[4] + f[0]*re[5];
1158 
1159  im[i] += s*factor_even;
1160  for (i = 3; i < len - 4; i += 2) {
1161  s = f[6]*re[i-3] + f[5]*re[i-2] + f[4]*re[i-1] +
1162  f[3]*re[i] +
1163  f[2]*re[i+1] + f[1]*re[i+2] + f[0]*re[i+3];
1164  im[i+0] += s*factor_odd;
1165 
1166  s = f[6]*re[i-2] + f[5]*re[i-1] + f[4]*re[i] +
1167  f[3]*re[i+1] +
1168  f[2]*re[i+2] + f[1]*re[i+3] + f[0]*re[i+4];
1169  im[i+1] += s*factor_even;
1170  }
1171 
1172  i = len - 3;
1173  s = f[6]*re[i-3] + f[5]*re[i-2] + f[4]*re[i-1] +
1174  f[3]*re[i] +
1175  f[2]*re[i+1] + f[1]*re[i+2] + f[0]*re[i+2];
1176  im[i] += s*factor_odd;
1177 
1178  i = len - 2;
1179  s = f[6]*re[i-3] + f[5]*re[i-2] + f[4]*re[i-1] +
1180  f[3]*re[i] +
1181  f[2]*re[i+1] + f[1]*re[i+1] + f[0]*re[i];
1182  im[i] += s*factor_even;
1183 
1184  i = len - 1;
1185  s = f[6]*re[i-3] + f[5]*re[i-2] + f[4]*re[i-1] +
1186  f[3]*re[i] +
1187  f[2]*re[i] + f[1]*re[i-1] + f[0]*re[i-2];
1188  im[i] += s*factor_odd;
1189 }
1190 
1192 {
1193  AACUsacStereo *us = &cpe->us;
1194  IndividualChannelStream *ics = &cpe->ch[0].ics;
1195  float *coef1 = cpe->ch[0].coeffs;
1196  float *coef2 = cpe->ch[1].coeffs;
1197  float *dmix_im = us->dmix_im;
1198 
1199  for (int g = 0; g < ics->num_window_groups; g++) {
1200  unsigned g_len = ics->group_len[g];
1201  for (int sfb = 0; sfb < cpe->max_sfb_ste; sfb++) {
1202  int off = ics->swb_offset[sfb];
1203  int cb_len = ics->swb_offset[sfb + 1] - off;
1204 
1205  float *c1 = coef1 + off;
1206  float *c2 = coef2 + off;
1207  float *dm_im = dmix_im + off;
1208  float alpha_re = us->alpha_q_re[g*cpe->max_sfb_ste + sfb];
1209  float alpha_im = us->alpha_q_im[g*cpe->max_sfb_ste + sfb];
1210 
1211  if (!us->pred_used[g*cpe->max_sfb_ste + sfb])
1212  continue;
1213 
1214  if (!cpe->us.pred_dir) {
1215  for (int group = 0; group < (unsigned)g_len;
1216  group++, c1 += 128, c2 += 128, dm_im += 128) {
1217  for (int z = 0; z < cb_len; z++) {
1218  float side;
1219  side = c2[z] - alpha_re*c1[z] - alpha_im*dm_im[z];
1220  c2[z] = c1[z] - side;
1221  c1[z] = c1[z] + side;
1222  }
1223  }
1224  } else {
1225  for (int group = 0; group < (unsigned)g_len;
1226  group++, c1 += 128, c2 += 128, dm_im += 128) {
1227  for (int z = 0; z < cb_len; z++) {
1228  float mid;
1229  mid = c2[z] - alpha_re*c1[z] - alpha_im*dm_im[z];
1230  c2[z] = mid - c1[z];
1231  c1[z] = mid + c1[z];
1232  }
1233  }
1234  }
1235  }
1236 
1237  coef1 += g_len << 7;
1238  coef2 += g_len << 7;
1239  dmix_im += g_len << 7;
1240  }
1241 }
1242 
1243 static const float *complex_stereo_get_filter(ChannelElement *cpe, int is_prev)
1244 {
1245  int win, shape;
1246  if (!is_prev) {
1247  switch (cpe->ch[0].ics.window_sequence[0]) {
1248  default:
1249  case ONLY_LONG_SEQUENCE:
1250  case EIGHT_SHORT_SEQUENCE:
1251  win = 0;
1252  break;
1253  case LONG_START_SEQUENCE:
1254  win = 1;
1255  break;
1256  case LONG_STOP_SEQUENCE:
1257  win = 2;
1258  break;
1259  }
1260 
1261  if (cpe->ch[0].ics.use_kb_window[0] == 0 &&
1262  cpe->ch[0].ics.use_kb_window[1] == 0)
1263  shape = 0;
1264  else if (cpe->ch[0].ics.use_kb_window[0] == 1 &&
1265  cpe->ch[0].ics.use_kb_window[1] == 1)
1266  shape = 1;
1267  else if (cpe->ch[0].ics.use_kb_window[0] == 0 &&
1268  cpe->ch[0].ics.use_kb_window[1] == 1)
1269  shape = 2;
1270  else if (cpe->ch[0].ics.use_kb_window[0] == 1 &&
1271  cpe->ch[0].ics.use_kb_window[1] == 0)
1272  shape = 3;
1273  else
1274  shape = 3;
1275  } else {
1276  win = cpe->ch[0].ics.window_sequence[0] == LONG_STOP_SEQUENCE;
1277  shape = cpe->ch[0].ics.use_kb_window[1];
1278  }
1279 
1280  return ff_aac_usac_mdst_filt_cur[win][shape];
1281 }
1282 
1284  ChannelElement *cpe, int nb_channels)
1285 {
1286  AACUsacStereo *us = &cpe->us;
1287 
1288  for (int ch = 0; ch < nb_channels; ch++) {
1289  SingleChannelElement *sce = &cpe->ch[ch];
1290  AACUsacElemData *ue = &sce->ue;
1291 
1292  spectrum_scale(ac, sce, ue);
1293  }
1294 
1295  if (nb_channels > 1 && us->common_window) {
1296  for (int ch = 0; ch < nb_channels; ch++) {
1297  SingleChannelElement *sce = &cpe->ch[ch];
1298 
1299  /* Apply TNS, if the tns_on_lr bit is not set. */
1300  if (sce->tns.present && !us->tns_on_lr)
1301  ac->dsp.apply_tns(sce->coeffs, &sce->tns, &sce->ics, 1);
1302  }
1303 
1304  if (us->ms_mask_mode == 3) {
1305  const float *filt;
1306  complex_stereo_downmix_cur(ac, cpe, us->dmix_re);
1307  complex_stereo_downmix_prev(ac, cpe, us->prev_dmix_re);
1308 
1309  filt = complex_stereo_get_filter(cpe, 0);
1310  complex_stereo_interpolate_imag(us->dmix_im, us->dmix_re, filt,
1311  usac->core_frame_len, 1, 1);
1312  if (us->use_prev_frame) {
1313  filt = complex_stereo_get_filter(cpe, 1);
1314  complex_stereo_interpolate_imag(us->dmix_im, us->prev_dmix_re, filt,
1315  usac->core_frame_len, -1, 1);
1316  }
1317 
1318  apply_complex_stereo(ac, cpe);
1319  } else if (us->ms_mask_mode > 0) {
1320  ac->dsp.apply_mid_side_stereo(ac, cpe);
1321  }
1322  }
1323 
1324  /* Save coefficients and alpha values for prediction reasons */
1325  if (nb_channels > 1) {
1326  AACUsacStereo *us = &cpe->us;
1327  for (int ch = 0; ch < nb_channels; ch++) {
1328  SingleChannelElement *sce = &cpe->ch[ch];
1329  memcpy(sce->prev_coeffs, sce->coeffs, sizeof(sce->coeffs));
1330  }
1331  memcpy(us->prev_alpha_q_re, us->alpha_q_re, sizeof(us->alpha_q_re));
1332  memcpy(us->prev_alpha_q_im, us->alpha_q_im, sizeof(us->alpha_q_im));
1333  }
1334 
1335  for (int ch = 0; ch < nb_channels; ch++) {
1336  SingleChannelElement *sce = &cpe->ch[ch];
1337 
1338  /* Apply TNS, if it hasn't been applied yet. */
1339  if (sce->tns.present && ((nb_channels == 1) || (us->tns_on_lr)))
1340  ac->dsp.apply_tns(sce->coeffs, &sce->tns, &sce->ics, 1);
1341 
1342  ac->oc[1].m4ac.frame_length_short ? ac->dsp.imdct_and_windowing_768(ac, sce) :
1343  ac->dsp.imdct_and_windowing(ac, sce);
1344  }
1345 }
1346 
1349  GetBitContext *gb, int indep_flag, int nb_channels)
1350 {
1351  int ret;
1352  int arith_reset_flag;
1353  AACUsacStereo *us = &che->us;
1354  int core_nb_channels = nb_channels;
1355 
1356  /* Local symbols */
1357  uint8_t global_gain;
1358 
1359  us->common_window = 0;
1360 
1361  for (int ch = 0; ch < core_nb_channels; ch++) {
1362  SingleChannelElement *sce = &che->ch[ch];
1363  AACUsacElemData *ue = &sce->ue;
1364 
1365  sce->tns.present = 0;
1366  ue->tns_data_present = 0;
1367 
1368  ue->core_mode = get_bits1(gb);
1369  }
1370 
1371  if (nb_channels > 1 && ec->stereo_config_index == 1)
1372  core_nb_channels = 1;
1373 
1374  if (core_nb_channels == 2) {
1375  ret = decode_usac_stereo_info(ac, usac, ec, che, gb, indep_flag);
1376  if (ret)
1377  return ret;
1378  }
1379 
1380  for (int ch = 0; ch < core_nb_channels; ch++) {
1381  SingleChannelElement *sce = &che->ch[ch];
1382  IndividualChannelStream *ics = &sce->ics;
1383  AACUsacElemData *ue = &sce->ue;
1384 
1385  if (ue->core_mode) { /* lpd_channel_stream */
1386  ret = ff_aac_ldp_parse_channel_stream(ac, usac, ue, gb);
1387  if (ret < 0)
1388  return ret;
1389  continue;
1390  }
1391 
1392  if ((core_nb_channels == 1) ||
1393  (che->ch[0].ue.core_mode != che->ch[1].ue.core_mode))
1394  ue->tns_data_present = get_bits1(gb);
1395 
1396  /* fd_channel_stream */
1397  global_gain = get_bits(gb, 8);
1398 
1399  ue->noise.level = 0;
1400  if (ec->noise_fill) {
1401  ue->noise.level = get_bits(gb, 3);
1402  ue->noise.offset = get_bits(gb, 5);
1403  }
1404 
1405  if (!us->common_window) {
1406  /* ics_info() */
1407  ics->window_sequence[1] = ics->window_sequence[0];
1408  ics->window_sequence[0] = get_bits(gb, 2);
1409  ics->use_kb_window[1] = ics->use_kb_window[0];
1410  ics->use_kb_window[0] = get_bits1(gb);
1411  if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) {
1412  ics->max_sfb = get_bits(gb, 4);
1413  ue->scale_factor_grouping = get_bits(gb, 7);
1414  } else {
1415  ics->max_sfb = get_bits(gb, 6);
1416  }
1417 
1418  ret = setup_sce(ac, sce, usac);
1419  if (ret < 0)
1420  return ret;
1421  }
1422 
1423  if (ec->tw_mdct && !us->common_tw) {
1424  /* tw_data() */
1425  if (get_bits1(gb)) { /* tw_data_present */
1426  /* Time warping is not supported in baseline profile streams. */
1428  "AAC USAC timewarping");
1429  return AVERROR_PATCHWELCOME;
1430  }
1431  }
1432 
1433  ret = decode_usac_scale_factors(ac, sce, gb, global_gain);
1434  if (ret < 0)
1435  return ret;
1436 
1437  if (ue->tns_data_present) {
1438  sce->tns.present = 1;
1439  ret = ff_aac_decode_tns(ac, &sce->tns, gb, ics);
1440  if (ret < 0)
1441  return ret;
1442  }
1443 
1444  /* ac_spectral_data */
1445  arith_reset_flag = indep_flag;
1446  if (!arith_reset_flag)
1447  arith_reset_flag = get_bits1(gb);
1448 
1449  /* Decode coeffs */
1450  memset(&sce->coeffs[0], 0, 1024*sizeof(float));
1451  for (int win = 0; win < ics->num_windows; win++) {
1452  int lg = ics->swb_offset[ics->max_sfb];
1453  int N;
1454  if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE)
1455  N = usac->core_frame_len / 8;
1456  else
1457  N = usac->core_frame_len;
1458 
1459  ret = decode_spectrum_ac(ac, sce->coeffs + win*128, gb, &ue->ac,
1460  arith_reset_flag && (win == 0), lg, N);
1461  if (ret < 0)
1462  return ret;
1463  }
1464 
1465  if (get_bits1(gb)) { /* fac_data_present */
1466  const uint16_t len_8 = usac->core_frame_len / 8;
1467  const uint16_t len_16 = usac->core_frame_len / 16;
1468  const uint16_t fac_len = ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE ? len_16 : len_8;
1469  ret = ff_aac_parse_fac_data(ue, gb, 1, fac_len);
1470  if (ret < 0)
1471  return ret;
1472  }
1473  }
1474 
1475  if (ec->sbr.ratio) {
1476  int sbr_ch = nb_channels;
1477  if (nb_channels == 2 &&
1478  !(ec->stereo_config_index == 0 || ec->stereo_config_index == 3))
1479  sbr_ch = 1;
1480 
1481  ret = ff_aac_sbr_decode_usac_data(ac, che, ec, gb, sbr_ch, indep_flag);
1482  if (ret < 0)
1483  return ret;
1484 
1485  if (ec->stereo_config_index) {
1486  avpriv_report_missing_feature(ac->avctx, "AAC USAC Mps212");
1487  return AVERROR_PATCHWELCOME;
1488  }
1489  }
1490 
1491  spectrum_decode(ac, usac, che, core_nb_channels);
1492 
1493  if (ac->oc[1].m4ac.sbr > 0) {
1494  ac->proc.sbr_apply(ac, che, nb_channels == 2 ? TYPE_CPE : TYPE_SCE,
1495  che->ch[0].output,
1496  che->ch[1].output);
1497  }
1498 
1499  return 0;
1500 }
1501 
1503 {
1504  int ret = 0;
1505  GetBitContext gbc;
1506  OutputConfiguration *oc = &ac->oc[1];
1507  MPEG4AudioConfig *m4ac = &oc->m4ac;
1508  MPEG4AudioConfig m4ac_bak = oc->m4ac;
1509  uint8_t temp_data[512];
1510  uint8_t *tmp_buf = temp_data;
1511  size_t tmp_buf_size = sizeof(temp_data);
1512 
1513  av_unused int crossfade;
1514  int num_preroll_frames;
1515 
1516  int config_len = get_escaped_value(gb, 4, 4, 8);
1517 
1518  /* Implementations are free to pad the config to any length, so use a
1519  * different reader for this. */
1520  gbc = *gb;
1521  ret = ff_aac_usac_config_decode(ac, ac->avctx, &gbc, oc, m4ac->chan_config);
1522  if (ret < 0) {
1523  *m4ac = m4ac_bak;
1524  return ret;
1525  } else {
1526  ac->oc[1].m4ac.chan_config = 0;
1527  }
1528 
1529  /* 7.18.3.3 Bitrate adaption
1530  * If configuration didn't change after applying preroll, continue
1531  * without decoding it. */
1532  if (!memcmp(m4ac, &m4ac_bak, sizeof(m4ac_bak)))
1533  return 0;
1534 
1535  skip_bits_long(gb, config_len*8);
1536 
1537  crossfade = get_bits1(gb); /* applyCrossfade */
1538  skip_bits1(gb); /* reserved */
1539  num_preroll_frames = get_escaped_value(gb, 2, 4, 0); /* numPreRollFrames */
1540 
1541  for (int i = 0; i < num_preroll_frames; i++) {
1542  int got_frame_ptr = 0;
1543  int au_len = get_escaped_value(gb, 16, 16, 0);
1544 
1545  if (au_len*8 > tmp_buf_size) {
1546  uint8_t *tmp2;
1547  tmp_buf = tmp_buf == temp_data ? NULL : tmp_buf;
1548  tmp2 = av_realloc_array(tmp_buf, au_len, 8);
1549  if (!tmp2) {
1550  if (tmp_buf != temp_data)
1551  av_free(tmp_buf);
1552  return AVERROR(ENOMEM);
1553  }
1554  tmp_buf = tmp2;
1555  }
1556 
1557  /* Byte alignment is not guaranteed. */
1558  for (int i = 0; i < au_len; i++)
1559  tmp_buf[i] = get_bits(gb, 8);
1560 
1561  ret = init_get_bits8(&gbc, tmp_buf, au_len);
1562  if (ret < 0)
1563  break;
1564 
1565  ret = ff_aac_usac_decode_frame(ac->avctx, ac, &gbc, &got_frame_ptr);
1566  if (ret < 0)
1567  break;
1568  }
1569 
1570  if (tmp_buf != temp_data)
1571  av_free(tmp_buf);
1572 
1573  return 0;
1574 }
1575 
1577  GetBitContext *gb)
1578 {
1579  uint8_t *tmp;
1580  uint8_t pl_frag_start = 1;
1581  uint8_t pl_frag_end = 1;
1582  uint32_t len;
1583 
1584  if (!get_bits1(gb)) /* usacExtElementPresent */
1585  return 0;
1586 
1587  if (get_bits1(gb)) { /* usacExtElementUseDefaultLength */
1588  len = e->ext.default_len;
1589  } else {
1590  len = get_bits(gb, 8); /* usacExtElementPayloadLength */
1591  if (len == 255)
1592  len += get_bits(gb, 16) - 2;
1593  }
1594 
1595  if (!len)
1596  return 0;
1597 
1598  if (e->ext.payload_frag) {
1599  pl_frag_start = get_bits1(gb); /* usacExtElementStart */
1600  pl_frag_end = get_bits1(gb); /* usacExtElementStop */
1601  }
1602 
1603  if (pl_frag_start)
1604  e->ext.pl_data_offset = 0;
1605 
1606  /* If an extension starts and ends this packet, we can directly use it */
1607  if (!(pl_frag_start && pl_frag_end)) {
1609  if (!tmp) {
1610  av_free(e->ext.pl_data);
1611  return AVERROR(ENOMEM);
1612  }
1613  e->ext.pl_data = tmp;
1614 
1615  /* Readout data to a buffer */
1616  for (int i = 0; i < len; i++)
1617  e->ext.pl_data[e->ext.pl_data_offset + i] = get_bits(gb, 8);
1618  }
1619 
1620  e->ext.pl_data_offset += len;
1621 
1622  if (pl_frag_end) {
1623  int ret = 0;
1624  int start_bits = get_bits_count(gb);
1625  const int pl_len = e->ext.pl_data_offset;
1626  GetBitContext *gb2 = gb;
1627  GetBitContext gbc;
1628  if (!(pl_frag_start && pl_frag_end)) {
1629  ret = init_get_bits8(&gbc, e->ext.pl_data, pl_len);
1630  if (ret < 0)
1631  return ret;
1632 
1633  gb2 = &gbc;
1634  }
1635 
1636  switch (e->ext.type) {
1637  case ID_EXT_ELE_FILL:
1638  /* Filler elements have no usable payload */
1639  break;
1641  ret = parse_audio_preroll(ac, gb2);
1642  break;
1643  default:
1644  /* This should never happen */
1645  av_assert0(0);
1646  }
1647  av_freep(&e->ext.pl_data);
1648  if (ret < 0)
1649  return ret;
1650 
1651  skip_bits_long(gb, pl_len*8 - (get_bits_count(gb) - start_bits));
1652  }
1653 
1654  return 0;
1655 }
1656 
1658  GetBitContext *gb, int *got_frame_ptr)
1659 {
1660  int ret, is_dmono = 0;
1661  int indep_flag, samples = 0;
1662  int audio_found = 0;
1663  int elem_id[3 /* SCE, CPE, LFE */] = { 0, 0, 0 };
1664  AVFrame *frame = ac->frame;
1665 
1666  int ratio_mult, ratio_dec;
1667  AACUSACConfig *usac = &ac->oc[1].usac;
1668  int sbr_ratio = usac->core_sbr_frame_len_idx == 2 ? 2 :
1669  usac->core_sbr_frame_len_idx == 3 ? 3 :
1670  usac->core_sbr_frame_len_idx == 4 ? 1 :
1671  0;
1672 
1673  if (sbr_ratio == 2) {
1674  ratio_mult = 8;
1675  ratio_dec = 3;
1676  } else if (sbr_ratio == 3) {
1677  ratio_mult = 2;
1678  ratio_dec = 1;
1679  } else if (sbr_ratio == 4) {
1680  ratio_mult = 4;
1681  ratio_dec = 1;
1682  } else {
1683  ratio_mult = 1;
1684  ratio_dec = 1;
1685  }
1686 
1688  ac->oc[1].status, 0);
1689 
1691 
1692  indep_flag = get_bits1(gb);
1693 
1694  for (int i = 0; i < ac->oc[1].usac.nb_elems; i++) {
1695  int layout_id;
1696  int layout_type;
1697  AACUsacElemConfig *e = &ac->oc[1].usac.elems[i];
1698  ChannelElement *che;
1699 
1700  if (e->type == ID_USAC_SCE) {
1701  layout_id = elem_id[0]++;
1702  layout_type = TYPE_SCE;
1703  che = ff_aac_get_che(ac, TYPE_SCE, layout_id);
1704  } else if (e->type == ID_USAC_CPE) {
1705  layout_id = elem_id[1]++;
1706  layout_type = TYPE_CPE;
1707  che = ff_aac_get_che(ac, TYPE_CPE, layout_id);
1708  } else if (e->type == ID_USAC_LFE) {
1709  layout_id = elem_id[2]++;
1710  layout_type = TYPE_LFE;
1711  che = ff_aac_get_che(ac, TYPE_LFE, layout_id);
1712  }
1713 
1714  if (e->type != ID_USAC_EXT && !che) {
1715  av_log(ac->avctx, AV_LOG_ERROR,
1716  "channel element %d.%d is not allocated\n",
1717  layout_type, layout_id);
1718  return AVERROR_INVALIDDATA;
1719  }
1720 
1721  switch (e->type) {
1722  case ID_USAC_LFE:
1723  /* Fallthrough */
1724  case ID_USAC_SCE:
1725  ret = decode_usac_core_coder(ac, &ac->oc[1].usac, e, che, gb,
1726  indep_flag, 1);
1727  if (ret < 0)
1728  return ret;
1729 
1730  audio_found = 1;
1731  che->present = 1;
1732  break;
1733  case ID_USAC_CPE:
1734  ret = decode_usac_core_coder(ac, &ac->oc[1].usac, e, che, gb,
1735  indep_flag, 2);
1736  if (ret < 0)
1737  return ret;
1738 
1739  audio_found = 1;
1740  che->present = 1;
1741  break;
1742  case ID_USAC_EXT:
1743  ret = parse_ext_ele(ac, e, gb);
1744  if (ret < 0)
1745  return ret;
1746  break;
1747  }
1748  }
1749 
1750  if (audio_found)
1751  samples = ac->oc[1].m4ac.frame_length_short ? 768 : 1024;
1752 
1753  samples = (samples * ratio_mult) / ratio_dec;
1754 
1755  if (ac->oc[1].status && audio_found) {
1756  avctx->sample_rate = ac->oc[1].m4ac.ext_sample_rate;
1757  avctx->frame_size = samples;
1758  ac->oc[1].status = OC_LOCKED;
1759  }
1760 
1761  if (!frame->data[0] && samples) {
1762  av_log(avctx, AV_LOG_ERROR, "no frame data found\n");
1763  return AVERROR_INVALIDDATA;
1764  }
1765 
1766  if (samples) {
1767  frame->nb_samples = samples;
1768  frame->sample_rate = avctx->sample_rate;
1769  frame->flags = indep_flag ? AV_FRAME_FLAG_KEY : 0x0;
1770  *got_frame_ptr = 1;
1771  } else {
1772  av_frame_unref(ac->frame);
1773  frame->flags = indep_flag ? AV_FRAME_FLAG_KEY : 0x0;
1774  *got_frame_ptr = 0;
1775  }
1776 
1777  /* for dual-mono audio (SCE + SCE) */
1778  is_dmono = ac->dmono_mode && elem_id[0] == 2 &&
1781  if (is_dmono) {
1782  if (ac->dmono_mode == 1)
1783  frame->data[1] = frame->data[0];
1784  else if (ac->dmono_mode == 2)
1785  frame->data[0] = frame->data[1];
1786  }
1787 
1788  return 0;
1789 }
MAX_ELEM_ID
#define MAX_ELEM_ID
Definition: aac.h:34
AACUsacElemConfig::stereo_config_index
uint8_t stereo_config_index
Definition: aacdec.h:303
AVCodecContext::frame_size
int frame_size
Number of samples per channel in an audio frame.
Definition: avcodec.h:1077
ff_usac_noise_fill_start_offset
const uint8_t ff_usac_noise_fill_start_offset[2][2]
Definition: aactab.c:2009
skip_bits_long
static void skip_bits_long(GetBitContext *s, int n)
Skips the specified number of bits.
Definition: get_bits.h:278
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
AVChannelLayout::u
union AVChannelLayout::@402 u
Details about which channels are present in this layout.
AACUsacElemConfig::sbr
struct AACUsacElemConfig::@22 sbr
r
const char * r
Definition: vf_curves.c:127
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
decode_usac_stereo_info
static int decode_usac_stereo_info(AACDecContext *ac, AACUSACConfig *usac, AACUsacElemConfig *ec, ChannelElement *cpe, GetBitContext *gb, int indep_flag)
Definition: aacdec_usac.c:847
aacdec_ac.h
AACUSACConfig
Definition: aacdec.h:351
ID_EXT_ELE_SAOC
@ ID_EXT_ELE_SAOC
Definition: aacdec.h:90
AV_CHANNEL_LAYOUT_STEREO
#define AV_CHANNEL_LAYOUT_STEREO
Definition: channel_layout.h:387
AVCodecContext::sample_rate
int sample_rate
samples per second
Definition: avcodec.h:1050
AACUSACConfig::stream_identifier
uint16_t stream_identifier
Definition: aacdec.h:354
cb
static double cb(void *priv, double x, double y)
Definition: vf_geq.c:246
AACUSACConfig::nb_album
uint8_t nb_album
Definition: aacdec.h:360
spectrum_decode
static void spectrum_decode(AACDecContext *ac, AACUSACConfig *usac, ChannelElement *cpe, int nb_channels)
Definition: aacdec_usac.c:1283
AACUsacElemConfig::payload_frag
uint8_t payload_frag
Definition: aacdec.h:344
ff_aac_usac_config_decode
int ff_aac_usac_config_decode(AACDecContext *ac, AVCodecContext *avctx, GetBitContext *gb, OutputConfiguration *oc, int channel_config)
Definition: aacdec_usac.c:333
AV_CHAN_WIDE_LEFT
@ AV_CHAN_WIDE_LEFT
Definition: channel_layout.h:72
ID_USAC_LFE
@ ID_USAC_LFE
Definition: aacdec.h:77
ff_aac_ac_lsb_cdfs
const uint16_t ff_aac_ac_lsb_cdfs[3][4]
Definition: aactab.c:1335
state
static struct @437 state
get_bits_count
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:266
AVChannelLayout::map
AVChannelCustom * map
This member must be used when the channel order is AV_CHANNEL_ORDER_CUSTOM.
Definition: channel_layout.h:362
av_unused
#define av_unused
Definition: attributes.h:131
AACUsacElemConfig::tw_mdct
uint8_t tw_mdct
Definition: aacdec.h:300
aacsbr.h
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:374
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:28
AV_CHAN_TOP_SURROUND_LEFT
@ AV_CHAN_TOP_SURROUND_LEFT
+110 degrees, Lvs, TpLS
Definition: channel_layout.h:84
complex_stereo_downmix_cur
static void complex_stereo_downmix_cur(AACDecContext *ac, ChannelElement *cpe, float *dmix_re)
Definition: aacdec_usac.c:1097
b
#define b
Definition: input.c:41
aacdec_usac.h
TemporalNoiseShaping::present
int present
Definition: aacdec.h:185
AACUsacElemData::scale_factor_grouping
uint8_t scale_factor_grouping
Definition: aacdec.h:127
AACUSACConfig::nb_info
uint8_t nb_info
Definition: aacdec.h:362
AACDecDSP::apply_tns
void(* apply_tns)(void *_coef_param, TemporalNoiseShaping *tns, IndividualChannelStream *ics, int decode)
Definition: aacdec.h:421
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
AACDecContext::proc
AACDecProc proc
Definition: aacdec.h:453
AACUsacElemConfig::bs_pvc
uint8_t bs_pvc
Definition: aacdec.h:310
c1
static const uint64_t c1
Definition: murmur3.c:52
AACUsacStereo::pred_dir
uint8_t pred_dir
Definition: aacdec.h:242
AACUsacElemData::tns_data_present
uint8_t tns_data_present
Definition: aacdec.h:128
ChannelElement::ch
SingleChannelElement ch[2]
Definition: aacdec.h:266
ff_aac_sample_rate_idx
static int ff_aac_sample_rate_idx(int rate)
Definition: aac.h:106
ff_swb_offset_128
const uint16_t *const ff_swb_offset_128[]
Definition: aactab.c:1950
ChannelElement::present
int present
Definition: aacdec.h:261
ID_CONFIG_EXT_STREAM_ID
@ ID_CONFIG_EXT_STREAM_ID
Definition: aacdec.h:84
ID_USAC_EXT
@ ID_USAC_EXT
Definition: aacdec.h:78
win
static float win(SuperEqualizerContext *s, float n, int N)
Definition: af_superequalizer.c:120
AACDecContext::dmono_mode
int dmono_mode
0->not dmono, 1->use first channel, 2->use second channel
Definition: aacdec.h:522
MPEG4AudioConfig
Definition: mpeg4audio.h:29
skip_bits
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:381
AACUsacElemConfig::pseudo_lr
uint8_t pseudo_lr
Definition: aacdec.h:338
AACUsacElemConfig::mps
struct AACUsacElemConfig::@23 mps
IndividualChannelStream::num_swb
int num_swb
number of scalefactor window bands
Definition: aacdec.h:171
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:335
AV_CHAN_SURROUND_DIRECT_LEFT
@ AV_CHAN_SURROUND_DIRECT_LEFT
Definition: channel_layout.h:74
SingleChannelElement::coeffs
float coeffs[1024]
coefficients for IMDCT, maybe processed
Definition: aacenc.h:139
AACUsacElemData::core_mode
uint8_t core_mode
Definition: aacdec.h:126
mpeg4audio.h
AACArith
Definition: aacdec_ac.h:34
AVCodecContext::ch_layout
AVChannelLayout ch_layout
Audio channel layout.
Definition: avcodec.h:1065
AV_CHAN_TOP_BACK_RIGHT
@ AV_CHAN_TOP_BACK_RIGHT
Definition: channel_layout.h:67
parse_ext_ele
static int parse_ext_ele(AACDecContext *ac, AACUsacElemConfig *e, GetBitContext *gb)
Definition: aacdec_usac.c:1576
ID_EXT_ELE_AUDIOPREROLL
@ ID_EXT_ELE_AUDIOPREROLL
Definition: aacdec.h:91
TYPE_CPE
@ TYPE_CPE
Definition: aac.h:41
SFB_PER_PRED_BAND
#define SFB_PER_PRED_BAND
Definition: aacdec_usac.c:34
GetBitContext
Definition: get_bits.h:108
decode_spectrum_ac
static int decode_spectrum_ac(AACDecContext *s, float coef[1024], GetBitContext *gb, AACArithState *state, int reset, uint16_t len, uint16_t N)
Decode and dequantize arithmetically coded, uniformly quantized value.
Definition: aacdec_usac.c:599
ue
#define ue(name, range_min, range_max)
Definition: cbs_h2645.c:254
AACUsacElemConfig::high_rate_mode
uint8_t high_rate_mode
Definition: aacdec.h:332
val
static double val(void *priv, double ch)
Definition: aeval.c:78
AACDecProc::sbr_apply
void(* sbr_apply)(AACDecContext *ac, ChannelElement *che, int id_aac, void *L, void *R)
Definition: aacdec.h:406
OutputConfiguration::status
enum OCStatus status
Definition: aacdec.h:372
type
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf type
Definition: writing_filters.txt:86
us
#define us(width, name, range_min, range_max, subs,...)
Definition: cbs_h2645.c:263
AACUsacElemConfig::freq_res
uint8_t freq_res
Definition: aacdec.h:328
SingleChannelElement::ics
IndividualChannelStream ics
Definition: aacdec.h:211
AACUSACConfig::elems
AACUsacElemConfig elems[64]
Definition: aacdec.h:356
cbrt
#define cbrt
Definition: tablegen.h:35
AACUsacElemConfig::pl_data_offset
uint32_t pl_data_offset
Definition: aacdec.h:346
ID_CONFIG_EXT_FILL
@ ID_CONFIG_EXT_FILL
Definition: aacdec.h:82
AACUsacElemConfig
Definition: aacdec.h:297
complex_stereo_interpolate_imag
static void complex_stereo_interpolate_imag(float *im, float *re, const float f[7], int len, int factor_even, int factor_odd)
Definition: aacdec_usac.c:1137
AV_CHAN_BOTTOM_FRONT_LEFT
@ AV_CHAN_BOTTOM_FRONT_LEFT
Definition: channel_layout.h:80
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
AACDecDSP::dequant_scalefactors
void(* dequant_scalefactors)(SingleChannelElement *sce)
Definition: aacdec.h:415
init_get_bits8
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:545
AACUsacElemConfig::residual_bands
uint8_t residual_bands
Definition: aacdec.h:337
AV_FRAME_FLAG_KEY
#define AV_FRAME_FLAG_KEY
A flag to mark frames that are keyframes.
Definition: frame.h:625
OC_GLOBAL_HDR
@ OC_GLOBAL_HDR
Output configuration set in a global header but not yet locked.
Definition: aacdec.h:56
s
#define s(width, name)
Definition: cbs_vp9.c:198
AACUsacElemConfig::harmonic_sbr
uint8_t harmonic_sbr
Definition: aacdec.h:308
AACDecDSP::apply_mid_side_stereo
void(* apply_mid_side_stereo)(AACDecContext *ac, ChannelElement *cpe)
Definition: aacdec.h:417
av_realloc_array
void * av_realloc_array(void *ptr, size_t nmemb, size_t size)
Definition: mem.c:217
AVChannelCustom
An AVChannelCustom defines a single channel within a custom order layout.
Definition: channel_layout.h:275
ff_aac_ac_finish
void ff_aac_ac_finish(AACArithState *state, int offset, int N)
Definition: aacdec_ac.c:199
g
const char * g
Definition: vf_curves.c:128
EIGHT_SHORT_SEQUENCE
@ EIGHT_SHORT_SEQUENCE
Definition: aac.h:62
info
MIPS optimizations info
Definition: mips.txt:2
AACUsacElemConfig::pl_data
uint8_t * pl_data
Definition: aacdec.h:347
decode_usac_scale_factors
static int decode_usac_scale_factors(AACDecContext *ac, SingleChannelElement *sce, GetBitContext *gb, uint8_t global_gain)
Definition: aacdec_usac.c:559
AV_CHAN_SIDE_RIGHT
@ AV_CHAN_SIDE_RIGHT
Definition: channel_layout.h:60
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
ff_aac_get_che
ChannelElement * ff_aac_get_che(AACDecContext *ac, int type, int elem_id)
Definition: aacdec.c:589
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
AACUsacElemData
Definition: aacdec.h:125
AACUSACConfig::core_sbr_frame_len_idx
uint8_t core_sbr_frame_len_idx
Definition: aacdec.h:352
IndividualChannelStream
Individual Channel Stream.
Definition: aacdec.h:162
UNIDRCLOUDEXT_TERM
@ UNIDRCLOUDEXT_TERM
Definition: aacdec.h:96
ID_USAC_CPE
@ ID_USAC_CPE
Definition: aacdec.h:76
SCALE_DIFF_ZERO
#define SCALE_DIFF_ZERO
codebook index corresponding to zero scalefactor indices difference
Definition: aac.h:91
AV_CHAN_TOP_SIDE_LEFT
@ AV_CHAN_TOP_SIDE_LEFT
Definition: channel_layout.h:77
ff_tns_max_bands_usac_1024
const uint8_t ff_tns_max_bands_usac_1024[]
Definition: aactab.c:1988
AACDecContext::fdsp
AVFloatDSPContext * fdsp
Definition: aacdec.h:504
ff_aac_usac_decode_frame
int ff_aac_usac_decode_frame(AVCodecContext *avctx, AACDecContext *ac, GetBitContext *gb, int *got_frame_ptr)
Definition: aacdec_usac.c:1657
AV_CHAN_TOP_SIDE_RIGHT
@ AV_CHAN_TOP_SIDE_RIGHT
Definition: channel_layout.h:78
ff_aac_ac_init
void ff_aac_ac_init(AACArith *ac, GetBitContext *gb)
Definition: aacdec_ac.c:106
decode_loudness_info
static int decode_loudness_info(AACDecContext *ac, AACUSACLoudnessInfo *info, GetBitContext *gb)
Definition: aacdec_usac.c:85
AV_CHAN_SIDE_SURROUND_LEFT
@ AV_CHAN_SIDE_SURROUND_LEFT
+90 degrees, Lss, SiL
Definition: channel_layout.h:82
ff_aac_ldp_parse_channel_stream
int ff_aac_ldp_parse_channel_stream(AACDecContext *ac, AACUSACConfig *usac, AACUsacElemData *ce, GetBitContext *gb)
Definition: aacdec_lpd.c:142
NULL
#define NULL
Definition: coverity.c:32
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
AACUsacElemData::seed
unsigned int seed
Definition: aacdec.h:146
AACUSACConfig::core_frame_len
uint16_t core_frame_len
Definition: aacdec.h:353
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
IndividualChannelStream::use_kb_window
uint8_t use_kb_window[2]
If set, use Kaiser-Bessel window, otherwise use a sine window.
Definition: aacdec.h:165
ff_aac_num_swb_128
const uint8_t ff_aac_num_swb_128[]
Definition: aactab.c:169
IndividualChannelStream::num_window_groups
int num_window_groups
Definition: aacdec.h:166
ff_tns_max_bands_usac_128
const uint8_t ff_tns_max_bands_usac_128[]
Definition: aactab.c:2004
AV_CHANNEL_LAYOUT_RETYPE_FLAG_CANONICAL
#define AV_CHANNEL_LAYOUT_RETYPE_FLAG_CANONICAL
The specified retype target order is ignored and the simplest possible (canonical) order is used for ...
Definition: channel_layout.h:710
AV_CHAN_TOP_BACK_CENTER
@ AV_CHAN_TOP_BACK_CENTER
Definition: channel_layout.h:66
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:388
MPEG4AudioConfig::sampling_index
int sampling_index
Definition: mpeg4audio.h:31
ChannelElement::ms_mask
uint8_t ms_mask[128]
Set if mid/side stereo is used for each scalefactor window band.
Definition: aacdec.h:264
parse_audio_preroll
static int parse_audio_preroll(AACDecContext *ac, GetBitContext *gb)
Definition: aacdec_usac.c:1502
get_escaped_value
static uint32_t get_escaped_value(GetBitContext *gb, int nb1, int nb2, int nb3)
Definition: aacdec_usac.c:36
aactab.h
AV_CHAN_BOTTOM_FRONT_RIGHT
@ AV_CHAN_BOTTOM_FRONT_RIGHT
Definition: channel_layout.h:81
AACUsacElemConfig::noise_fill
uint8_t noise_fill
Definition: aacdec.h:301
AV_CHAN_TOP_CENTER
@ AV_CHAN_TOP_CENTER
Definition: channel_layout.h:61
AAC_CHANNEL_FRONT
@ AAC_CHANNEL_FRONT
Definition: aac.h:78
AACUsacElemConfig::temp_shape_config
uint8_t temp_shape_config
Definition: aacdec.h:330
seed
static unsigned int seed
Definition: videogen.c:78
get_vlc2
static av_always_inline int get_vlc2(GetBitContext *s, const VLCElem *table, int bits, int max_depth)
Parse a vlc code.
Definition: get_bits.h:652
decode_usac_stereo_cplx
static int decode_usac_stereo_cplx(AACDecContext *ac, AACUsacStereo *us, ChannelElement *cpe, GetBitContext *gb, int num_window_groups, int prev_num_window_groups, int indep_flag)
Definition: aacdec_usac.c:694
ff_aac_ac_decode
uint16_t ff_aac_ac_decode(AACArith *ac, GetBitContext *gb, const uint16_t *cdf, uint16_t cdf_len)
Definition: aacdec_ac.c:113
spectrum_scale
static void spectrum_scale(AACDecContext *ac, SingleChannelElement *sce, AACUsacElemData *ue)
Definition: aacdec_usac.c:1036
AACUsacStereo
Definition: aacdec.h:232
OC_LOCKED
@ OC_LOCKED
Output configuration locked in place.
Definition: aacdec.h:57
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
AV_CHAN_FRONT_RIGHT_OF_CENTER
@ AV_CHAN_FRONT_RIGHT_OF_CENTER
Definition: channel_layout.h:57
IndividualChannelStream::prev_num_window_groups
int prev_num_window_groups
Previous frame's number of window groups.
Definition: aacdec.h:167
get_unary
static int get_unary(GetBitContext *gb, int stop, int len)
Get unary code of limited length.
Definition: unary.h:46
AACUsacElemConfig::default_len
uint32_t default_len
Definition: aacdec.h:345
OutputConfiguration::layout_map_tags
int layout_map_tags
Definition: aacdec.h:370
SingleChannelElement::ue
AACUsacElemData ue
USAC element data.
Definition: aacdec.h:212
AV_CHAN_FRONT_RIGHT
@ AV_CHAN_FRONT_RIGHT
Definition: channel_layout.h:51
AV_CHAN_FRONT_CENTER
@ AV_CHAN_FRONT_CENTER
Definition: channel_layout.h:52
OutputConfiguration::layout_map
uint8_t layout_map[MAX_ELEM_ID *4][3]
Definition: aacdec.h:369
AACUsacElemConfig::bs_intertes
uint8_t bs_intertes
Definition: aacdec.h:309
IndividualChannelStream::window_sequence
enum WindowSequence window_sequence[2]
Definition: aacdec.h:164
AACDecContext::dsp
AACDecDSP dsp
Definition: aacdec.h:452
f
f
Definition: af_crystalizer.c:121
ff_swb_offset_1024
const uint16_t *const ff_swb_offset_1024[]
Definition: aactab.c:1910
powf
#define powf(x, y)
Definition: libm.h:50
AVChannelLayout
An AVChannelLayout holds information about the channel layout of audio data.
Definition: channel_layout.h:311
ONLY_LONG_SEQUENCE
@ ONLY_LONG_SEQUENCE
Definition: aac.h:60
AACDecDSP::imdct_and_windowing
void(* imdct_and_windowing)(AACDecContext *ac, SingleChannelElement *sce)
Definition: aacdec.h:436
ChannelElement::max_sfb_ste
uint8_t max_sfb_ste
(USAC) Maximum of both max_sfb values
Definition: aacdec.h:263
AV_CHAN_LOW_FREQUENCY
@ AV_CHAN_LOW_FREQUENCY
Definition: channel_layout.h:53
ESC_BT
@ ESC_BT
Spectral data are coded with an escape sequence.
Definition: aac.h:69
SingleChannelElement::sfo
int sfo[128]
scalefactor offsets
Definition: aacdec.h:215
AV_CHAN_BACK_RIGHT
@ AV_CHAN_BACK_RIGHT
Definition: channel_layout.h:55
avpriv_report_missing_feature
void avpriv_report_missing_feature(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
AV_CHAN_SIDE_LEFT
@ AV_CHAN_SIDE_LEFT
Definition: channel_layout.h:59
ChannelElement::us
AACUsacStereo us
Definition: aacdec.h:270
OutputConfiguration
Definition: aacdec.h:367
ff_aac_usac_mdst_filt_cur
const float ff_aac_usac_mdst_filt_cur[4][4][7]
Definition: aactab.c:3920
AACUsacElemConfig::dflt
struct AACUsacElemConfig::@22::@25 dflt
a
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:41
av_channel_layout_retype
int av_channel_layout_retype(AVChannelLayout *channel_layout, enum AVChannelOrder order, int flags)
Change the AVChannelOrder of a channel layout.
Definition: channel_layout.c:880
AV_CHAN_TOP_FRONT_RIGHT
@ AV_CHAN_TOP_FRONT_RIGHT
Definition: channel_layout.h:64
AV_CHANNEL_ORDER_NATIVE
@ AV_CHANNEL_ORDER_NATIVE
The native channel order, i.e.
Definition: channel_layout.h:122
skip_bits1
static void skip_bits1(GetBitContext *s)
Definition: get_bits.h:413
ff_aac_ac_get_context
uint32_t ff_aac_ac_get_context(AACArithState *state, uint32_t c, int i, int N)
Definition: aacdec_ac.c:57
AV_CHAN_FRONT_LEFT_OF_CENTER
@ AV_CHAN_FRONT_LEFT_OF_CENTER
Definition: channel_layout.h:56
N
#define N
Definition: af_mcompand.c:54
SingleChannelElement::band_type
enum BandType band_type[128]
band types
Definition: aacdec.h:214
AACUsacElemConfig::fixed_gain
uint8_t fixed_gain
Definition: aacdec.h:329
ID_CONFIG_EXT_LOUDNESS_INFO
@ ID_CONFIG_EXT_LOUDNESS_INFO
Definition: aacdec.h:83
unary.h
SingleChannelElement::output
float * output
PCM output.
Definition: aacdec.h:227
av_channel_layout_compare
int av_channel_layout_compare(const AVChannelLayout *chl, const AVChannelLayout *chl1)
Check whether two channel layouts are semantically the same, i.e.
Definition: channel_layout.c:804
ff_aac_ac_get_pk
uint32_t ff_aac_ac_get_pk(uint32_t c)
Definition: aacdec_ac.c:73
av_channel_layout_custom_init
int av_channel_layout_custom_init(AVChannelLayout *channel_layout, int nb_channels)
Initialize a custom channel layout with the specified number of channels.
Definition: channel_layout.c:227
AVChannel
AVChannel
Definition: channel_layout.h:47
apply_noise_fill
static void apply_noise_fill(AACDecContext *ac, SingleChannelElement *sce, AACUsacElemData *ue)
Definition: aacdec_usac.c:995
AV_CHAN_TOP_SURROUND_RIGHT
@ AV_CHAN_TOP_SURROUND_RIGHT
-110 degrees, Rvs, TpRS
Definition: channel_layout.h:85
RawDataBlockType
RawDataBlockType
Definition: aac.h:39
AV_CHAN_SURROUND_DIRECT_RIGHT
@ AV_CHAN_SURROUND_DIRECT_RIGHT
Definition: channel_layout.h:75
SingleChannelElement
Single Channel Element - used for both SCE and LFE elements.
Definition: aacdec.h:210
ff_swb_offset_768
const uint16_t *const ff_swb_offset_768[]
Definition: aactab.c:1926
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
decode_usac_element_pair
static int decode_usac_element_pair(AACDecContext *ac, AACUsacElemConfig *e, GetBitContext *gb)
Definition: aacdec_usac.c:202
IndividualChannelStream::num_windows
int num_windows
Definition: aacdec.h:172
OutputConfiguration::usac
AACUSACConfig usac
Definition: aacdec.h:373
LONG_STOP_SEQUENCE
@ LONG_STOP_SEQUENCE
Definition: aac.h:63
usac_ch_pos_to_av
static enum AVChannel usac_ch_pos_to_av[64]
Definition: aacdec_usac.c:50
ChannelElement
channel element - generic struct for SCE/CPE/CCE/LFE
Definition: aacdec.h:260
IndividualChannelStream::swb_offset
const uint16_t * swb_offset
table of offsets to the lowest spectral coefficient of a scalefactor band, sfb, for a particular wind...
Definition: aacdec.h:170
ff_aac_parse_fac_data
int ff_aac_parse_fac_data(AACUsacElemData *ce, GetBitContext *gb, int use_gain, int len)
Definition: aacdec_lpd.c:126
ff_aac_usac_samplerate
const int ff_aac_usac_samplerate[32]
Definition: aactab.c:3912
AACUsacElemConfig::type
enum AACUsacElem type
Definition: aacdec.h:298
TYPE_LFE
@ TYPE_LFE
Definition: aac.h:43
av_frame_unref
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:606
complex_stereo_get_filter
static const float * complex_stereo_get_filter(ChannelElement *cpe, int is_prev)
Definition: aacdec_usac.c:1243
MPEG4AudioConfig::chan_config
int chan_config
Definition: mpeg4audio.h:33
AACUsacElemConfig::decorr_config
uint8_t decorr_config
Definition: aacdec.h:331
ff_aac_ac_update_context
void ff_aac_ac_update_context(AACArithState *state, int idx, uint16_t a, uint16_t b)
Definition: aacdec_ac.c:91
TYPE_SCE
@ TYPE_SCE
Definition: aac.h:40
len
int len
Definition: vorbis_enc_data.h:426
filt
static const int8_t filt[NUMTAPS *2]
Definition: af_earwax.c:39
complex_stereo_downmix_prev
static void complex_stereo_downmix_prev(AACDecContext *ac, ChannelElement *cpe, float *dmix_re)
Definition: aacdec_usac.c:1066
AACDecContext::oc
OutputConfiguration oc[2]
Definition: aacdec.h:527
MPEG4AudioConfig::ext_sample_rate
int ext_sample_rate
Definition: mpeg4audio.h:37
IndividualChannelStream::tns_max_bands
int tns_max_bands
Definition: aacdec.h:173
ff_aac_num_swb_96
const uint8_t ff_aac_num_swb_96[]
Definition: aactab.c:177
ff_aac_ac_map_process
uint32_t ff_aac_ac_map_process(AACArithState *state, int reset, int N)
Definition: aacdec_ac.c:25
AACUSACConfig::nb_elems
int nb_elems
Definition: aacdec.h:357
ID_EXT_ELE_UNI_DRC
@ ID_EXT_ELE_UNI_DRC
Definition: aacdec.h:92
AAC_CHANNEL_LFE
@ AAC_CHANNEL_LFE
Definition: aac.h:81
decode_usac_sbr_data
static int decode_usac_sbr_data(AACDecContext *ac, AACUsacElemConfig *e, GetBitContext *gb)
Definition: aacdec_usac.c:150
ret
ret
Definition: filter_design.txt:187
ff_aac_num_swb_1024
const uint8_t ff_aac_num_swb_1024[]
Definition: aactab.c:149
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
AACDecContext::frame
struct AVFrame * frame
Definition: aacdec.h:455
decode_usac_element_core
static void decode_usac_element_core(AACUsacElemConfig *e, GetBitContext *gb, int sbr_ratio)
Definition: aacdec_usac.c:193
LONG_START_SEQUENCE
@ LONG_START_SEQUENCE
Definition: aac.h:61
UNIDRCLOUDEXT_EQ
@ UNIDRCLOUDEXT_EQ
Definition: aacdec.h:97
id
enum AVCodecID id
Definition: dts2pts.c:365
aacdec_lpd.h
AV_CHAN_BACK_CENTER
@ AV_CHAN_BACK_CENTER
Definition: channel_layout.h:58
SingleChannelElement::tns
TemporalNoiseShaping tns
Definition: aacdec.h:213
U
#define U(x)
Definition: vpx_arith.h:37
AACDecContext
main AAC decoding context
Definition: aacdec.h:448
AACUSACConfig::info
AACUSACLoudnessInfo info[64]
Definition: aacdec.h:363
AVCodecContext
main external API structure.
Definition: avcodec.h:445
c2
static const uint64_t c2
Definition: murmur3.c:53
AV_CHAN_LOW_FREQUENCY_2
@ AV_CHAN_LOW_FREQUENCY_2
Definition: channel_layout.h:76
AACDecContext::avctx
struct AVCodecContext * avctx
Definition: aacdec.h:450
AV_CHAN_TOP_BACK_LEFT
@ AV_CHAN_TOP_BACK_LEFT
Definition: channel_layout.h:65
noise_random_sign
static float noise_random_sign(unsigned int *seed)
Definition: aacdec_usac.c:987
apply_complex_stereo
static void apply_complex_stereo(AACDecContext *ac, ChannelElement *cpe)
Definition: aacdec_usac.c:1191
AACUSACConfig::loudness
struct AACUSACConfig::@26 loudness
aacdec_tab.h
setup_sce
static int setup_sce(AACDecContext *ac, SingleChannelElement *sce, AACUSACConfig *usac)
Definition: aacdec_usac.c:785
AACUSACLoudnessInfo
Definition: aacdec.h:273
AACUsacElemConfig::ext
struct AACUsacElemConfig::@24 ext
AVCodecContext::profile
int profile
profile
Definition: avcodec.h:1640
av_channel_layout_uninit
void av_channel_layout_uninit(AVChannelLayout *channel_layout)
Free any allocated data in the channel layout and reset the channel count to 0.
Definition: channel_layout.c:437
cm
#define cm
Definition: dvbsubdec.c:40
AACUsacElemConfig::env_quant_mode
uint8_t env_quant_mode
Definition: aacdec.h:339
AV_CHAN_BACK_LEFT
@ AV_CHAN_BACK_LEFT
Definition: channel_layout.h:54
MPEG4AudioConfig::sbr
int sbr
-1 implicit, 1 presence
Definition: mpeg4audio.h:34
samples
Filter the word “frame” indicates either a video frame or a group of audio samples
Definition: filter_design.txt:8
ff_aac_decode_tns
int ff_aac_decode_tns(AACDecContext *ac, TemporalNoiseShaping *tns, GetBitContext *gb, const IndividualChannelStream *ics)
Decode Temporal Noise Shaping data; reference: table 4.48.
Definition: aacdec.c:1554
ff_aac_usac_reset_state
int ff_aac_usac_reset_state(AACDecContext *ac, OutputConfiguration *oc)
Definition: aacdec_usac.c:274
AV_CHAN_BOTTOM_FRONT_CENTER
@ AV_CHAN_BOTTOM_FRONT_CENTER
Definition: channel_layout.h:79
AACUsacElemConfig::ratio
int ratio
Definition: aacdec.h:306
decode_loudness_set
static int decode_loudness_set(AACDecContext *ac, AACUSACConfig *usac, GetBitContext *gb)
Definition: aacdec_usac.c:111
av_channel_layout_copy
int av_channel_layout_copy(AVChannelLayout *dst, const AVChannelLayout *src)
Make a copy of a channel layout.
Definition: channel_layout.c:444
OutputConfiguration::m4ac
MPEG4AudioConfig m4ac
Definition: aacdec.h:368
AV_CHAN_TOP_FRONT_CENTER
@ AV_CHAN_TOP_FRONT_CENTER
Definition: channel_layout.h:63
AV_CHAN_SIDE_SURROUND_RIGHT
@ AV_CHAN_SIDE_SURROUND_RIGHT
-90 degrees, Rss, SiR
Definition: channel_layout.h:83
mem.h
FF_AAC_AC_ESCAPE
#define FF_AAC_AC_ESCAPE
Definition: aacdec_ac.h:40
OutputConfiguration::ch_layout
AVChannelLayout ch_layout
Definition: aacdec.h:371
AV_CHAN_WIDE_RIGHT
@ AV_CHAN_WIDE_RIGHT
Definition: channel_layout.h:73
ff_aac_sbr_decode_usac_data
int ff_aac_sbr_decode_usac_data(AACDecContext *ac, ChannelElement *che, AACUsacElemConfig *ue, GetBitContext *gb, int sbr_ch, int indep_flag)
Decode frame SBR data, USAC.
Definition: aacsbr_template.c:1208
decode_usac_core_coder
static int decode_usac_core_coder(AACDecContext *ac, AACUSACConfig *usac, AACUsacElemConfig *ec, ChannelElement *che, GetBitContext *gb, int indep_flag, int nb_channels)
Definition: aacdec_usac.c:1347
AACDecDSP::imdct_and_windowing_768
void(* imdct_and_windowing_768)(AACDecContext *ac, SingleChannelElement *sce)
Definition: aacdec.h:437
MPEG4AudioConfig::frame_length_short
int frame_length_short
Definition: mpeg4audio.h:41
ID_EXT_ELE_MPEGS
@ ID_EXT_ELE_MPEGS
Definition: aacdec.h:89
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
ff_aac_ac_msb_cdfs
const uint16_t ff_aac_ac_msb_cdfs[64][17]
Definition: aactab.c:1204
ff_vlc_scalefactors
VLCElem ff_vlc_scalefactors[352]
Definition: aacdec_tab.c:111
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
AV_CHAN_TOP_FRONT_LEFT
@ AV_CHAN_TOP_FRONT_LEFT
Definition: channel_layout.h:62
IndividualChannelStream::max_sfb
uint8_t max_sfb
number of scalefactor bands per group
Definition: aacdec.h:163
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
AV_CHAN_FRONT_LEFT
@ AV_CHAN_FRONT_LEFT
Definition: channel_layout.h:50
ff_aac_set_default_channel_config
int ff_aac_set_default_channel_config(AACDecContext *ac, AVCodecContext *avctx, uint8_t(*layout_map)[3], int *tags, int channel_config)
Set up channel positions based on a default channel configuration as specified in table 1....
Definition: aacdec.c:549
AACArithState
Definition: aacdec_ac.h:27
AACUsacElemConfig::residual_coding
uint8_t residual_coding
Definition: aacdec.h:336
ff_aac_sbr_config_usac
int ff_aac_sbr_config_usac(AACDecContext *ac, ChannelElement *che, AACUsacElemConfig *ue)
Due to channel allocation not being known upon SBR parameter transmission, supply the parameters sepa...
Definition: aacsbr_template.c:1200
AACUsacElemConfig::otts_bands_phase
uint8_t otts_bands_phase
Definition: aacdec.h:335
AACUSACLoudnessExt
AACUSACLoudnessExt
Definition: aacdec.h:95
IndividualChannelStream::group_len
uint8_t group_len[8]
Definition: aacdec.h:168
ff_aac_num_swb_768
const uint8_t ff_aac_num_swb_768[]
Definition: aactab.c:157
AV_PROFILE_AAC_USAC
#define AV_PROFILE_AAC_USAC
Definition: defs.h:76
AACUsacElemConfig::phase_coding
uint8_t phase_coding
Definition: aacdec.h:333
ff_aac_output_configure
int ff_aac_output_configure(AACDecContext *ac, uint8_t layout_map[MAX_ELEM_ID *4][3], int tags, enum OCStatus oc_type, int get_new_frame)
Configure output channel order based on the current program configuration element.
Definition: aacdec.c:458
ID_EXT_ELE_FILL
@ ID_EXT_ELE_FILL
Definition: aacdec.h:88
AACUsacElemData::noise
struct AACUsacElemData::@13 noise
av_realloc
void * av_realloc(void *ptr, size_t size)
Allocate, reallocate, or free a block of memory.
Definition: mem.c:155
AACUSACConfig::album_info
AACUSACLoudnessInfo album_info[64]
Definition: aacdec.h:361
MPEG4AudioConfig::sample_rate
int sample_rate
Definition: mpeg4audio.h:32
ff_swb_offset_96
const uint16_t *const ff_swb_offset_96[]
Definition: aactab.c:1968
decode_usac_extension
static int decode_usac_extension(AACDecContext *ac, AACUsacElemConfig *e, GetBitContext *gb)
Definition: aacdec_usac.c:236
ID_USAC_SCE
@ ID_USAC_SCE
Definition: aacdec.h:75