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