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