FFmpeg
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,
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);
302  if (diff >= FF_ARRAY_ELEMS(ff_dca_fst_amp)) {
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) {
667  code = ff_dca_rsd_pack_5_in_8[get_bits(&s->gb, 8)];
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++)
680  samples[j] = ff_dca_rsd_level_5[ff_dca_rsd_pack_3_in_7[code][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
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 
1119  if (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;
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);
1162  ff_dca_lbr_flush(s);
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");
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:
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");
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);
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]],
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 }
static void parse_grid_3(DCALbrDecoder *s, int ch1, int ch2, int sb, int flag)
Definition: dca_lbr.c:604
int ntones
Circular buffer head position.
Definition: dca_lbr.h:122
VLC ff_dca_vlc_avg_g3
Definition: dcahuff.c:1257
float, planar
Definition: samplefmt.h:69
static int parse_grid_1_sec_ch(DCALbrDecoder *s, int ch2)
Definition: dca_lbr.c:578
const float ff_dca_rsd_level_2b[2]
Definition: dcadata.c:8930
static int parse_tonal_chunk(DCALbrDecoder *s, LBRChunk *chunk)
Definition: dca_lbr.c:363
float window[DCA_LBR_SUBBANDS *4]
Long window for IMDCT.
Definition: dca_lbr.h:113
static void synth_lpc(DCALbrDecoder *s, int ch1, int ch2, int sb)
Definition: dca_lbr.c:1490
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
version
Definition: libkvazaar.c:320
static int shift(int a, int b)
Definition: sonic.c:82
This structure describes decoded (raw) audio or video data.
Definition: frame.h:318
const float ff_dca_st_coeff[34]
Definition: dcadata.c:9049
void(* lbr_bank)(float output[32][4], float **input, const float *coeff, ptrdiff_t ofs, ptrdiff_t len)
Definition: dcadsp.h:88
int bit_rate_scaled
Scaled bit rate.
Definition: dca_lbr.h:66
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
int ff_dca_lbr_parse(DCALbrDecoder *s, uint8_t *data, DCAExssAsset *asset)
Definition: dca_lbr.c:1168
uint8_t grid_2_scf[DCA_LBR_CHANNELS][3][64]
Grid 2 scale factors.
Definition: dca_lbr.h:92
uint32_t ch_pres[DCA_LBR_CHANNELS]
Subband allocation flags.
Definition: dca_lbr.h:89
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:200
int64_t bit_rate
the average bitrate
Definition: avcodec.h:586
const int8_t ff_dca_ph0_shift[8]
Definition: dcadata.c:8753
#define AV_CH_LAYOUT_SURROUND
#define DCA_LBR_CHANNELS_TOTAL
Definition: dca_lbr.h:37
int max_mono_subband
Subband index where mono encoding ends.
Definition: dca_lbr.h:78
static void skip_bits_long(GetBitContext *s, int n)
Skips the specified number of bits.
Definition: get_bits.h:291
unsigned int ts_size
Time sample buffer size.
Definition: dca_lbr.h:110
const uint8_t ff_dca_scf_to_grid_1[32]
Definition: dcadata.c:8765
static float cos_tab[256]
Definition: dca_lbr.c:124
static int parse_st_code(GetBitContext *s, int min_v)
Definition: dca_lbr.c:496
int nchannels_total
Total number of fullband channels.
Definition: dca_lbr.h:69
int freq_range
Frequency range of LBR audio.
Definition: dca_lbr.h:70
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:36
const float ff_dca_lfe_step_size_24[144]
Definition: dcadata.c:9133
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:137
#define FF_PROFILE_DTS_EXPRESS
Definition: avcodec.h:1885
uint8_t x_freq
Spectral line offset.
Definition: dca_lbr.h:50
const uint16_t ff_dca_rsd_pack_5_in_8[256]
Definition: dcadata.c:8856
static int parse_lfe_16(DCALbrDecoder *s)
Definition: dca_lbr.c:198
#define FF_ARRAY_ELEMS(a)
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:1747
#define AV_CH_LAYOUT_STEREO
int bit_rate_orig
Original bit rate.
Definition: dca_lbr.h:65
VLC ff_dca_vlc_grid_3
Definition: dcahuff.c:1260
static int init_sample_rate(DCALbrDecoder *s)
Definition: dca_lbr.c:954
int profile
profile
Definition: avcodec.h:1858
const float ff_dca_quant_amp[57]
Definition: dcadata.c:9031
#define AV_CH_LAYOUT_5POINT0
static int parse_grid_1_chunk(DCALbrDecoder *s, LBRChunk *chunk, int ch1, int ch2)
Definition: dca_lbr.c:510
float * ts_buffer
Time sample buffer base.
Definition: dca_lbr.h:109
const uint8_t ff_dca_freq_ranges[16]
Definition: dca.c:46
float sb_scf[DCA_LBR_SUBBANDS]
Subband randomization scale factors.
Definition: dca_lbr.h:105
float lfe_scale
Scale factor of LFE samples before IIR filter.
Definition: dca_lbr.h:117
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
#define av_ceil_log2
Definition: common.h:119
VLC ff_dca_vlc_st_grid
Definition: dcahuff.c:1258
static int ensure_bits(GetBitContext *s, int n)
Check point to ensure that enough bits are left.
Definition: dca_lbr.c:414
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1204
uint8_t
#define av_cold
Definition: attributes.h:88
float delta
static void filter_ts(DCALbrDecoder *s, int ch1, int ch2)
Definition: dca_lbr.c:1512
int ch_mask
LBR speaker mask.
Definition: dca_lbr.h:63
#define f(width, name)
Definition: cbs_vp9.c:255
#define AMP_MAX
Definition: dca_lbr.c:32
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
uint8_t part_stereo_pres
Partial stereo coefficients presence flags.
Definition: dca_lbr.h:101
#define LOCAL_ALIGNED_32(t, v,...)
Definition: mem_internal.h:136
filter_frame For filters that do not use the this method is called when a frame is pushed to the filter s input It can be called at any time except in a reentrant way If the input frame is enough to produce output
GLsizei GLboolean const GLfloat * value
Definition: opengl_enc.c:108
static void random_ts(DCALbrDecoder *s, int ch1, int ch2)
Fill unallocated subbands with randomness.
Definition: dca_lbr.c:1442
#define AV_CH_LOW_FREQUENCY
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
DCADSPContext * dcadsp
Definition: dca_lbr.h:126
uint8_t phs[DCA_LBR_CHANNELS]
Per-channel phase.
Definition: dca_lbr.h:55
static int parse_lfe_chunk(DCALbrDecoder *s, LBRChunk *chunk)
Definition: dca_lbr.c:248
#define av_clip
Definition: common.h:122
const uint8_t * buffer
Definition: bytestream.h:34
static void transform_channel(DCALbrDecoder *s, int ch, float *output)
Definition: dca_lbr.c:1701
int nchannels
Number of fullband channels to decode.
Definition: dca_lbr.h:68
#define av_log(a,...)
int sample_rate
Sample rate of LBR audio.
Definition: dca_lbr.h:62
static av_always_inline int bytestream2_get_bytes_left(GetByteContext *g)
Definition: bytestream.h:158
#define U(x)
Definition: vp56_arith.h:37
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:849
static float lbr_rand(DCALbrDecoder *s, int sb)
Definition: dca_lbr.c:626
const int8_t ff_dca_lfe_delta_index_16[8]
Definition: dcadata.c:8847
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
DCALbrTone tones[DCA_LBR_TONES]
Circular buffer of tones.
Definition: dca_lbr.h:121
av_cold AVFloatDSPContext * avpriv_float_dsp_alloc(int bit_exact)
Allocate a float DSP context.
Definition: float_dsp.c:135
uint8_t tonal_scf[6]
Tonal scale factors.
Definition: dca_lbr.h:119
static __device__ float fabs(float a)
Definition: cuda_runtime.h:182
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
Definition: bytestream.h:168
uint8_t ph_rot
Phase rotation.
Definition: dca_lbr.h:52
int warned
Flags for warning suppression.
Definition: dca_lbr.h:82
const float ff_dca_rsd_level_5[5]
Definition: dcadata.c:8938
static av_cold void init_tables(void)
Definition: dca_lbr.c:127
float lfe_history[5][2]
LFE IIR filter history.
Definition: dca_lbr.h:116
const uint32_t ff_dca_sampling_freqs[16]
Definition: dca.c:41
uint8_t part_stereo[DCA_LBR_CHANNELS][DCA_LBR_SUBBANDS/4][5]
Partial stereo coefficients.
Definition: dca_lbr.h:100
void(* imdct_calc)(struct FFTContext *s, FFTSample *output, const FFTSample *input)
Definition: fft.h:102
int lbr_offset
Offset to LBR component from start of substream.
Definition: dca_exss.h:59
#define ff_mdct_init
Definition: fft.h:161
uint8_t amp[DCA_LBR_CHANNELS]
Per-channel amplitude.
Definition: dca_lbr.h:54
int id
Definition: dca_lbr.c:82
#define DCA_SPEAKER_LAYOUT_STEREO
Definition: dca.h:123
GLsizei count
Definition: opengl_enc.c:108
static int parse_tonal_group(DCALbrDecoder *s, LBRChunk *chunk)
Definition: dca_lbr.c:396
Definition: vlc.h:26
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:1247
uint16_t tonal_bounds[5][32][2]
Per-group per-subframe start/end positions of tones.
Definition: dca_lbr.h:120
#define DCA_LBR_CHANNELS
Definition: dca_lbr.h:36
#define AV_CH_LAYOUT_2_2
static int alloc_sample_buffer(DCALbrDecoder *s)
Definition: dca_lbr.c:992
const float ff_dca_synth_env[32]
Definition: dcadata.c:8953
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
audio channel layout utility functions
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
Definition: avcodec.h:1645
const uint8_t * data
Definition: dca_lbr.c:83
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
#define FFMIN(a, b)
Definition: common.h:105
const float ff_dca_rsd_level_8[8]
Definition: dcadata.c:8942
const uint8_t ff_dca_scf_to_grid_2[32]
Definition: dcadata.c:8770
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 values
const uint16_t ff_dca_avg_g3_freqs[3]
Definition: dcadata.c:8732
int lbr_rand
Seed for subband randomization.
Definition: dca_lbr.h:81
const float ff_dca_rsd_level_16[16]
Definition: dcadata.c:8946
uint8_t sec_ch_sbms[DCA_LBR_CHANNELS/2][DCA_LBR_SUBBANDS]
Right channel inversion or mid/side decoding flags.
Definition: dca_lbr.h:87
int8_t grid_3_avg[DCA_LBR_CHANNELS][DCA_LBR_SUBBANDS-4]
Grid 3 average values.
Definition: dca_lbr.h:94
static int initialized
int nsubbands
Number of encoded subbands.
Definition: dca_lbr.h:75
int len
Definition: dca_lbr.c:82
av_cold void ff_dca_lbr_flush(DCALbrDecoder *s)
Definition: dca_lbr.c:1795
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
GetBitContext gb
Definition: dca_lbr.h:60
#define DCA_SYNCWORD_LBR
Definition: dca_syncwords.h:30
#define s(width, name)
Definition: cbs_vp9.c:257
av_cold void ff_dca_lbr_close(DCALbrDecoder *s)
Definition: dca_lbr.c:1830
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
#define DCA_LBR_TONES
Definition: dca_lbr.h:39
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: avcodec.h:1656
static int parse_lpc(DCALbrDecoder *s, int ch1, int ch2, int start_sb, int end_sb)
Definition: dca_lbr.c:788
static int parse_ts(DCALbrDecoder *s, int ch1, int ch2, int start_sb, int end_sb, int flag)
Definition: dca_lbr.c:709
#define AV_CH_FRONT_CENTER
AVCodecContext * avctx
Definition: dca_lbr.h:59
uint8_t grid_1_scf[DCA_LBR_CHANNELS][12][8]
Grid 1 scale factors.
Definition: dca_lbr.h:91
static volatile int checksum
Definition: adler32.c:30
VLC ff_dca_vlc_grid_2
Definition: dcahuff.c:1259
LBRChunkTypes
Definition: dca_lbr.c:48
const float ff_dca_bank_coeff[10]
Definition: dcadata.c:9184
VLC ff_dca_vlc_tnl_grp[5]
Definition: dcahuff.c:1250
static const uint8_t channel_counts[7]
Definition: dca_lbr.c:110
int ff_dca_lbr_filter_frame(DCALbrDecoder *s, AVFrame *frame)
Definition: dca_lbr.c:1735
static void predict(float *samples, const float *coeff, int nsamples)
Definition: dca_lbr.c:1478
static int parse_high_res_grid(DCALbrDecoder *s, LBRChunk *chunk, int ch1, int ch2)
Definition: dca_lbr.c:809
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
int bits
Definition: vlc.h:27
if(ret)
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
static int parse_ts2_chunk(DCALbrDecoder *s, LBRChunk *chunk, int ch1, int ch2)
Definition: dca_lbr.c:931
LBRFlags
Definition: dca_lbr.c:34
float lpc_coeff[2][DCA_LBR_CHANNELS][3][2][8]
Predictor coefficients.
Definition: dca_lbr.h:103
static const int8_t channel_reorder_lfe[7][5]
Definition: dca_lbr.c:96
const float ff_dca_corr_cf[32][11]
Definition: dcadata.c:8964
float history[DCA_LBR_CHANNELS][DCA_LBR_SUBBANDS *4]
IMDCT history.
Definition: dca_lbr.h:112
const float ff_dca_lfe_iir[5][4]
Definition: dcadata.c:9190
int8_t grid_3_scf[DCA_LBR_CHANNELS][DCA_LBR_SUBBANDS-4][8]
Grid 3 scale factors.
Definition: dca_lbr.h:95
int sample_rate
samples per second
Definition: avcodec.h:1196
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:677
int band_limit
Band limit factor.
Definition: dca_lbr.h:71
main external API structure.
Definition: avcodec.h:536
static int parse_ts1_chunk(DCALbrDecoder *s, LBRChunk *chunk, int ch1, int ch2)
Definition: dca_lbr.c:913
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1893
int lbr_size
Size of LBR component in extension substream.
Definition: dca_exss.h:60
Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2]...the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so...,+,-,+,-,+,+,-,+,-,+,...hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32-hcoeff[1]-hcoeff[2]-...a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2}an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||.........intra?||||:Block01:yes no||||:Block02:.................||||:Block03::y DC::ref index:||||:Block04::cb DC::motion x:||||.........:cr DC::motion y:||||.................|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------------------------------|||Y subbands||Cb subbands||Cr subbands||||------||------||------|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||------||------||------||||------||------||------|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||------||------||------||||------||------||------|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||------||------||------||||------||------||------|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------------------------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction------------|\Dequantization-------------------\||Reference frames|\IDWT|--------------|Motion\|||Frame 0||Frame 1||Compensation.OBMC v-------|--------------|--------------.\------> Frame n output Frame Frame<----------------------------------/|...|-------------------Range Coder:============Binary Range Coder:-------------------The implemented range coder is an adapted version based upon"Range encoding: an algorithm for removing redundancy from a digitised message."by G.N.N.Martin.The symbols encoded by the Snow range coder are bits(0|1).The associated probabilities are not fix but change depending on the symbol mix seen so far.bit seen|new state---------+-----------------------------------------------0|256-state_transition_table[256-old_state];1|state_transition_table[old_state];state_transition_table={0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:-------------------------FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1.the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled left
Definition: snow.txt:206
FFTContext imdct
Definition: dca_lbr.h:124
const uint8_t ff_dca_freq_to_sb[32]
Definition: dcadata.c:8748
#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 int parse_tonal(DCALbrDecoder *s, int group)
Definition: dca_lbr.c:281
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
static const uint16_t channel_layouts[7]
Definition: dca_lbr.c:114
int res_profile
Resolution profile.
Definition: dca_lbr.h:74
static float lpc_tab[16]
Definition: dca_lbr.c:125
const float ff_dca_long_window[128]
Definition: dcadata.c:9061
static void convert_lpc(float *coeff, const int *codes)
Convert from reflection coefficients to direct form coefficients.
Definition: dca_lbr.c:772
uint8_t sb_indices[DCA_LBR_SUBBANDS]
Subband reordering indices.
Definition: dca_lbr.h:85
#define AV_EF_CRCCHECK
Verify checksums embedded in the bitstream (could be of either encoded or decoded data...
Definition: avcodec.h:1653
VLC ff_dca_vlc_tnl_scf
Definition: dcahuff.c:1251
VLC ff_dca_vlc_rsd_amp
Definition: dcahuff.c:1256
const uint8_t ff_dca_rsd_pack_3_in_7[128][3]
Definition: dcadata.c:8891
mfxU16 profile
Definition: qsvenc.c:45
int limited_range
Band limited frequency range.
Definition: dca_lbr.h:73
static int parse_lfe_24(DCALbrDecoder *s)
Definition: dca_lbr.c:144
void avpriv_report_missing_feature(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some it can consider them to be part of the FIFO and delay acknowledging a status change accordingly Example code
const float ff_dca_rsd_level_3[3]
Definition: dcadata.c:8934
static int ff_dca_count_chs_for_mask(unsigned int mask)
Return number of individual channels in DCASpeakerPair mask.
Definition: dca.h:159
VLC ff_dca_vlc_dph
Definition: dcahuff.c:1253
#define AV_CH_SIDE_RIGHT
uint8_t f_delt
Difference between original and center frequency.
Definition: dca_lbr.h:51
#define DCA_LBR_TIME_HISTORY
Definition: dca_lbr.h:42
int framenum
Lower 5 bits of current frame number.
Definition: dca_lbr.h:80
int limited_rate
Band limited sample rate.
Definition: dca_lbr.h:72
uint8_t sec_ch_lrms[DCA_LBR_CHANNELS/2][DCA_LBR_SUBBANDS]
Flags indicating if left/right channel are swapped.
Definition: dca_lbr.h:88
const uint8_t ff_dca_grid_1_to_scf[11]
Definition: dcadata.c:8757
float lfe_data[64]
Decimated LFE samples.
Definition: dca_lbr.h:115
#define DCA_LBR_TIME_SAMPLES
Definition: dca_lbr.h:41
uint32_t grid_3_pres[DCA_LBR_CHANNELS]
Grid 3 scale factors presence flags.
Definition: dca_lbr.h:96
#define ff_mdct_end
Definition: fft.h:162
#define flag(name)
Definition: cbs_av1.c:553
const float ff_dca_rsd_level_2a[2]
Definition: dcadata.c:8926
const uint16_t ff_dca_fst_amp[44]
Definition: dcadata.c:8734
const float ff_dca_lfe_step_size_16[101]
Definition: dcadata.c:9096
#define DCA_LBR_SUBBANDS
Definition: dca_lbr.h:38
void(* vector_fmul_add)(float *dst, const float *src0, const float *src1, const float *src2, int len)
Calculate the entry wise product of two vectors of floats, add a third vector of floats and store the...
Definition: float_dsp.h:137
int request_channel_layout
Converted from avctx.request_channel_layout.
Definition: dcadec.h:64
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_vlc(GetBitContext *s, VLC *vlc, int max_depth)
Definition: dca_lbr.c:272
float * time_samples[DCA_LBR_CHANNELS][DCA_LBR_SUBBANDS]
Time samples.
Definition: dca_lbr.h:107
VLC ff_dca_vlc_fst_rsd_amp
Definition: dcahuff.c:1254
void * priv_data
Definition: avcodec.h:563
static av_always_inline int diff(const uint32_t a, const uint32_t b)
AVFloatDSPContext * fdsp
Definition: dca_lbr.h:125
int channels
number of audio channels
Definition: avcodec.h:1197
VLC_TYPE(* table)[2]
code, bits
Definition: vlc.h:28
static int parse_scale_factors(DCALbrDecoder *s, uint8_t *scf)
Definition: dca_lbr.c:426
VLC ff_dca_vlc_rsd_apprx
Definition: dcahuff.c:1255
static const double coeff[2][5]
Definition: vf_owdenoise.c:73
const uint8_t ff_dca_sb_reorder[8][8]
Definition: dcadata.c:8836
static const int8_t channel_reorder_nolfe[7][5]
Definition: dca_lbr.c:86
static void decode_part_stereo(DCALbrDecoder *s, int ch1, int ch2)
Modulate by interpolated partial stereo coefficients.
Definition: dca_lbr.c:1597
and forward the result(frame or status change) to the corresponding input.If nothing is possible
Filter the word “frame” indicates either a video frame or a group of audio samples
int flags
Flags for LBR decoder initialization.
Definition: dca_lbr.h:64
#define av_freep(p)
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
#define M_PI
Definition: mathematics.h:52
av_cold int ff_dca_lbr_init(DCALbrDecoder *s)
Definition: dca_lbr.c:1819
#define AV_CH_SIDE_LEFT
uint8_t quant_levels[DCA_LBR_CHANNELS/2][DCA_LBR_SUBBANDS]
Quantization levels.
Definition: dca_lbr.h:84
const int8_t ff_dca_lfe_delta_index_24[32]
Definition: dcadata.c:8851
static const uint8_t lfe_index[7]
Definition: dca_lbr.c:106
int min_mono_subband
Subband index where mono encoding starts.
Definition: dca_lbr.h:77
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
const uint8_t ff_dca_grid_2_to_scf[3]
Definition: dcadata.c:8761
uint8_t ** extended_data
pointers to the data planes/channels.
Definition: frame.h:365
#define AV_CH_LAYOUT_MONO
void(* lfe_iir)(float *output, const float *input, const float iir[5][4], float hist[5][2], ptrdiff_t factor)
Definition: dcadsp.h:91
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:384
int g3_avg_only_start_sb
Subband index where grid 3 scale factors end.
Definition: dca_lbr.h:76
for(j=16;j >0;--j)
static int parse_decoder_init(DCALbrDecoder *s, GetByteContext *gb)
Definition: dca_lbr.c:1016
VLC ff_dca_vlc_rsd
Definition: dcahuff.c:1261
int i
Definition: input.c:407
static av_always_inline int get_bitsz(GetBitContext *s, int n)
Read 0-25 bits.
Definition: get_bits.h:415
uint8_t high_res_scf[DCA_LBR_CHANNELS][DCA_LBR_SUBBANDS][8]
High-frequency resolution scale factors.
Definition: dca_lbr.h:98
trying all byte sequences megabyte in length and selecting the best looking sequence will yield cases to try But a word about which is also called distortion Distortion can be quantified by almost any quality measurement one chooses the sum of squared differences is used but more complex methods that consider psychovisual effects can be used as well It makes no difference in this discussion First step
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
VLC ff_dca_vlc_damp
Definition: dcahuff.c:1252
const uint8_t ff_dca_grid_1_weights[12][32]
Definition: dcadata.c:8775
void(* vector_fmul_reverse)(float *dst, const float *src0, const float *src1, int len)
Calculate the entry wise product of two vectors of floats, and store the result in a vector of floats...
Definition: float_dsp.h:154
static uint8_t tmp[11]
Definition: aes_ctr.c:27