FFmpeg  4.4
dca_lbr.c
Go to the documentation of this file.
1 /*
2  * Copyright (C) 2016 foo86
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 #define BITSTREAM_READER_LE
22 
24 #include "libavutil/mem_internal.h"
25 
26 #include "dcadec.h"
27 #include "dcadata.h"
28 #include "dcahuff.h"
29 #include "dca_syncwords.h"
30 #include "bytestream.h"
31 
32 #define AMP_MAX 56
33 
34 enum LBRFlags {
46 };
47 
50  LBR_CHUNK_PAD = 0x01,
53  LBR_CHUNK_LFE = 0x0a,
54  LBR_CHUNK_ECS = 0x0b,
57  LBR_CHUNK_SCF = 0x0e,
78  LBR_CHUNK_EXTENSION = 0x7f
79 };
80 
81 typedef struct LBRChunk {
82  int id, len;
83  const uint8_t *data;
84 } LBRChunk;
85 
86 static const int8_t channel_reorder_nolfe[7][5] = {
87  { 0, -1, -1, -1, -1 }, // C
88  { 0, 1, -1, -1, -1 }, // LR
89  { 0, 1, 2, -1, -1 }, // LR C
90  { 0, 1, -1, -1, -1 }, // LsRs
91  { 1, 2, 0, -1, -1 }, // LsRs C
92  { 0, 1, 2, 3, -1 }, // LR LsRs
93  { 0, 1, 3, 4, 2 }, // LR LsRs C
94 };
95 
96 static const int8_t channel_reorder_lfe[7][5] = {
97  { 0, -1, -1, -1, -1 }, // C
98  { 0, 1, -1, -1, -1 }, // LR
99  { 0, 1, 2, -1, -1 }, // LR C
100  { 1, 2, -1, -1, -1 }, // LsRs
101  { 2, 3, 0, -1, -1 }, // LsRs C
102  { 0, 1, 3, 4, -1 }, // LR LsRs
103  { 0, 1, 4, 5, 2 }, // LR LsRs C
104 };
105 
106 static const uint8_t lfe_index[7] = {
107  1, 2, 3, 0, 1, 2, 3
108 };
109 
110 static const uint8_t channel_counts[7] = {
111  1, 2, 3, 2, 3, 4, 5
112 };
113 
114 static const uint16_t channel_layouts[7] = {
122 };
123 
124 static float cos_tab[256];
125 static float lpc_tab[16];
126 
127 static av_cold void init_tables(void)
128 {
129  static int initialized;
130  int i;
131 
132  if (initialized)
133  return;
134 
135  for (i = 0; i < 256; i++)
136  cos_tab[i] = cos(M_PI * i / 128);
137 
138  for (i = 0; i < 16; i++)
139  lpc_tab[i] = sin((i - 8) * (M_PI / ((i < 8) ? 17 : 15)));
140 
141  initialized = 1;
142 }
143 
145 {
146  int step_max = FF_ARRAY_ELEMS(ff_dca_lfe_step_size_24) - 1;
147  int i, ps, si, code, step_i;
148  float step, value, delta;
149 
150  ps = get_bits(&s->gb, 24);
151  si = ps >> 23;
152 
153  value = (((ps & 0x7fffff) ^ -si) + si) * (1.0f / 0x7fffff);
154 
155  step_i = get_bits(&s->gb, 8);
156  if (step_i > step_max) {
157  av_log(s->avctx, AV_LOG_ERROR, "Invalid LFE step size index\n");
158  return AVERROR_INVALIDDATA;
159  }
160 
161  step = ff_dca_lfe_step_size_24[step_i];
162 
163  for (i = 0; i < 64; i++) {
164  code = get_bits(&s->gb, 6);
165 
166  delta = step * 0.03125f;
167  if (code & 16)
168  delta += step;
169  if (code & 8)
170  delta += step * 0.5f;
171  if (code & 4)
172  delta += step * 0.25f;
173  if (code & 2)
174  delta += step * 0.125f;
175  if (code & 1)
176  delta += step * 0.0625f;
177 
178  if (code & 32) {
179  value -= delta;
180  if (value < -3.0f)
181  value = -3.0f;
182  } else {
183  value += delta;
184  if (value > 3.0f)
185  value = 3.0f;
186  }
187 
188  step_i += ff_dca_lfe_delta_index_24[code & 31];
189  step_i = av_clip(step_i, 0, step_max);
190 
191  step = ff_dca_lfe_step_size_24[step_i];
192  s->lfe_data[i] = value * s->lfe_scale;
193  }
194 
195  return 0;
196 }
197 
199 {
200  int step_max = FF_ARRAY_ELEMS(ff_dca_lfe_step_size_16) - 1;
201  int i, ps, si, code, step_i;
202  float step, value, delta;
203 
204  ps = get_bits(&s->gb, 16);
205  si = ps >> 15;
206 
207  value = (((ps & 0x7fff) ^ -si) + si) * (1.0f / 0x7fff);
208 
209  step_i = get_bits(&s->gb, 8);
210  if (step_i > step_max) {
211  av_log(s->avctx, AV_LOG_ERROR, "Invalid LFE step size index\n");
212  return AVERROR_INVALIDDATA;
213  }
214 
215  step = ff_dca_lfe_step_size_16[step_i];
216 
217  for (i = 0; i < 64; i++) {
218  code = get_bits(&s->gb, 4);
219 
220  delta = step * 0.125f;
221  if (code & 4)
222  delta += step;
223  if (code & 2)
224  delta += step * 0.5f;
225  if (code & 1)
226  delta += step * 0.25f;
227 
228  if (code & 8) {
229  value -= delta;
230  if (value < -3.0f)
231  value = -3.0f;
232  } else {
233  value += delta;
234  if (value > 3.0f)
235  value = 3.0f;
236  }
237 
238  step_i += ff_dca_lfe_delta_index_16[code & 7];
239  step_i = av_clip(step_i, 0, step_max);
240 
241  step = ff_dca_lfe_step_size_16[step_i];
242  s->lfe_data[i] = value * s->lfe_scale;
243  }
244 
245  return 0;
246 }
247 
249 {
250  int ret;
251 
252  if (!(s->flags & LBR_FLAG_LFE_PRESENT))
253  return 0;
254 
255  if (!chunk->len)
256  return 0;
257 
258  ret = init_get_bits8(&s->gb, chunk->data, chunk->len);
259  if (ret < 0)
260  return ret;
261 
262  // Determine bit depth from chunk size
263  if (chunk->len >= 52)
264  return parse_lfe_24(s);
265  if (chunk->len >= 35)
266  return parse_lfe_16(s);
267 
268  av_log(s->avctx, AV_LOG_ERROR, "LFE chunk too short\n");
269  return AVERROR_INVALIDDATA;
270 }
271 
272 static inline int parse_vlc(GetBitContext *s, VLC *vlc, int max_depth)
273 {
274  int v = get_vlc2(s, vlc->table, vlc->bits, max_depth);
275  if (v > 0)
276  return v - 1;
277  // Rare value
278  return get_bits(s, get_bits(s, 3) + 1);
279 }
280 
281 static int parse_tonal(DCALbrDecoder *s, int group)
282 {
283  unsigned int amp[DCA_LBR_CHANNELS_TOTAL];
284  unsigned int phs[DCA_LBR_CHANNELS_TOTAL];
285  unsigned int diff, main_amp, shift;
286  int sf, sf_idx, ch, main_ch, freq;
287  int ch_nbits = av_ceil_log2(s->nchannels_total);
288 
289  // Parse subframes for this group
290  for (sf = 0; sf < 1 << group; sf += diff ? 8 : 1) {
291  sf_idx = ((s->framenum << group) + sf) & 31;
292  s->tonal_bounds[group][sf_idx][0] = s->ntones;
293 
294  // Parse tones for this subframe
295  for (freq = 1;; freq++) {
296  if (get_bits_left(&s->gb) < 1) {
297  av_log(s->avctx, AV_LOG_ERROR, "Tonal group chunk too short\n");
298  return AVERROR_INVALIDDATA;
299  }
300 
301  diff = parse_vlc(&s->gb, &ff_dca_vlc_tnl_grp[group], 2);
303  av_log(s->avctx, AV_LOG_ERROR, "Invalid tonal frequency diff\n");
304  return AVERROR_INVALIDDATA;
305  }
306 
307  diff = get_bitsz(&s->gb, diff >> 2) + ff_dca_fst_amp[diff];
308  if (diff <= 1)
309  break; // End of subframe
310 
311  freq += diff - 2;
312  if (freq >> (5 - group) > s->nsubbands * 4 - 6) {
313  av_log(s->avctx, AV_LOG_ERROR, "Invalid spectral line offset\n");
314  return AVERROR_INVALIDDATA;
315  }
316 
317  // Main channel
318  main_ch = get_bitsz(&s->gb, ch_nbits);
319  main_amp = parse_vlc(&s->gb, &ff_dca_vlc_tnl_scf, 2)
320  + s->tonal_scf[ff_dca_freq_to_sb[freq >> (7 - group)]]
321  + s->limited_range - 2;
322  amp[main_ch] = main_amp < AMP_MAX ? main_amp : 0;
323  phs[main_ch] = get_bits(&s->gb, 3);
324 
325  // Secondary channels
326  for (ch = 0; ch < s->nchannels_total; ch++) {
327  if (ch == main_ch)
328  continue;
329  if (get_bits1(&s->gb)) {
330  amp[ch] = amp[main_ch] - parse_vlc(&s->gb, &ff_dca_vlc_damp, 1);
331  phs[ch] = phs[main_ch] - parse_vlc(&s->gb, &ff_dca_vlc_dph, 1);
332  } else {
333  amp[ch] = 0;
334  phs[ch] = 0;
335  }
336  }
337 
338  if (amp[main_ch]) {
339  // Allocate new tone
340  DCALbrTone *t = &s->tones[s->ntones];
341  s->ntones = (s->ntones + 1) & (DCA_LBR_TONES - 1);
342 
343  t->x_freq = freq >> (5 - group);
344  t->f_delt = (freq & ((1 << (5 - group)) - 1)) << group;
345  t->ph_rot = 256 - (t->x_freq & 1) * 128 - t->f_delt * 4;
346 
347  shift = ff_dca_ph0_shift[(t->x_freq & 3) * 2 + (freq & 1)]
348  - ((t->ph_rot << (5 - group)) - t->ph_rot);
349 
350  for (ch = 0; ch < s->nchannels; ch++) {
351  t->amp[ch] = amp[ch] < AMP_MAX ? amp[ch] : 0;
352  t->phs[ch] = 128 - phs[ch] * 32 + shift;
353  }
354  }
355  }
356 
357  s->tonal_bounds[group][sf_idx][1] = s->ntones;
358  }
359 
360  return 0;
361 }
362 
364 {
365  int sb, group, ret;
366 
367  if (!chunk->len)
368  return 0;
369 
370  ret = init_get_bits8(&s->gb, chunk->data, chunk->len);
371 
372  if (ret < 0)
373  return ret;
374 
375  // Scale factors
376  if (chunk->id == LBR_CHUNK_SCF || chunk->id == LBR_CHUNK_TONAL_SCF) {
377  if (get_bits_left(&s->gb) < 36) {
378  av_log(s->avctx, AV_LOG_ERROR, "Tonal scale factor chunk too short\n");
379  return AVERROR_INVALIDDATA;
380  }
381  for (sb = 0; sb < 6; sb++)
382  s->tonal_scf[sb] = get_bits(&s->gb, 6);
383  }
384 
385  // Tonal groups
386  if (chunk->id == LBR_CHUNK_TONAL || chunk->id == LBR_CHUNK_TONAL_SCF)
387  for (group = 0; group < 5; group++) {
388  ret = parse_tonal(s, group);
389  if (ret < 0)
390  return ret;
391  }
392 
393  return 0;
394 }
395 
397 {
398  int ret;
399 
400  if (!chunk->len)
401  return 0;
402 
403  ret = init_get_bits8(&s->gb, chunk->data, chunk->len);
404  if (ret < 0)
405  return ret;
406 
407  return parse_tonal(s, chunk->id);
408 }
409 
410 /**
411  * Check point to ensure that enough bits are left. Aborts decoding
412  * by skipping to the end of chunk otherwise.
413  */
414 static int ensure_bits(GetBitContext *s, int n)
415 {
416  int left = get_bits_left(s);
417  if (left < 0)
418  return AVERROR_INVALIDDATA;
419  if (left < n) {
420  skip_bits_long(s, left);
421  return 1;
422  }
423  return 0;
424 }
425 
427 {
428  int i, sf, prev, next, dist;
429 
430  // Truncated scale factors remain zero
431  if (ensure_bits(&s->gb, 20))
432  return 0;
433 
434  // Initial scale factor
435  prev = parse_vlc(&s->gb, &ff_dca_vlc_fst_rsd_amp, 2);
436 
437  for (sf = 0; sf < 7; sf += dist) {
438  scf[sf] = prev; // Store previous value
439 
440  if (ensure_bits(&s->gb, 20))
441  return 0;
442 
443  // Interpolation distance
444  dist = parse_vlc(&s->gb, &ff_dca_vlc_rsd_apprx, 1) + 1;
445  if (dist > 7 - sf) {
446  av_log(s->avctx, AV_LOG_ERROR, "Invalid scale factor distance\n");
447  return AVERROR_INVALIDDATA;
448  }
449 
450  if (ensure_bits(&s->gb, 20))
451  return 0;
452 
453  // Final interpolation point
454  next = parse_vlc(&s->gb, &ff_dca_vlc_rsd_amp, 2);
455 
456  if (next & 1)
457  next = prev + ((next + 1) >> 1);
458  else
459  next = prev - ( next >> 1);
460 
461  // Interpolate
462  switch (dist) {
463  case 2:
464  if (next > prev)
465  scf[sf + 1] = prev + ((next - prev) >> 1);
466  else
467  scf[sf + 1] = prev - ((prev - next) >> 1);
468  break;
469 
470  case 4:
471  if (next > prev) {
472  scf[sf + 1] = prev + ( (next - prev) >> 2);
473  scf[sf + 2] = prev + ( (next - prev) >> 1);
474  scf[sf + 3] = prev + (((next - prev) * 3) >> 2);
475  } else {
476  scf[sf + 1] = prev - ( (prev - next) >> 2);
477  scf[sf + 2] = prev - ( (prev - next) >> 1);
478  scf[sf + 3] = prev - (((prev - next) * 3) >> 2);
479  }
480  break;
481 
482  default:
483  for (i = 1; i < dist; i++)
484  scf[sf + i] = prev + (next - prev) * i / dist;
485  break;
486  }
487 
488  prev = next;
489  }
490 
491  scf[sf] = next; // Store final value
492 
493  return 0;
494 }
495 
496 static int parse_st_code(GetBitContext *s, int min_v)
497 {
498  unsigned int v = parse_vlc(s, &ff_dca_vlc_st_grid, 2) + min_v;
499 
500  if (v & 1)
501  v = 16 + (v >> 1);
502  else
503  v = 16 - (v >> 1);
504 
506  v = 16;
507  return v;
508 }
509 
510 static int parse_grid_1_chunk(DCALbrDecoder *s, LBRChunk *chunk, int ch1, int ch2)
511 {
512  int ch, sb, sf, nsubbands, ret;
513 
514  if (!chunk->len)
515  return 0;
516 
517  ret = init_get_bits8(&s->gb, chunk->data, chunk->len);
518  if (ret < 0)
519  return ret;
520 
521  // Scale factors
522  nsubbands = ff_dca_scf_to_grid_1[s->nsubbands - 1] + 1;
523  for (sb = 2; sb < nsubbands; sb++) {
524  ret = parse_scale_factors(s, s->grid_1_scf[ch1][sb]);
525  if (ret < 0)
526  return ret;
527  if (ch1 != ch2 && ff_dca_grid_1_to_scf[sb] < s->min_mono_subband) {
528  ret = parse_scale_factors(s, s->grid_1_scf[ch2][sb]);
529  if (ret < 0)
530  return ret;
531  }
532  }
533 
534  if (get_bits_left(&s->gb) < 1)
535  return 0; // Should not happen, but a sample exists that proves otherwise
536 
537  // Average values for third grid
538  for (sb = 0; sb < s->nsubbands - 4; sb++) {
539  s->grid_3_avg[ch1][sb] = parse_vlc(&s->gb, &ff_dca_vlc_avg_g3, 2) - 16;
540  if (ch1 != ch2) {
541  if (sb + 4 < s->min_mono_subband)
542  s->grid_3_avg[ch2][sb] = parse_vlc(&s->gb, &ff_dca_vlc_avg_g3, 2) - 16;
543  else
544  s->grid_3_avg[ch2][sb] = s->grid_3_avg[ch1][sb];
545  }
546  }
547 
548  if (get_bits_left(&s->gb) < 0) {
549  av_log(s->avctx, AV_LOG_ERROR, "First grid chunk too short\n");
550  return AVERROR_INVALIDDATA;
551  }
552 
553  // Stereo image for partial mono mode
554  if (ch1 != ch2) {
555  int min_v[2];
556 
557  if (ensure_bits(&s->gb, 8))
558  return 0;
559 
560  min_v[0] = get_bits(&s->gb, 4);
561  min_v[1] = get_bits(&s->gb, 4);
562 
563  nsubbands = (s->nsubbands - s->min_mono_subband + 3) / 4;
564  for (sb = 0; sb < nsubbands; sb++)
565  for (ch = ch1; ch <= ch2; ch++)
566  for (sf = 1; sf <= 4; sf++)
567  s->part_stereo[ch][sb][sf] = parse_st_code(&s->gb, min_v[ch - ch1]);
568 
569  if (get_bits_left(&s->gb) >= 0)
570  s->part_stereo_pres |= 1 << ch1;
571  }
572 
573  // Low resolution spatial information is not decoded
574 
575  return 0;
576 }
577 
578 static int parse_grid_1_sec_ch(DCALbrDecoder *s, int ch2)
579 {
580  int sb, nsubbands, ret;
581 
582  // Scale factors
583  nsubbands = ff_dca_scf_to_grid_1[s->nsubbands - 1] + 1;
584  for (sb = 2; sb < nsubbands; sb++) {
585  if (ff_dca_grid_1_to_scf[sb] >= s->min_mono_subband) {
586  ret = parse_scale_factors(s, s->grid_1_scf[ch2][sb]);
587  if (ret < 0)
588  return ret;
589  }
590  }
591 
592  // Average values for third grid
593  for (sb = 0; sb < s->nsubbands - 4; sb++) {
594  if (sb + 4 >= s->min_mono_subband) {
595  if (ensure_bits(&s->gb, 20))
596  return 0;
597  s->grid_3_avg[ch2][sb] = parse_vlc(&s->gb, &ff_dca_vlc_avg_g3, 2) - 16;
598  }
599  }
600 
601  return 0;
602 }
603 
604 static void parse_grid_3(DCALbrDecoder *s, int ch1, int ch2, int sb, int flag)
605 {
606  int i, ch;
607 
608  for (ch = ch1; ch <= ch2; ch++) {
609  if ((ch != ch1 && sb + 4 >= s->min_mono_subband) != flag)
610  continue;
611 
612  if (s->grid_3_pres[ch] & (1U << sb))
613  continue; // Already parsed
614 
615  for (i = 0; i < 8; i++) {
616  if (ensure_bits(&s->gb, 20))
617  return;
618  s->grid_3_scf[ch][sb][i] = parse_vlc(&s->gb, &ff_dca_vlc_grid_3, 2) - 16;
619  }
620 
621  // Flag scale factors for this subband parsed
622  s->grid_3_pres[ch] |= 1U << sb;
623  }
624 }
625 
626 static float lbr_rand(DCALbrDecoder *s, int sb)
627 {
628  s->lbr_rand = 1103515245U * s->lbr_rand + 12345U;
629  return s->lbr_rand * s->sb_scf[sb];
630 }
631 
632 /**
633  * Parse time samples for one subband, filling truncated samples with randomness
634  */
635 static void parse_ch(DCALbrDecoder *s, int ch, int sb, int quant_level, int flag)
636 {
637  float *samples = s->time_samples[ch][sb];
638  int i, j, code, nblocks, coding_method;
639 
640  if (ensure_bits(&s->gb, 20))
641  return; // Too few bits left
642 
643  coding_method = get_bits1(&s->gb);
644 
645  switch (quant_level) {
646  case 1:
647  nblocks = FFMIN(get_bits_left(&s->gb) / 8, DCA_LBR_TIME_SAMPLES / 8);
648  for (i = 0; i < nblocks; i++, samples += 8) {
649  code = get_bits(&s->gb, 8);
650  for (j = 0; j < 8; j++)
651  samples[j] = ff_dca_rsd_level_2a[(code >> j) & 1];
652  }
653  i = nblocks * 8;
654  break;
655 
656  case 2:
657  if (coding_method) {
658  for (i = 0; i < DCA_LBR_TIME_SAMPLES && get_bits_left(&s->gb) >= 2; i++) {
659  if (get_bits1(&s->gb))
660  samples[i] = ff_dca_rsd_level_2b[get_bits1(&s->gb)];
661  else
662  samples[i] = 0;
663  }
664  } else {
665  nblocks = FFMIN(get_bits_left(&s->gb) / 8, (DCA_LBR_TIME_SAMPLES + 4) / 5);
666  for (i = 0; i < nblocks; i++, samples += 5) {
668  for (j = 0; j < 5; j++)
669  samples[j] = ff_dca_rsd_level_3[(code >> j * 2) & 3];
670  }
671  i = nblocks * 5;
672  }
673  break;
674 
675  case 3:
676  nblocks = FFMIN(get_bits_left(&s->gb) / 7, (DCA_LBR_TIME_SAMPLES + 2) / 3);
677  for (i = 0; i < nblocks; i++, samples += 3) {
678  code = get_bits(&s->gb, 7);
679  for (j = 0; j < 3; j++)
681  }
682  i = nblocks * 3;
683  break;
684 
685  case 4:
686  for (i = 0; i < DCA_LBR_TIME_SAMPLES && get_bits_left(&s->gb) >= 6; i++)
687  samples[i] = ff_dca_rsd_level_8[get_vlc2(&s->gb, ff_dca_vlc_rsd.table, 6, 1)];
688  break;
689 
690  case 5:
691  nblocks = FFMIN(get_bits_left(&s->gb) / 4, DCA_LBR_TIME_SAMPLES);
692  for (i = 0; i < nblocks; i++)
693  samples[i] = ff_dca_rsd_level_16[get_bits(&s->gb, 4)];
694  break;
695 
696  default:
697  av_assert0(0);
698  }
699 
700  if (flag && get_bits_left(&s->gb) < 20)
701  return; // Skip incomplete mono subband
702 
703  for (; i < DCA_LBR_TIME_SAMPLES; i++)
704  s->time_samples[ch][sb][i] = lbr_rand(s, sb);
705 
706  s->ch_pres[ch] |= 1U << sb;
707 }
708 
709 static int parse_ts(DCALbrDecoder *s, int ch1, int ch2,
710  int start_sb, int end_sb, int flag)
711 {
712  int sb, sb_g3, sb_reorder, quant_level;
713 
714  for (sb = start_sb; sb < end_sb; sb++) {
715  // Subband number before reordering
716  if (sb < 6) {
717  sb_reorder = sb;
718  } else if (flag && sb < s->max_mono_subband) {
719  sb_reorder = s->sb_indices[sb];
720  } else {
721  if (ensure_bits(&s->gb, 28))
722  break;
723  sb_reorder = get_bits(&s->gb, s->limited_range + 3);
724  if (sb_reorder < 6)
725  sb_reorder = 6;
726  s->sb_indices[sb] = sb_reorder;
727  }
728  if (sb_reorder >= s->nsubbands)
729  return AVERROR_INVALIDDATA;
730 
731  // Third grid scale factors
732  if (sb == 12) {
733  for (sb_g3 = 0; sb_g3 < s->g3_avg_only_start_sb - 4; sb_g3++)
734  parse_grid_3(s, ch1, ch2, sb_g3, flag);
735  } else if (sb < 12 && sb_reorder >= 4) {
736  parse_grid_3(s, ch1, ch2, sb_reorder - 4, flag);
737  }
738 
739  // Secondary channel flags
740  if (ch1 != ch2) {
741  if (ensure_bits(&s->gb, 20))
742  break;
743  if (!flag || sb_reorder >= s->max_mono_subband)
744  s->sec_ch_sbms[ch1 / 2][sb_reorder] = get_bits(&s->gb, 8);
745  if (flag && sb_reorder >= s->min_mono_subband)
746  s->sec_ch_lrms[ch1 / 2][sb_reorder] = get_bits(&s->gb, 8);
747  }
748 
749  quant_level = s->quant_levels[ch1 / 2][sb];
750  if (!quant_level)
751  return AVERROR_INVALIDDATA;
752 
753  // Time samples for one or both channels
754  if (sb < s->max_mono_subband && sb_reorder >= s->min_mono_subband) {
755  if (!flag)
756  parse_ch(s, ch1, sb_reorder, quant_level, 0);
757  else if (ch1 != ch2)
758  parse_ch(s, ch2, sb_reorder, quant_level, 1);
759  } else {
760  parse_ch(s, ch1, sb_reorder, quant_level, 0);
761  if (ch1 != ch2)
762  parse_ch(s, ch2, sb_reorder, quant_level, 0);
763  }
764  }
765 
766  return 0;
767 }
768 
769 /**
770  * Convert from reflection coefficients to direct form coefficients
771  */
772 static void convert_lpc(float *coeff, const int *codes)
773 {
774  int i, j;
775 
776  for (i = 0; i < 8; i++) {
777  float rc = lpc_tab[codes[i]];
778  for (j = 0; j < (i + 1) / 2; j++) {
779  float tmp1 = coeff[ j ];
780  float tmp2 = coeff[i - j - 1];
781  coeff[ j ] = tmp1 + rc * tmp2;
782  coeff[i - j - 1] = tmp2 + rc * tmp1;
783  }
784  coeff[i] = rc;
785  }
786 }
787 
788 static int parse_lpc(DCALbrDecoder *s, int ch1, int ch2, int start_sb, int end_sb)
789 {
790  int f = s->framenum & 1;
791  int i, sb, ch, codes[16];
792 
793  // First two subbands have two sets of coefficients, third subband has one
794  for (sb = start_sb; sb < end_sb; sb++) {
795  int ncodes = 8 * (1 + (sb < 2));
796  for (ch = ch1; ch <= ch2; ch++) {
797  if (ensure_bits(&s->gb, 4 * ncodes))
798  return 0;
799  for (i = 0; i < ncodes; i++)
800  codes[i] = get_bits(&s->gb, 4);
801  for (i = 0; i < ncodes / 8; i++)
802  convert_lpc(s->lpc_coeff[f][ch][sb][i], &codes[i * 8]);
803  }
804  }
805 
806  return 0;
807 }
808 
809 static int parse_high_res_grid(DCALbrDecoder *s, LBRChunk *chunk, int ch1, int ch2)
810 {
811  int quant_levels[DCA_LBR_SUBBANDS];
812  int sb, ch, ol, st, max_sb, profile, ret;
813 
814  if (!chunk->len)
815  return 0;
816 
817  ret = init_get_bits8(&s->gb, chunk->data, chunk->len);
818  if (ret < 0)
819  return ret;
820 
821  // Quantizer profile
822  profile = get_bits(&s->gb, 8);
823  // Overall level
824  ol = (profile >> 3) & 7;
825  // Steepness
826  st = profile >> 6;
827  // Max energy subband
828  max_sb = profile & 7;
829 
830  // Calculate quantization levels
831  for (sb = 0; sb < s->nsubbands; sb++) {
832  int f = sb * s->limited_rate / s->nsubbands;
833  int a = 18000 / (12 * f / 1000 + 100 + 40 * st) + 20 * ol;
834  if (a <= 95)
835  quant_levels[sb] = 1;
836  else if (a <= 140)
837  quant_levels[sb] = 2;
838  else if (a <= 180)
839  quant_levels[sb] = 3;
840  else if (a <= 230)
841  quant_levels[sb] = 4;
842  else
843  quant_levels[sb] = 5;
844  }
845 
846  // Reorder quantization levels for lower subbands
847  for (sb = 0; sb < 8; sb++)
848  s->quant_levels[ch1 / 2][sb] = quant_levels[ff_dca_sb_reorder[max_sb][sb]];
849  for (; sb < s->nsubbands; sb++)
850  s->quant_levels[ch1 / 2][sb] = quant_levels[sb];
851 
852  // LPC for the first two subbands
853  ret = parse_lpc(s, ch1, ch2, 0, 2);
854  if (ret < 0)
855  return ret;
856 
857  // Time-samples for the first two subbands of main channel
858  ret = parse_ts(s, ch1, ch2, 0, 2, 0);
859  if (ret < 0)
860  return ret;
861 
862  // First two bands of the first grid
863  for (sb = 0; sb < 2; sb++)
864  for (ch = ch1; ch <= ch2; ch++)
865  if ((ret = parse_scale_factors(s, s->grid_1_scf[ch][sb])) < 0)
866  return ret;
867 
868  return 0;
869 }
870 
871 static int parse_grid_2(DCALbrDecoder *s, int ch1, int ch2,
872  int start_sb, int end_sb, int flag)
873 {
874  int i, j, sb, ch, nsubbands;
875 
876  nsubbands = ff_dca_scf_to_grid_2[s->nsubbands - 1] + 1;
877  if (end_sb > nsubbands)
878  end_sb = nsubbands;
879 
880  for (sb = start_sb; sb < end_sb; sb++) {
881  for (ch = ch1; ch <= ch2; ch++) {
882  uint8_t *g2_scf = s->grid_2_scf[ch][sb];
883 
884  if ((ch != ch1 && ff_dca_grid_2_to_scf[sb] >= s->min_mono_subband) != flag) {
885  if (!flag)
886  memcpy(g2_scf, s->grid_2_scf[ch1][sb], 64);
887  continue;
888  }
889 
890  // Scale factors in groups of 8
891  for (i = 0; i < 8; i++, g2_scf += 8) {
892  if (get_bits_left(&s->gb) < 1) {
893  memset(g2_scf, 0, 64 - i * 8);
894  break;
895  }
896  // Bit indicating if whole group has zero values
897  if (get_bits1(&s->gb)) {
898  for (j = 0; j < 8; j++) {
899  if (ensure_bits(&s->gb, 20))
900  break;
901  g2_scf[j] = parse_vlc(&s->gb, &ff_dca_vlc_grid_2, 2);
902  }
903  } else {
904  memset(g2_scf, 0, 8);
905  }
906  }
907  }
908  }
909 
910  return 0;
911 }
912 
913 static int parse_ts1_chunk(DCALbrDecoder *s, LBRChunk *chunk, int ch1, int ch2)
914 {
915  int ret;
916  if (!chunk->len)
917  return 0;
918  if ((ret = init_get_bits8(&s->gb, chunk->data, chunk->len)) < 0)
919  return ret;
920  if ((ret = parse_lpc(s, ch1, ch2, 2, 3)) < 0)
921  return ret;
922  if ((ret = parse_ts(s, ch1, ch2, 2, 4, 0)) < 0)
923  return ret;
924  if ((ret = parse_grid_2(s, ch1, ch2, 0, 1, 0)) < 0)
925  return ret;
926  if ((ret = parse_ts(s, ch1, ch2, 4, 6, 0)) < 0)
927  return ret;
928  return 0;
929 }
930 
931 static int parse_ts2_chunk(DCALbrDecoder *s, LBRChunk *chunk, int ch1, int ch2)
932 {
933  int ret;
934 
935  if (!chunk->len)
936  return 0;
937  if ((ret = init_get_bits8(&s->gb, chunk->data, chunk->len)) < 0)
938  return ret;
939  if ((ret = parse_grid_2(s, ch1, ch2, 1, 3, 0)) < 0)
940  return ret;
941  if ((ret = parse_ts(s, ch1, ch2, 6, s->max_mono_subband, 0)) < 0)
942  return ret;
943  if (ch1 != ch2) {
944  if ((ret = parse_grid_1_sec_ch(s, ch2)) < 0)
945  return ret;
946  if ((ret = parse_grid_2(s, ch1, ch2, 0, 3, 1)) < 0)
947  return ret;
948  }
949  if ((ret = parse_ts(s, ch1, ch2, s->min_mono_subband, s->nsubbands, 1)) < 0)
950  return ret;
951  return 0;
952 }
953 
955 {
956  double scale = (-1.0 / (1 << 17)) * sqrt(1 << (2 - s->limited_range));
957  int i, br_per_ch = s->bit_rate_scaled / s->nchannels_total;
958  int ret;
959 
960  ff_mdct_end(&s->imdct);
961 
962  ret = ff_mdct_init(&s->imdct, s->freq_range + 6, 1, scale);
963  if (ret < 0)
964  return ret;
965 
966  for (i = 0; i < 32 << s->freq_range; i++)
967  s->window[i] = ff_dca_long_window[i << (2 - s->freq_range)];
968 
969  if (br_per_ch < 14000)
970  scale = 0.85;
971  else if (br_per_ch < 32000)
972  scale = (br_per_ch - 14000) * (1.0 / 120000) + 0.85;
973  else
974  scale = 1.0;
975 
976  scale *= 1.0 / INT_MAX;
977 
978  for (i = 0; i < s->nsubbands; i++) {
979  if (i < 2)
980  s->sb_scf[i] = 0; // The first two subbands are always zero
981  else if (i < 5)
982  s->sb_scf[i] = (i - 1) * 0.25 * 0.785 * scale;
983  else
984  s->sb_scf[i] = 0.785 * scale;
985  }
986 
987  s->lfe_scale = (16 << s->freq_range) * 0.0000078265894;
988 
989  return 0;
990 }
991 
993 {
994  // Reserve space for history and padding
995  int nchsamples = DCA_LBR_TIME_SAMPLES + DCA_LBR_TIME_HISTORY * 2;
996  int nsamples = nchsamples * s->nchannels * s->nsubbands;
997  int ch, sb;
998  float *ptr;
999 
1000  // Reallocate time sample buffer
1001  av_fast_mallocz(&s->ts_buffer, &s->ts_size, nsamples * sizeof(float));
1002  if (!s->ts_buffer)
1003  return AVERROR(ENOMEM);
1004 
1005  ptr = s->ts_buffer + DCA_LBR_TIME_HISTORY;
1006  for (ch = 0; ch < s->nchannels; ch++) {
1007  for (sb = 0; sb < s->nsubbands; sb++) {
1008  s->time_samples[ch][sb] = ptr;
1009  ptr += nchsamples;
1010  }
1011  }
1012 
1013  return 0;
1014 }
1015 
1017 {
1018  int old_rate = s->sample_rate;
1019  int old_band_limit = s->band_limit;
1020  int old_nchannels = s->nchannels;
1021  int version, bit_rate_hi;
1022  unsigned int sr_code;
1023 
1024  // Sample rate of LBR audio
1025  sr_code = bytestream2_get_byte(gb);
1026  if (sr_code >= FF_ARRAY_ELEMS(ff_dca_sampling_freqs)) {
1027  av_log(s->avctx, AV_LOG_ERROR, "Invalid LBR sample rate\n");
1028  return AVERROR_INVALIDDATA;
1029  }
1030  s->sample_rate = ff_dca_sampling_freqs[sr_code];
1031  if (s->sample_rate > 48000) {
1032  avpriv_report_missing_feature(s->avctx, "%d Hz LBR sample rate", s->sample_rate);
1033  return AVERROR_PATCHWELCOME;
1034  }
1035 
1036  // LBR speaker mask
1037  s->ch_mask = bytestream2_get_le16(gb);
1038  if (!(s->ch_mask & 0x7)) {
1039  avpriv_report_missing_feature(s->avctx, "LBR channel mask %#x", s->ch_mask);
1040  return AVERROR_PATCHWELCOME;
1041  }
1042  if ((s->ch_mask & 0xfff0) && !(s->warned & 1)) {
1043  avpriv_report_missing_feature(s->avctx, "LBR channel mask %#x", s->ch_mask);
1044  s->warned |= 1;
1045  }
1046 
1047  // LBR bitstream version
1048  version = bytestream2_get_le16(gb);
1049  if ((version & 0xff00) != 0x0800) {
1050  avpriv_report_missing_feature(s->avctx, "LBR stream version %#x", version);
1051  return AVERROR_PATCHWELCOME;
1052  }
1053 
1054  // Flags for LBR decoder initialization
1055  s->flags = bytestream2_get_byte(gb);
1056  if (s->flags & LBR_FLAG_DMIX_MULTI_CH) {
1057  avpriv_report_missing_feature(s->avctx, "LBR multi-channel downmix");
1058  return AVERROR_PATCHWELCOME;
1059  }
1060  if ((s->flags & LBR_FLAG_LFE_PRESENT) && s->sample_rate != 48000) {
1061  if (!(s->warned & 2)) {
1062  avpriv_report_missing_feature(s->avctx, "%d Hz LFE interpolation", s->sample_rate);
1063  s->warned |= 2;
1064  }
1065  s->flags &= ~LBR_FLAG_LFE_PRESENT;
1066  }
1067 
1068  // Most significant bit rate nibbles
1069  bit_rate_hi = bytestream2_get_byte(gb);
1070 
1071  // Least significant original bit rate word
1072  s->bit_rate_orig = bytestream2_get_le16(gb) | ((bit_rate_hi & 0x0F) << 16);
1073 
1074  // Least significant scaled bit rate word
1075  s->bit_rate_scaled = bytestream2_get_le16(gb) | ((bit_rate_hi & 0xF0) << 12);
1076 
1077  // Setup number of fullband channels
1078  s->nchannels_total = ff_dca_count_chs_for_mask(s->ch_mask & ~DCA_SPEAKER_PAIR_LFE1);
1079  s->nchannels = FFMIN(s->nchannels_total, DCA_LBR_CHANNELS);
1080 
1081  // Setup band limit
1082  switch (s->flags & LBR_FLAG_BAND_LIMIT_MASK) {
1084  s->band_limit = 0;
1085  break;
1087  s->band_limit = 1;
1088  break;
1090  s->band_limit = 2;
1091  break;
1092  default:
1093  avpriv_report_missing_feature(s->avctx, "LBR band limit %#x", s->flags & LBR_FLAG_BAND_LIMIT_MASK);
1094  return AVERROR_PATCHWELCOME;
1095  }
1096 
1097  // Setup frequency range
1098  s->freq_range = ff_dca_freq_ranges[sr_code];
1099 
1100  // Setup resolution profile
1101  if (s->bit_rate_orig >= 44000 * (s->nchannels_total + 2))
1102  s->res_profile = 2;
1103  else if (s->bit_rate_orig >= 25000 * (s->nchannels_total + 2))
1104  s->res_profile = 1;
1105  else
1106  s->res_profile = 0;
1107 
1108  // Setup limited sample rate, number of subbands, etc
1109  s->limited_rate = s->sample_rate >> s->band_limit;
1110  s->limited_range = s->freq_range - s->band_limit;
1111  if (s->limited_range < 0) {
1112  av_log(s->avctx, AV_LOG_ERROR, "Invalid LBR band limit for frequency range\n");
1113  return AVERROR_INVALIDDATA;
1114  }
1115 
1116  s->nsubbands = 8 << s->limited_range;
1117 
1118  s->g3_avg_only_start_sb = s->nsubbands * ff_dca_avg_g3_freqs[s->res_profile] / (s->limited_rate / 2);
1119  if (s->g3_avg_only_start_sb > s->nsubbands)
1120  s->g3_avg_only_start_sb = s->nsubbands;
1121 
1122  s->min_mono_subband = s->nsubbands * 2000 / (s->limited_rate / 2);
1123  if (s->min_mono_subband > s->nsubbands)
1124  s->min_mono_subband = s->nsubbands;
1125 
1126  s->max_mono_subband = s->nsubbands * 14000 / (s->limited_rate / 2);
1127  if (s->max_mono_subband > s->nsubbands)
1128  s->max_mono_subband = s->nsubbands;
1129 
1130  // Handle change of sample rate
1131  if ((old_rate != s->sample_rate || old_band_limit != s->band_limit) && init_sample_rate(s) < 0)
1132  return AVERROR(ENOMEM);
1133 
1134  // Setup stereo downmix
1135  if (s->flags & LBR_FLAG_DMIX_STEREO) {
1136  DCAContext *dca = s->avctx->priv_data;
1137 
1138  if (s->nchannels_total < 3 || s->nchannels_total > DCA_LBR_CHANNELS_TOTAL - 2) {
1139  av_log(s->avctx, AV_LOG_ERROR, "Invalid number of channels for LBR stereo downmix\n");
1140  return AVERROR_INVALIDDATA;
1141  }
1142 
1143  // This decoder doesn't support ECS chunk
1144  if (dca->request_channel_layout != DCA_SPEAKER_LAYOUT_STEREO && !(s->warned & 4)) {
1145  avpriv_report_missing_feature(s->avctx, "Embedded LBR stereo downmix");
1146  s->warned |= 4;
1147  }
1148 
1149  // Account for extra downmixed channel pair
1150  s->nchannels_total += 2;
1151  s->nchannels = 2;
1152  s->ch_mask = DCA_SPEAKER_PAIR_LR;
1153  s->flags &= ~LBR_FLAG_LFE_PRESENT;
1154  }
1155 
1156  // Handle change of sample rate or number of channels
1157  if (old_rate != s->sample_rate
1158  || old_band_limit != s->band_limit
1159  || old_nchannels != s->nchannels) {
1160  if (alloc_sample_buffer(s) < 0)
1161  return AVERROR(ENOMEM);
1163  }
1164 
1165  return 0;
1166 }
1167 
1169 {
1170  struct {
1171  LBRChunk lfe;
1172  LBRChunk tonal;
1173  LBRChunk tonal_grp[5];
1174  LBRChunk grid1[DCA_LBR_CHANNELS / 2];
1175  LBRChunk hr_grid[DCA_LBR_CHANNELS / 2];
1176  LBRChunk ts1[DCA_LBR_CHANNELS / 2];
1177  LBRChunk ts2[DCA_LBR_CHANNELS / 2];
1178  } chunk = { {0} };
1179 
1180  GetByteContext gb;
1181 
1182  int i, ch, sb, sf, ret, group, chunk_id, chunk_len;
1183 
1184  bytestream2_init(&gb, data + asset->lbr_offset, asset->lbr_size);
1185 
1186  // LBR sync word
1187  if (bytestream2_get_be32(&gb) != DCA_SYNCWORD_LBR) {
1188  av_log(s->avctx, AV_LOG_ERROR, "Invalid LBR sync word\n");
1189  return AVERROR_INVALIDDATA;
1190  }
1191 
1192  // LBR header type
1193  switch (bytestream2_get_byte(&gb)) {
1195  if (!s->sample_rate) {
1196  av_log(s->avctx, AV_LOG_ERROR, "LBR decoder not initialized\n");
1197  return AVERROR_INVALIDDATA;
1198  }
1199  break;
1201  if ((ret = parse_decoder_init(s, &gb)) < 0) {
1202  s->sample_rate = 0;
1203  return ret;
1204  }
1205  break;
1206  default:
1207  av_log(s->avctx, AV_LOG_ERROR, "Invalid LBR header type\n");
1208  return AVERROR_INVALIDDATA;
1209  }
1210 
1211  // LBR frame chunk header
1212  chunk_id = bytestream2_get_byte(&gb);
1213  chunk_len = (chunk_id & 0x80) ? bytestream2_get_be16(&gb) : bytestream2_get_byte(&gb);
1214 
1215  if (chunk_len > bytestream2_get_bytes_left(&gb)) {
1216  chunk_len = bytestream2_get_bytes_left(&gb);
1217  av_log(s->avctx, AV_LOG_WARNING, "LBR frame chunk was truncated\n");
1218  if (s->avctx->err_recognition & AV_EF_EXPLODE)
1219  return AVERROR_INVALIDDATA;
1220  }
1221 
1222  bytestream2_init(&gb, gb.buffer, chunk_len);
1223 
1224  switch (chunk_id & 0x7f) {
1225  case LBR_CHUNK_FRAME:
1226  if (s->avctx->err_recognition & (AV_EF_CRCCHECK | AV_EF_CAREFUL)) {
1227  int checksum = bytestream2_get_be16(&gb);
1228  uint16_t res = chunk_id;
1229  res += (chunk_len >> 8) & 0xff;
1230  res += chunk_len & 0xff;
1231  for (i = 0; i < chunk_len - 2; i++)
1232  res += gb.buffer[i];
1233  if (checksum != res) {
1234  av_log(s->avctx, AV_LOG_WARNING, "Invalid LBR checksum\n");
1235  if (s->avctx->err_recognition & AV_EF_EXPLODE)
1236  return AVERROR_INVALIDDATA;
1237  }
1238  } else {
1239  bytestream2_skip(&gb, 2);
1240  }
1241  break;
1243  break;
1244  default:
1245  av_log(s->avctx, AV_LOG_ERROR, "Invalid LBR frame chunk ID\n");
1246  return AVERROR_INVALIDDATA;
1247  }
1248 
1249  // Clear current frame
1250  memset(s->quant_levels, 0, sizeof(s->quant_levels));
1251  memset(s->sb_indices, 0xff, sizeof(s->sb_indices));
1252  memset(s->sec_ch_sbms, 0, sizeof(s->sec_ch_sbms));
1253  memset(s->sec_ch_lrms, 0, sizeof(s->sec_ch_lrms));
1254  memset(s->ch_pres, 0, sizeof(s->ch_pres));
1255  memset(s->grid_1_scf, 0, sizeof(s->grid_1_scf));
1256  memset(s->grid_2_scf, 0, sizeof(s->grid_2_scf));
1257  memset(s->grid_3_avg, 0, sizeof(s->grid_3_avg));
1258  memset(s->grid_3_scf, 0, sizeof(s->grid_3_scf));
1259  memset(s->grid_3_pres, 0, sizeof(s->grid_3_pres));
1260  memset(s->tonal_scf, 0, sizeof(s->tonal_scf));
1261  memset(s->lfe_data, 0, sizeof(s->lfe_data));
1262  s->part_stereo_pres = 0;
1263  s->framenum = (s->framenum + 1) & 31;
1264 
1265  for (ch = 0; ch < s->nchannels; ch++) {
1266  for (sb = 0; sb < s->nsubbands / 4; sb++) {
1267  s->part_stereo[ch][sb][0] = s->part_stereo[ch][sb][4];
1268  s->part_stereo[ch][sb][4] = 16;
1269  }
1270  }
1271 
1272  memset(s->lpc_coeff[s->framenum & 1], 0, sizeof(s->lpc_coeff[0]));
1273 
1274  for (group = 0; group < 5; group++) {
1275  for (sf = 0; sf < 1 << group; sf++) {
1276  int sf_idx = ((s->framenum << group) + sf) & 31;
1277  s->tonal_bounds[group][sf_idx][0] =
1278  s->tonal_bounds[group][sf_idx][1] = s->ntones;
1279  }
1280  }
1281 
1282  // Parse chunk headers
1283  while (bytestream2_get_bytes_left(&gb) > 0) {
1284  chunk_id = bytestream2_get_byte(&gb);
1285  chunk_len = (chunk_id & 0x80) ? bytestream2_get_be16(&gb) : bytestream2_get_byte(&gb);
1286  chunk_id &= 0x7f;
1287 
1288  if (chunk_len > bytestream2_get_bytes_left(&gb)) {
1289  chunk_len = bytestream2_get_bytes_left(&gb);
1290  av_log(s->avctx, AV_LOG_WARNING, "LBR chunk %#x was truncated\n", chunk_id);
1291  if (s->avctx->err_recognition & AV_EF_EXPLODE)
1292  return AVERROR_INVALIDDATA;
1293  }
1294 
1295  switch (chunk_id) {
1296  case LBR_CHUNK_LFE:
1297  chunk.lfe.len = chunk_len;
1298  chunk.lfe.data = gb.buffer;
1299  break;
1300 
1301  case LBR_CHUNK_SCF:
1302  case LBR_CHUNK_TONAL:
1303  case LBR_CHUNK_TONAL_SCF:
1304  chunk.tonal.id = chunk_id;
1305  chunk.tonal.len = chunk_len;
1306  chunk.tonal.data = gb.buffer;
1307  break;
1308 
1309  case LBR_CHUNK_TONAL_GRP_1:
1310  case LBR_CHUNK_TONAL_GRP_2:
1311  case LBR_CHUNK_TONAL_GRP_3:
1312  case LBR_CHUNK_TONAL_GRP_4:
1313  case LBR_CHUNK_TONAL_GRP_5:
1314  i = LBR_CHUNK_TONAL_GRP_5 - chunk_id;
1315  chunk.tonal_grp[i].id = i;
1316  chunk.tonal_grp[i].len = chunk_len;
1317  chunk.tonal_grp[i].data = gb.buffer;
1318  break;
1319 
1325  i = LBR_CHUNK_TONAL_SCF_GRP_5 - chunk_id;
1326  chunk.tonal_grp[i].id = i;
1327  chunk.tonal_grp[i].len = chunk_len;
1328  chunk.tonal_grp[i].data = gb.buffer;
1329  break;
1330 
1331  case LBR_CHUNK_RES_GRID_LR:
1332  case LBR_CHUNK_RES_GRID_LR + 1:
1333  case LBR_CHUNK_RES_GRID_LR + 2:
1334  i = chunk_id - LBR_CHUNK_RES_GRID_LR;
1335  chunk.grid1[i].len = chunk_len;
1336  chunk.grid1[i].data = gb.buffer;
1337  break;
1338 
1339  case LBR_CHUNK_RES_GRID_HR:
1340  case LBR_CHUNK_RES_GRID_HR + 1:
1341  case LBR_CHUNK_RES_GRID_HR + 2:
1342  i = chunk_id - LBR_CHUNK_RES_GRID_HR;
1343  chunk.hr_grid[i].len = chunk_len;
1344  chunk.hr_grid[i].data = gb.buffer;
1345  break;
1346 
1347  case LBR_CHUNK_RES_TS_1:
1348  case LBR_CHUNK_RES_TS_1 + 1:
1349  case LBR_CHUNK_RES_TS_1 + 2:
1350  i = chunk_id - LBR_CHUNK_RES_TS_1;
1351  chunk.ts1[i].len = chunk_len;
1352  chunk.ts1[i].data = gb.buffer;
1353  break;
1354 
1355  case LBR_CHUNK_RES_TS_2:
1356  case LBR_CHUNK_RES_TS_2 + 1:
1357  case LBR_CHUNK_RES_TS_2 + 2:
1358  i = chunk_id - LBR_CHUNK_RES_TS_2;
1359  chunk.ts2[i].len = chunk_len;
1360  chunk.ts2[i].data = gb.buffer;
1361  break;
1362  }
1363 
1364  bytestream2_skip(&gb, chunk_len);
1365  }
1366 
1367  // Parse the chunks
1368  ret = parse_lfe_chunk(s, &chunk.lfe);
1369 
1370  ret |= parse_tonal_chunk(s, &chunk.tonal);
1371 
1372  for (i = 0; i < 5; i++)
1373  ret |= parse_tonal_group(s, &chunk.tonal_grp[i]);
1374 
1375  for (i = 0; i < (s->nchannels + 1) / 2; i++) {
1376  int ch1 = i * 2;
1377  int ch2 = FFMIN(ch1 + 1, s->nchannels - 1);
1378 
1379  if (parse_grid_1_chunk (s, &chunk.grid1 [i], ch1, ch2) < 0 ||
1380  parse_high_res_grid(s, &chunk.hr_grid[i], ch1, ch2) < 0) {
1381  ret = -1;
1382  continue;
1383  }
1384 
1385  // TS chunks depend on both grids. TS_2 depends on TS_1.
1386  if (!chunk.grid1[i].len || !chunk.hr_grid[i].len || !chunk.ts1[i].len)
1387  continue;
1388 
1389  if (parse_ts1_chunk(s, &chunk.ts1[i], ch1, ch2) < 0 ||
1390  parse_ts2_chunk(s, &chunk.ts2[i], ch1, ch2) < 0) {
1391  ret = -1;
1392  continue;
1393  }
1394  }
1395 
1396  if (ret < 0 && (s->avctx->err_recognition & AV_EF_EXPLODE))
1397  return AVERROR_INVALIDDATA;
1398 
1399  return 0;
1400 }
1401 
1402 /**
1403  * Reconstruct high-frequency resolution grid from first and third grids
1404  */
1405 static void decode_grid(DCALbrDecoder *s, int ch1, int ch2)
1406 {
1407  int i, ch, sb;
1408 
1409  for (ch = ch1; ch <= ch2; ch++) {
1410  for (sb = 0; sb < s->nsubbands; sb++) {
1411  int g1_sb = ff_dca_scf_to_grid_1[sb];
1412 
1413  uint8_t *g1_scf_a = s->grid_1_scf[ch][g1_sb ];
1414  uint8_t *g1_scf_b = s->grid_1_scf[ch][g1_sb + 1];
1415 
1416  int w1 = ff_dca_grid_1_weights[g1_sb ][sb];
1417  int w2 = ff_dca_grid_1_weights[g1_sb + 1][sb];
1418 
1419  uint8_t *hr_scf = s->high_res_scf[ch][sb];
1420 
1421  if (sb < 4) {
1422  for (i = 0; i < 8; i++) {
1423  int scf = w1 * g1_scf_a[i] + w2 * g1_scf_b[i];
1424  hr_scf[i] = scf >> 7;
1425  }
1426  } else {
1427  int8_t *g3_scf = s->grid_3_scf[ch][sb - 4];
1428  int g3_avg = s->grid_3_avg[ch][sb - 4];
1429 
1430  for (i = 0; i < 8; i++) {
1431  int scf = w1 * g1_scf_a[i] + w2 * g1_scf_b[i];
1432  hr_scf[i] = (scf >> 7) - g3_avg - g3_scf[i];
1433  }
1434  }
1435  }
1436  }
1437 }
1438 
1439 /**
1440  * Fill unallocated subbands with randomness
1441  */
1442 static void random_ts(DCALbrDecoder *s, int ch1, int ch2)
1443 {
1444  int i, j, k, ch, sb;
1445 
1446  for (ch = ch1; ch <= ch2; ch++) {
1447  for (sb = 0; sb < s->nsubbands; sb++) {
1448  float *samples = s->time_samples[ch][sb];
1449 
1450  if (s->ch_pres[ch] & (1U << sb))
1451  continue; // Skip allocated subband
1452 
1453  if (sb < 2) {
1454  // The first two subbands are always zero
1455  memset(samples, 0, DCA_LBR_TIME_SAMPLES * sizeof(float));
1456  } else if (sb < 10) {
1457  for (i = 0; i < DCA_LBR_TIME_SAMPLES; i++)
1458  samples[i] = lbr_rand(s, sb);
1459  } else {
1460  for (i = 0; i < DCA_LBR_TIME_SAMPLES / 8; i++, samples += 8) {
1461  float accum[8] = { 0 };
1462 
1463  // Modulate by subbands 2-5 in blocks of 8
1464  for (k = 2; k < 6; k++) {
1465  float *other = &s->time_samples[ch][k][i * 8];
1466  for (j = 0; j < 8; j++)
1467  accum[j] += fabs(other[j]);
1468  }
1469 
1470  for (j = 0; j < 8; j++)
1471  samples[j] = (accum[j] * 0.25f + 0.5f) * lbr_rand(s, sb);
1472  }
1473  }
1474  }
1475  }
1476 }
1477 
1478 static void predict(float *samples, const float *coeff, int nsamples)
1479 {
1480  int i, j;
1481 
1482  for (i = 0; i < nsamples; i++) {
1483  float res = 0;
1484  for (j = 0; j < 8; j++)
1485  res += coeff[j] * samples[i - j - 1];
1486  samples[i] -= res;
1487  }
1488 }
1489 
1490 static void synth_lpc(DCALbrDecoder *s, int ch1, int ch2, int sb)
1491 {
1492  int f = s->framenum & 1;
1493  int ch;
1494 
1495  for (ch = ch1; ch <= ch2; ch++) {
1496  float *samples = s->time_samples[ch][sb];
1497 
1498  if (!(s->ch_pres[ch] & (1U << sb)))
1499  continue;
1500 
1501  if (sb < 2) {
1502  predict(samples, s->lpc_coeff[f^1][ch][sb][1], 16);
1503  predict(samples + 16, s->lpc_coeff[f ][ch][sb][0], 64);
1504  predict(samples + 80, s->lpc_coeff[f ][ch][sb][1], 48);
1505  } else {
1506  predict(samples, s->lpc_coeff[f^1][ch][sb][0], 16);
1507  predict(samples + 16, s->lpc_coeff[f ][ch][sb][0], 112);
1508  }
1509  }
1510 }
1511 
1512 static void filter_ts(DCALbrDecoder *s, int ch1, int ch2)
1513 {
1514  int i, j, sb, ch;
1515 
1516  for (sb = 0; sb < s->nsubbands; sb++) {
1517  // Scale factors
1518  for (ch = ch1; ch <= ch2; ch++) {
1519  float *samples = s->time_samples[ch][sb];
1520  uint8_t *hr_scf = s->high_res_scf[ch][sb];
1521  if (sb < 4) {
1522  for (i = 0; i < DCA_LBR_TIME_SAMPLES / 16; i++, samples += 16) {
1523  unsigned int scf = hr_scf[i];
1524  if (scf > AMP_MAX)
1525  scf = AMP_MAX;
1526  for (j = 0; j < 16; j++)
1527  samples[j] *= ff_dca_quant_amp[scf];
1528  }
1529  } else {
1530  uint8_t *g2_scf = s->grid_2_scf[ch][ff_dca_scf_to_grid_2[sb]];
1531  for (i = 0; i < DCA_LBR_TIME_SAMPLES / 2; i++, samples += 2) {
1532  unsigned int scf = hr_scf[i / 8] - g2_scf[i];
1533  if (scf > AMP_MAX)
1534  scf = AMP_MAX;
1535  samples[0] *= ff_dca_quant_amp[scf];
1536  samples[1] *= ff_dca_quant_amp[scf];
1537  }
1538  }
1539  }
1540 
1541  // Mid-side stereo
1542  if (ch1 != ch2) {
1543  float *samples_l = s->time_samples[ch1][sb];
1544  float *samples_r = s->time_samples[ch2][sb];
1545  int ch2_pres = s->ch_pres[ch2] & (1U << sb);
1546 
1547  for (i = 0; i < DCA_LBR_TIME_SAMPLES / 16; i++) {
1548  int sbms = (s->sec_ch_sbms[ch1 / 2][sb] >> i) & 1;
1549  int lrms = (s->sec_ch_lrms[ch1 / 2][sb] >> i) & 1;
1550 
1551  if (sb >= s->min_mono_subband) {
1552  if (lrms && ch2_pres) {
1553  if (sbms) {
1554  for (j = 0; j < 16; j++) {
1555  float tmp = samples_l[j];
1556  samples_l[j] = samples_r[j];
1557  samples_r[j] = -tmp;
1558  }
1559  } else {
1560  for (j = 0; j < 16; j++) {
1561  float tmp = samples_l[j];
1562  samples_l[j] = samples_r[j];
1563  samples_r[j] = tmp;
1564  }
1565  }
1566  } else if (!ch2_pres) {
1567  if (sbms && (s->part_stereo_pres & (1 << ch1))) {
1568  for (j = 0; j < 16; j++)
1569  samples_r[j] = -samples_l[j];
1570  } else {
1571  for (j = 0; j < 16; j++)
1572  samples_r[j] = samples_l[j];
1573  }
1574  }
1575  } else if (sbms && ch2_pres) {
1576  for (j = 0; j < 16; j++) {
1577  float tmp = samples_l[j];
1578  samples_l[j] = (tmp + samples_r[j]) * 0.5f;
1579  samples_r[j] = (tmp - samples_r[j]) * 0.5f;
1580  }
1581  }
1582 
1583  samples_l += 16;
1584  samples_r += 16;
1585  }
1586  }
1587 
1588  // Inverse prediction
1589  if (sb < 3)
1590  synth_lpc(s, ch1, ch2, sb);
1591  }
1592 }
1593 
1594 /**
1595  * Modulate by interpolated partial stereo coefficients
1596  */
1597 static void decode_part_stereo(DCALbrDecoder *s, int ch1, int ch2)
1598 {
1599  int i, ch, sb, sf;
1600 
1601  for (ch = ch1; ch <= ch2; ch++) {
1602  for (sb = s->min_mono_subband; sb < s->nsubbands; sb++) {
1603  uint8_t *pt_st = s->part_stereo[ch][(sb - s->min_mono_subband) / 4];
1604  float *samples = s->time_samples[ch][sb];
1605 
1606  if (s->ch_pres[ch2] & (1U << sb))
1607  continue;
1608 
1609  for (sf = 1; sf <= 4; sf++, samples += 32) {
1610  float prev = ff_dca_st_coeff[pt_st[sf - 1]];
1611  float next = ff_dca_st_coeff[pt_st[sf ]];
1612 
1613  for (i = 0; i < 32; i++)
1614  samples[i] *= (32 - i) * prev + i * next;
1615  }
1616  }
1617  }
1618 }
1619 
1620 /**
1621  * Synthesise tones in the given group for the given tonal subframe
1622  */
1623 static void synth_tones(DCALbrDecoder *s, int ch, float *values,
1624  int group, int group_sf, int synth_idx)
1625 {
1626  int i, start, count;
1627 
1628  if (synth_idx < 0)
1629  return;
1630 
1631  start = s->tonal_bounds[group][group_sf][0];
1632  count = (s->tonal_bounds[group][group_sf][1] - start) & (DCA_LBR_TONES - 1);
1633 
1634  for (i = 0; i < count; i++) {
1635  DCALbrTone *t = &s->tones[(start + i) & (DCA_LBR_TONES - 1)];
1636 
1637  if (t->amp[ch]) {
1638  float amp = ff_dca_synth_env[synth_idx] * ff_dca_quant_amp[t->amp[ch]];
1639  float c = amp * cos_tab[(t->phs[ch] ) & 255];
1640  float s = amp * cos_tab[(t->phs[ch] + 64) & 255];
1641  const float *cf = ff_dca_corr_cf[t->f_delt];
1642  int x_freq = t->x_freq;
1643 
1644  switch (x_freq) {
1645  case 0:
1646  goto p0;
1647  case 1:
1648  values[3] += cf[0] * -s;
1649  values[2] += cf[1] * c;
1650  values[1] += cf[2] * s;
1651  values[0] += cf[3] * -c;
1652  goto p1;
1653  case 2:
1654  values[2] += cf[0] * -s;
1655  values[1] += cf[1] * c;
1656  values[0] += cf[2] * s;
1657  goto p2;
1658  case 3:
1659  values[1] += cf[0] * -s;
1660  values[0] += cf[1] * c;
1661  goto p3;
1662  case 4:
1663  values[0] += cf[0] * -s;
1664  goto p4;
1665  }
1666 
1667  values[x_freq - 5] += cf[ 0] * -s;
1668  p4: values[x_freq - 4] += cf[ 1] * c;
1669  p3: values[x_freq - 3] += cf[ 2] * s;
1670  p2: values[x_freq - 2] += cf[ 3] * -c;
1671  p1: values[x_freq - 1] += cf[ 4] * -s;
1672  p0: values[x_freq ] += cf[ 5] * c;
1673  values[x_freq + 1] += cf[ 6] * s;
1674  values[x_freq + 2] += cf[ 7] * -c;
1675  values[x_freq + 3] += cf[ 8] * -s;
1676  values[x_freq + 4] += cf[ 9] * c;
1677  values[x_freq + 5] += cf[10] * s;
1678  }
1679 
1680  t->phs[ch] += t->ph_rot;
1681  }
1682 }
1683 
1684 /**
1685  * Synthesise all tones in all groups for the given residual subframe
1686  */
1687 static void base_func_synth(DCALbrDecoder *s, int ch, float *values, int sf)
1688 {
1689  int group;
1690 
1691  // Tonal vs residual shift is 22 subframes
1692  for (group = 0; group < 5; group++) {
1693  int group_sf = (s->framenum << group) + ((sf - 22) >> (5 - group));
1694  int synth_idx = ((((sf - 22) & 31) << group) & 31) + (1 << group) - 1;
1695 
1696  synth_tones(s, ch, values, group, (group_sf - 1) & 31, 30 - synth_idx);
1697  synth_tones(s, ch, values, group, (group_sf ) & 31, synth_idx);
1698  }
1699 }
1700 
1701 static void transform_channel(DCALbrDecoder *s, int ch, float *output)
1702 {
1703  LOCAL_ALIGNED_32(float, values, [DCA_LBR_SUBBANDS ], [4]);
1704  LOCAL_ALIGNED_32(float, result, [DCA_LBR_SUBBANDS * 2], [4]);
1705  int sf, sb, nsubbands = s->nsubbands, noutsubbands = 8 << s->freq_range;
1706 
1707  // Clear inactive subbands
1708  if (nsubbands < noutsubbands)
1709  memset(values[nsubbands], 0, (noutsubbands - nsubbands) * sizeof(values[0]));
1710 
1711  for (sf = 0; sf < DCA_LBR_TIME_SAMPLES / 4; sf++) {
1712  // Hybrid filterbank
1713  s->dcadsp->lbr_bank(values, s->time_samples[ch],
1714  ff_dca_bank_coeff, sf * 4, nsubbands);
1715 
1716  base_func_synth(s, ch, values[0], sf);
1717 
1718  s->imdct.imdct_calc(&s->imdct, result[0], values[0]);
1719 
1720  // Long window and overlap-add
1721  s->fdsp->vector_fmul_add(output, result[0], s->window,
1722  s->history[ch], noutsubbands * 4);
1723  s->fdsp->vector_fmul_reverse(s->history[ch], result[noutsubbands],
1724  s->window, noutsubbands * 4);
1725  output += noutsubbands * 4;
1726  }
1727 
1728  // Update history for LPC and forward MDCT
1729  for (sb = 0; sb < nsubbands; sb++) {
1730  float *samples = s->time_samples[ch][sb] - DCA_LBR_TIME_HISTORY;
1731  memcpy(samples, samples + DCA_LBR_TIME_SAMPLES, DCA_LBR_TIME_HISTORY * sizeof(float));
1732  }
1733 }
1734 
1736 {
1737  AVCodecContext *avctx = s->avctx;
1738  int i, ret, nchannels, ch_conf = (s->ch_mask & 0x7) - 1;
1739  const int8_t *reorder;
1740 
1741  avctx->channel_layout = channel_layouts[ch_conf];
1742  avctx->channels = nchannels = channel_counts[ch_conf];
1743  avctx->sample_rate = s->sample_rate;
1744  avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;
1745  avctx->bits_per_raw_sample = 0;
1747  avctx->bit_rate = s->bit_rate_scaled;
1748 
1749  if (s->flags & LBR_FLAG_LFE_PRESENT) {
1751  avctx->channels++;
1752  reorder = channel_reorder_lfe[ch_conf];
1753  } else {
1754  reorder = channel_reorder_nolfe[ch_conf];
1755  }
1756 
1757  frame->nb_samples = 1024 << s->freq_range;
1758  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
1759  return ret;
1760 
1761  // Filter fullband channels
1762  for (i = 0; i < (s->nchannels + 1) / 2; i++) {
1763  int ch1 = i * 2;
1764  int ch2 = FFMIN(ch1 + 1, s->nchannels - 1);
1765 
1766  decode_grid(s, ch1, ch2);
1767 
1768  random_ts(s, ch1, ch2);
1769 
1770  filter_ts(s, ch1, ch2);
1771 
1772  if (ch1 != ch2 && (s->part_stereo_pres & (1 << ch1)))
1773  decode_part_stereo(s, ch1, ch2);
1774 
1775  if (ch1 < nchannels)
1776  transform_channel(s, ch1, (float *)frame->extended_data[reorder[ch1]]);
1777 
1778  if (ch1 != ch2 && ch2 < nchannels)
1779  transform_channel(s, ch2, (float *)frame->extended_data[reorder[ch2]]);
1780  }
1781 
1782  // Interpolate LFE channel
1783  if (s->flags & LBR_FLAG_LFE_PRESENT) {
1784  s->dcadsp->lfe_iir((float *)frame->extended_data[lfe_index[ch_conf]],
1785  s->lfe_data, ff_dca_lfe_iir,
1786  s->lfe_history, 16 << s->freq_range);
1787  }
1788 
1790  return ret;
1791 
1792  return 0;
1793 }
1794 
1796 {
1797  int ch, sb;
1798 
1799  if (!s->sample_rate)
1800  return;
1801 
1802  // Clear history
1803  memset(s->part_stereo, 16, sizeof(s->part_stereo));
1804  memset(s->lpc_coeff, 0, sizeof(s->lpc_coeff));
1805  memset(s->history, 0, sizeof(s->history));
1806  memset(s->tonal_bounds, 0, sizeof(s->tonal_bounds));
1807  memset(s->lfe_history, 0, sizeof(s->lfe_history));
1808  s->framenum = 0;
1809  s->ntones = 0;
1810 
1811  for (ch = 0; ch < s->nchannels; ch++) {
1812  for (sb = 0; sb < s->nsubbands; sb++) {
1813  float *samples = s->time_samples[ch][sb] - DCA_LBR_TIME_HISTORY;
1814  memset(samples, 0, DCA_LBR_TIME_HISTORY * sizeof(float));
1815  }
1816  }
1817 }
1818 
1820 {
1821  init_tables();
1822 
1823  if (!(s->fdsp = avpriv_float_dsp_alloc(0)))
1824  return AVERROR(ENOMEM);
1825 
1826  s->lbr_rand = 1;
1827  return 0;
1828 }
1829 
1831 {
1832  s->sample_rate = 0;
1833 
1834  av_freep(&s->ts_buffer);
1835  s->ts_size = 0;
1836 
1837  av_freep(&s->fdsp);
1838  ff_mdct_end(&s->imdct);
1839 }
#define av_cold
Definition: attributes.h:88
uint8_t
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
#define AV_EF_CRCCHECK
Verify checksums embedded in the bitstream (could be of either encoded or decoded data,...
Definition: avcodec.h:1653
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: avcodec.h:1656
#define FF_PROFILE_DTS_EXPRESS
Definition: avcodec.h:1885
#define AV_EF_CAREFUL
consider things that violate the spec, are fast to calculate and have not been seen in the wild as er...
Definition: avcodec.h:1659
static av_always_inline int bytestream2_get_bytes_left(GetByteContext *g)
Definition: bytestream.h:158
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:137
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
Definition: bytestream.h:168
#define flag(name)
Definition: cbs_av1.c:553
#define s(width, name)
Definition: cbs_vp9.c:257
#define f(width, name)
Definition: cbs_vp9.c:255
audio channel layout utility functions
#define FFMIN(a, b)
Definition: common.h:105
#define av_clip
Definition: common.h:122
#define av_ceil_log2
Definition: common.h:119
static __device__ float fabs(float a)
Definition: cuda_runtime.h:182
const uint8_t ff_dca_freq_ranges[16]
Definition: dca.c:46
const uint32_t ff_dca_sampling_freqs[16]
Definition: dca.c:41
#define DCA_SPEAKER_LAYOUT_STEREO
Definition: dca.h:123
static int ff_dca_count_chs_for_mask(unsigned int mask)
Return number of individual channels in DCASpeakerPair mask.
Definition: dca.h:159
@ DCA_SPEAKER_PAIR_LR
Definition: dca.h:139
@ DCA_SPEAKER_PAIR_LFE1
Definition: dca.h:141
static void random_ts(DCALbrDecoder *s, int ch1, int ch2)
Fill unallocated subbands with randomness.
Definition: dca_lbr.c:1442
static int alloc_sample_buffer(DCALbrDecoder *s)
Definition: dca_lbr.c:992
static int parse_grid_1_sec_ch(DCALbrDecoder *s, int ch2)
Definition: dca_lbr.c:578
int ff_dca_lbr_filter_frame(DCALbrDecoder *s, AVFrame *frame)
Definition: dca_lbr.c:1735
static void filter_ts(DCALbrDecoder *s, int ch1, int ch2)
Definition: dca_lbr.c:1512
static void decode_grid(DCALbrDecoder *s, int ch1, int ch2)
Reconstruct high-frequency resolution grid from first and third grids.
Definition: dca_lbr.c:1405
static void predict(float *samples, const float *coeff, int nsamples)
Definition: dca_lbr.c:1478
static const int8_t channel_reorder_lfe[7][5]
Definition: dca_lbr.c:96
static int parse_decoder_init(DCALbrDecoder *s, GetByteContext *gb)
Definition: dca_lbr.c:1016
static void transform_channel(DCALbrDecoder *s, int ch, float *output)
Definition: dca_lbr.c:1701
static int parse_vlc(GetBitContext *s, VLC *vlc, int max_depth)
Definition: dca_lbr.c:272
static int parse_lfe_chunk(DCALbrDecoder *s, LBRChunk *chunk)
Definition: dca_lbr.c:248
static const uint16_t channel_layouts[7]
Definition: dca_lbr.c:114
static void decode_part_stereo(DCALbrDecoder *s, int ch1, int ch2)
Modulate by interpolated partial stereo coefficients.
Definition: dca_lbr.c:1597
static int parse_tonal_chunk(DCALbrDecoder *s, LBRChunk *chunk)
Definition: dca_lbr.c:363
static int parse_tonal(DCALbrDecoder *s, int group)
Definition: dca_lbr.c:281
static const uint8_t channel_counts[7]
Definition: dca_lbr.c:110
int ff_dca_lbr_parse(DCALbrDecoder *s, uint8_t *data, DCAExssAsset *asset)
Definition: dca_lbr.c:1168
static const uint8_t lfe_index[7]
Definition: dca_lbr.c:106
static int ensure_bits(GetBitContext *s, int n)
Check point to ensure that enough bits are left.
Definition: dca_lbr.c:414
static av_cold void init_tables(void)
Definition: dca_lbr.c:127
static int parse_high_res_grid(DCALbrDecoder *s, LBRChunk *chunk, int ch1, int ch2)
Definition: dca_lbr.c:809
static int parse_ts1_chunk(DCALbrDecoder *s, LBRChunk *chunk, int ch1, int ch2)
Definition: dca_lbr.c:913
static void synth_lpc(DCALbrDecoder *s, int ch1, int ch2, int sb)
Definition: dca_lbr.c:1490
av_cold int ff_dca_lbr_init(DCALbrDecoder *s)
Definition: dca_lbr.c:1819
LBRFlags
Definition: dca_lbr.c:34
@ LBR_FLAG_BAND_LIMIT_1_4
Definition: dca_lbr.c:40
@ LBR_FLAG_BAND_LIMIT_1_2
Definition: dca_lbr.c:38
@ LBR_FLAG_DMIX_STEREO
Definition: dca_lbr.c:44
@ LBR_FLAG_BAND_LIMIT_MASK
Definition: dca_lbr.c:43
@ LBR_FLAG_BAND_LIMIT_2_3
Definition: dca_lbr.c:37
@ LBR_FLAG_BAND_LIMIT_1_8
Definition: dca_lbr.c:41
@ LBR_FLAG_BAND_LIMIT_1_3
Definition: dca_lbr.c:39
@ LBR_FLAG_BAND_LIMIT_NONE
Definition: dca_lbr.c:42
@ LBR_FLAG_24_BIT
Definition: dca_lbr.c:35
@ LBR_FLAG_LFE_PRESENT
Definition: dca_lbr.c:36
@ LBR_FLAG_DMIX_MULTI_CH
Definition: dca_lbr.c:45
static int parse_tonal_group(DCALbrDecoder *s, LBRChunk *chunk)
Definition: dca_lbr.c:396
static float cos_tab[256]
Definition: dca_lbr.c:124
static float lbr_rand(DCALbrDecoder *s, int sb)
Definition: dca_lbr.c:626
static void synth_tones(DCALbrDecoder *s, int ch, float *values, int group, int group_sf, int synth_idx)
Synthesise tones in the given group for the given tonal subframe.
Definition: dca_lbr.c:1623
static int parse_ts2_chunk(DCALbrDecoder *s, LBRChunk *chunk, int ch1, int ch2)
Definition: dca_lbr.c:931
static void parse_grid_3(DCALbrDecoder *s, int ch1, int ch2, int sb, int flag)
Definition: dca_lbr.c:604
static int parse_st_code(GetBitContext *s, int min_v)
Definition: dca_lbr.c:496
static int init_sample_rate(DCALbrDecoder *s)
Definition: dca_lbr.c:954
static int parse_grid_1_chunk(DCALbrDecoder *s, LBRChunk *chunk, int ch1, int ch2)
Definition: dca_lbr.c:510
av_cold void ff_dca_lbr_close(DCALbrDecoder *s)
Definition: dca_lbr.c:1830
static void parse_ch(DCALbrDecoder *s, int ch, int sb, int quant_level, int flag)
Parse time samples for one subband, filling truncated samples with randomness.
Definition: dca_lbr.c:635
static int parse_lfe_16(DCALbrDecoder *s)
Definition: dca_lbr.c:198
static int parse_lpc(DCALbrDecoder *s, int ch1, int ch2, int start_sb, int end_sb)
Definition: dca_lbr.c:788
#define AMP_MAX
Definition: dca_lbr.c:32
static const int8_t channel_reorder_nolfe[7][5]
Definition: dca_lbr.c:86
av_cold void ff_dca_lbr_flush(DCALbrDecoder *s)
Definition: dca_lbr.c:1795
static void convert_lpc(float *coeff, const int *codes)
Convert from reflection coefficients to direct form coefficients.
Definition: dca_lbr.c:772
LBRChunkTypes
Definition: dca_lbr.c:48
@ LBR_CHUNK_SCF
Definition: dca_lbr.c:57
@ LBR_CHUNK_TONAL_SCF_GRP_3
Definition: dca_lbr.c:67
@ LBR_CHUNK_ECS
Definition: dca_lbr.c:54
@ LBR_CHUNK_TONAL
Definition: dca_lbr.c:58
@ LBR_CHUNK_TONAL_GRP_4
Definition: dca_lbr.c:62
@ LBR_CHUNK_RES_TS_1_LAST
Definition: dca_lbr.c:75
@ LBR_CHUNK_RES_GRID_LR_LAST
Definition: dca_lbr.c:71
@ LBR_CHUNK_RES_GRID_HR
Definition: dca_lbr.c:72
@ LBR_CHUNK_RESERVED_2
Definition: dca_lbr.c:56
@ LBR_CHUNK_TONAL_SCF_GRP_2
Definition: dca_lbr.c:66
@ LBR_CHUNK_FRAME
Definition: dca_lbr.c:51
@ LBR_CHUNK_EXTENSION
Definition: dca_lbr.c:78
@ LBR_CHUNK_RES_TS_2
Definition: dca_lbr.c:76
@ LBR_CHUNK_TONAL_GRP_3
Definition: dca_lbr.c:61
@ LBR_CHUNK_RES_GRID_LR
Definition: dca_lbr.c:70
@ LBR_CHUNK_RES_GRID_HR_LAST
Definition: dca_lbr.c:73
@ LBR_CHUNK_TONAL_GRP_5
Definition: dca_lbr.c:63
@ LBR_CHUNK_LFE
Definition: dca_lbr.c:53
@ LBR_CHUNK_TONAL_GRP_2
Definition: dca_lbr.c:60
@ LBR_CHUNK_RES_TS_1
Definition: dca_lbr.c:74
@ LBR_CHUNK_TONAL_SCF_GRP_1
Definition: dca_lbr.c:65
@ LBR_CHUNK_RESERVED_1
Definition: dca_lbr.c:55
@ LBR_CHUNK_RES_TS_2_LAST
Definition: dca_lbr.c:77
@ LBR_CHUNK_TONAL_SCF_GRP_5
Definition: dca_lbr.c:69
@ LBR_CHUNK_TONAL_SCF
Definition: dca_lbr.c:64
@ LBR_CHUNK_PAD
Definition: dca_lbr.c:50
@ LBR_CHUNK_TONAL_GRP_1
Definition: dca_lbr.c:59
@ LBR_CHUNK_NULL
Definition: dca_lbr.c:49
@ LBR_CHUNK_FRAME_NO_CSUM
Definition: dca_lbr.c:52
@ LBR_CHUNK_TONAL_SCF_GRP_4
Definition: dca_lbr.c:68
static float lpc_tab[16]
Definition: dca_lbr.c:125
static int parse_ts(DCALbrDecoder *s, int ch1, int ch2, int start_sb, int end_sb, int flag)
Definition: dca_lbr.c:709
static int parse_grid_2(DCALbrDecoder *s, int ch1, int ch2, int start_sb, int end_sb, int flag)
Definition: dca_lbr.c:871
static int parse_scale_factors(DCALbrDecoder *s, uint8_t *scf)
Definition: dca_lbr.c:426
static void base_func_synth(DCALbrDecoder *s, int ch, float *values, int sf)
Synthesise all tones in all groups for the given residual subframe.
Definition: dca_lbr.c:1687
static int parse_lfe_24(DCALbrDecoder *s)
Definition: dca_lbr.c:144
#define DCA_LBR_SUBBANDS
Definition: dca_lbr.h:38
@ DCA_LBR_HEADER_SYNC_ONLY
Definition: dca_lbr.h:45
@ DCA_LBR_HEADER_DECODER_INIT
Definition: dca_lbr.h:46
#define DCA_LBR_CHANNELS
Definition: dca_lbr.h:36
#define DCA_LBR_CHANNELS_TOTAL
Definition: dca_lbr.h:37
#define DCA_LBR_TIME_SAMPLES
Definition: dca_lbr.h:41
#define DCA_LBR_TONES
Definition: dca_lbr.h:39
#define DCA_LBR_TIME_HISTORY
Definition: dca_lbr.h:42
#define DCA_SYNCWORD_LBR
Definition: dca_syncwords.h:30
const float ff_dca_lfe_step_size_24[144]
Definition: dcadata.c:9133
const float ff_dca_rsd_level_5[5]
Definition: dcadata.c:8938
const uint8_t ff_dca_scf_to_grid_2[32]
Definition: dcadata.c:8770
const int8_t ff_dca_lfe_delta_index_24[32]
Definition: dcadata.c:8851
const float ff_dca_rsd_level_8[8]
Definition: dcadata.c:8942
const float ff_dca_rsd_level_2b[2]
Definition: dcadata.c:8930
const uint8_t ff_dca_freq_to_sb[32]
Definition: dcadata.c:8748
const float ff_dca_bank_coeff[10]
Definition: dcadata.c:9184
const float ff_dca_rsd_level_16[16]
Definition: dcadata.c:8946
const float ff_dca_quant_amp[57]
Definition: dcadata.c:9031
const float ff_dca_corr_cf[32][11]
Definition: dcadata.c:8964
const float ff_dca_rsd_level_2a[2]
Definition: dcadata.c:8926
const float ff_dca_lfe_step_size_16[101]
Definition: dcadata.c:9096
const int8_t ff_dca_lfe_delta_index_16[8]
Definition: dcadata.c:8847
const uint8_t ff_dca_grid_1_to_scf[11]
Definition: dcadata.c:8757
const uint16_t ff_dca_fst_amp[44]
Definition: dcadata.c:8734
const uint8_t ff_dca_grid_2_to_scf[3]
Definition: dcadata.c:8761
const float ff_dca_st_coeff[34]
Definition: dcadata.c:9049
const uint8_t ff_dca_rsd_pack_3_in_7[128][3]
Definition: dcadata.c:8891
const float ff_dca_long_window[128]
Definition: dcadata.c:9061
const uint8_t ff_dca_grid_1_weights[12][32]
Definition: dcadata.c:8775
const float ff_dca_rsd_level_3[3]
Definition: dcadata.c:8934
const uint8_t ff_dca_sb_reorder[8][8]
Definition: dcadata.c:8836
const uint16_t ff_dca_avg_g3_freqs[3]
Definition: dcadata.c:8732
const float ff_dca_lfe_iir[5][4]
Definition: dcadata.c:9190
const uint8_t ff_dca_scf_to_grid_1[32]
Definition: dcadata.c:8765
const uint16_t ff_dca_rsd_pack_5_in_8[256]
Definition: dcadata.c:8856
const float ff_dca_synth_env[32]
Definition: dcadata.c:8953
const int8_t ff_dca_ph0_shift[8]
Definition: dcadata.c:8753
VLC ff_dca_vlc_fst_rsd_amp
Definition: dcahuff.c:1254
VLC ff_dca_vlc_rsd_apprx
Definition: dcahuff.c:1255
VLC ff_dca_vlc_rsd
Definition: dcahuff.c:1261
VLC ff_dca_vlc_grid_3
Definition: dcahuff.c:1260
VLC ff_dca_vlc_grid_2
Definition: dcahuff.c:1259
VLC ff_dca_vlc_st_grid
Definition: dcahuff.c:1258
VLC ff_dca_vlc_dph
Definition: dcahuff.c:1253
VLC ff_dca_vlc_tnl_scf
Definition: dcahuff.c:1251
VLC ff_dca_vlc_damp
Definition: dcahuff.c:1252
VLC ff_dca_vlc_avg_g3
Definition: dcahuff.c:1257
VLC ff_dca_vlc_tnl_grp[5]
Definition: dcahuff.c:1250
VLC ff_dca_vlc_rsd_amp
Definition: dcahuff.c:1256
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1893
static AVFrame * frame
double value
Definition: eval.c:98
#define ff_mdct_init
Definition: fft.h:161
#define ff_mdct_end
Definition: fft.h:162
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
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:849
static void skip_bits_long(GetBitContext *s, int n)
Skips the specified number of bits.
Definition: get_bits.h:291
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:677
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
static av_always_inline int get_bitsz(GetBitContext *s, int n)
Read 0-25 bits.
Definition: get_bits.h:415
#define AV_CH_LAYOUT_5POINT0
#define AV_CH_LAYOUT_MONO
#define AV_CH_LAYOUT_2_2
#define AV_CH_LAYOUT_SURROUND
#define AV_CH_LAYOUT_STEREO
@ AV_MATRIX_ENCODING_NONE
#define AV_CH_SIDE_LEFT
#define AV_CH_FRONT_CENTER
#define AV_CH_SIDE_RIGHT
#define AV_CH_LOW_FREQUENCY
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
#define AVERROR(e)
Definition: error.h:43
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:200
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
void av_fast_mallocz(void *ptr, unsigned int *size, size_t min_size)
Allocate and clear a buffer, reusing the given one if large enough.
Definition: mem.c:507
@ AV_SAMPLE_FMT_FLTP
float, planar
Definition: samplefmt.h:69
for(j=16;j >0;--j)
int i
Definition: input.c:407
int ff_side_data_update_matrix_encoding(AVFrame *frame, enum AVMatrixEncoding matrix_encoding)
Add or update AV_FRAME_DATA_MATRIXENCODING side data.
Definition: utils.c:114
av_cold AVFloatDSPContext * avpriv_float_dsp_alloc(int bit_exact)
Allocate a float DSP context.
Definition: float_dsp.c:135
void avpriv_report_missing_feature(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
version
Definition: libkvazaar.c:320
#define M_PI
Definition: mathematics.h:52
#define LOCAL_ALIGNED_32(t, v,...)
Definition: mem_internal.h:136
const char data[16]
Definition: mxf.c:142
mfxU16 profile
Definition: qsvenc.c:45
#define FF_ARRAY_ELEMS(a)
static int shift(int a, int b)
Definition: sonic.c:82
const uint8_t * code
Definition: spdifenc.c:413
main external API structure.
Definition: avcodec.h:536
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1204
int64_t bit_rate
the average bitrate
Definition: avcodec.h:586
int profile
profile
Definition: avcodec.h:1858
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:1747
int sample_rate
samples per second
Definition: avcodec.h:1196
int channels
number of audio channels
Definition: avcodec.h:1197
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:1247
This structure describes decoded (raw) audio or video data.
Definition: frame.h:318
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:384
uint8_t ** extended_data
pointers to the data planes/channels.
Definition: frame.h:365
int request_channel_layout
Converted from avctx.request_channel_layout.
Definition: dcadec.h:64
int lbr_offset
Offset to LBR component from start of substream.
Definition: dca_exss.h:59
int lbr_size
Size of LBR component in extension substream.
Definition: dca_exss.h:60
uint8_t amp[DCA_LBR_CHANNELS]
Per-channel amplitude.
Definition: dca_lbr.h:54
uint8_t phs[DCA_LBR_CHANNELS]
Per-channel phase.
Definition: dca_lbr.h:55
uint8_t f_delt
Difference between original and center frequency.
Definition: dca_lbr.h:51
uint8_t ph_rot
Phase rotation.
Definition: dca_lbr.h:52
uint8_t x_freq
Spectral line offset.
Definition: dca_lbr.h:50
const uint8_t * buffer
Definition: bytestream.h:34
int len
Definition: dca_lbr.c:82
const uint8_t * data
Definition: dca_lbr.c:83
int id
Definition: dca_lbr.c:82
Definition: vlc.h:26
int bits
Definition: vlc.h:27
VLC_TYPE(* table)[2]
code, bits
Definition: vlc.h:28
#define av_freep(p)
#define av_log(a,...)
static volatile int checksum
Definition: adler32.c:30
static uint8_t tmp[11]
Definition: aes_ctr.c:27
static int initialized
if(ret< 0)
Definition: vf_mcdeint.c:282
static const double coeff[2][5]
Definition: vf_owdenoise.c:73
static av_always_inline int diff(const uint32_t a, const uint32_t b)
float delta
static double c[64]