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
23 #include "libavutil/channel_layout.h"
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 {
34 LBR_FLAG_24_BIT = 0x01,
35 LBR_FLAG_LFE_PRESENT = 0x02,
36 LBR_FLAG_BAND_LIMIT_2_3 = 0x04,
37 LBR_FLAG_BAND_LIMIT_1_2 = 0x08,
38 LBR_FLAG_BAND_LIMIT_1_3 = 0x0c,
39 LBR_FLAG_BAND_LIMIT_1_4 = 0x10,
40 LBR_FLAG_BAND_LIMIT_1_8 = 0x18,
41 LBR_FLAG_BAND_LIMIT_NONE = 0x14,
42 LBR_FLAG_BAND_LIMIT_MASK = 0x1c,
43 LBR_FLAG_DMIX_STEREO = 0x20,
44 LBR_FLAG_DMIX_MULTI_CH = 0x40
45 };
46
47 enum LBRChunkTypes {
48 LBR_CHUNK_NULL = 0x00,
49 LBR_CHUNK_PAD = 0x01,
50 LBR_CHUNK_FRAME = 0x04,
51 LBR_CHUNK_FRAME_NO_CSUM = 0x06,
52 LBR_CHUNK_LFE = 0x0a,
53 LBR_CHUNK_ECS = 0x0b,
54 LBR_CHUNK_RESERVED_1 = 0x0c,
55 LBR_CHUNK_RESERVED_2 = 0x0d,
56 LBR_CHUNK_SCF = 0x0e,
57 LBR_CHUNK_TONAL = 0x10,
58 LBR_CHUNK_TONAL_GRP_1 = 0x11,
59 LBR_CHUNK_TONAL_GRP_2 = 0x12,
60 LBR_CHUNK_TONAL_GRP_3 = 0x13,
61 LBR_CHUNK_TONAL_GRP_4 = 0x14,
62 LBR_CHUNK_TONAL_GRP_5 = 0x15,
63 LBR_CHUNK_TONAL_SCF = 0x16,
64 LBR_CHUNK_TONAL_SCF_GRP_1 = 0x17,
65 LBR_CHUNK_TONAL_SCF_GRP_2 = 0x18,
66 LBR_CHUNK_TONAL_SCF_GRP_3 = 0x19,
67 LBR_CHUNK_TONAL_SCF_GRP_4 = 0x1a,
68 LBR_CHUNK_TONAL_SCF_GRP_5 = 0x1b,
69 LBR_CHUNK_RES_GRID_LR = 0x30,
70 LBR_CHUNK_RES_GRID_LR_LAST = 0x3f,
71 LBR_CHUNK_RES_GRID_HR = 0x40,
72 LBR_CHUNK_RES_GRID_HR_LAST = 0x4f,
73 LBR_CHUNK_RES_TS_1 = 0x50,
74 LBR_CHUNK_RES_TS_1_LAST = 0x5f,
75 LBR_CHUNK_RES_TS_2 = 0x60,
76 LBR_CHUNK_RES_TS_2_LAST = 0x6f,
77 LBR_CHUNK_EXTENSION = 0x7f
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] = {
114 AV_CH_LAYOUT_MONO,
115 AV_CH_LAYOUT_STEREO,
116 AV_CH_LAYOUT_SURROUND,
117 AV_CH_SIDE_LEFT | AV_CH_SIDE_RIGHT,
118 AV_CH_FRONT_CENTER | AV_CH_SIDE_LEFT | AV_CH_SIDE_RIGHT,
119 AV_CH_LAYOUT_2_2,
120 AV_CH_LAYOUT_5POINT0
121 };
122
123 static float cos_tab[256];
124 static float lpc_tab[16];
125
init_tables(void)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
parse_lfe_24(DCALbrDecoder * s)143 static int parse_lfe_24(DCALbrDecoder *s)
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
parse_lfe_16(DCALbrDecoder * s)197 static int parse_lfe_16(DCALbrDecoder *s)
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
parse_lfe_chunk(DCALbrDecoder * s,LBRChunk * chunk)247 static int parse_lfe_chunk(DCALbrDecoder *s, LBRChunk *chunk)
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
parse_vlc(GetBitContext * s,VLC * vlc,int max_depth)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
parse_tonal(DCALbrDecoder * s,int group)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
parse_tonal_chunk(DCALbrDecoder * s,LBRChunk * chunk)362 static int parse_tonal_chunk(DCALbrDecoder *s, LBRChunk *chunk)
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
parse_tonal_group(DCALbrDecoder * s,LBRChunk * chunk)395 static int parse_tonal_group(DCALbrDecoder *s, LBRChunk *chunk)
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 */
ensure_bits(GetBitContext * s,int n)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
parse_scale_factors(DCALbrDecoder * s,uint8_t * scf)425 static int parse_scale_factors(DCALbrDecoder *s, uint8_t *scf)
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
parse_st_code(GetBitContext * s,int min_v)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
504 if (v >= FF_ARRAY_ELEMS(ff_dca_st_coeff))
505 v = 16;
506 return v;
507 }
508
parse_grid_1_chunk(DCALbrDecoder * s,LBRChunk * chunk,int ch1,int ch2)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
parse_grid_1_sec_ch(DCALbrDecoder * s,int ch2)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
parse_grid_3(DCALbrDecoder * s,int ch1,int ch2,int sb,int flag)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
lbr_rand(DCALbrDecoder * s,int sb)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 */
parse_ch(DCALbrDecoder * s,int ch,int sb,int quant_level,int flag)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
parse_ts(DCALbrDecoder * s,int ch1,int ch2,int start_sb,int end_sb,int flag)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 */
convert_lpc(float * coeff,const int * codes)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
parse_lpc(DCALbrDecoder * s,int ch1,int ch2,int start_sb,int end_sb)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
parse_high_res_grid(DCALbrDecoder * s,LBRChunk * chunk,int ch1,int ch2)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
parse_grid_2(DCALbrDecoder * s,int ch1,int ch2,int start_sb,int end_sb,int flag)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
parse_ts1_chunk(DCALbrDecoder * s,LBRChunk * chunk,int ch1,int ch2)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
parse_ts2_chunk(DCALbrDecoder * s,LBRChunk * chunk,int ch1,int ch2)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
init_sample_rate(DCALbrDecoder * s)953 static int init_sample_rate(DCALbrDecoder *s)
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
alloc_sample_buffer(DCALbrDecoder * s)991 static int alloc_sample_buffer(DCALbrDecoder *s)
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
parse_decoder_init(DCALbrDecoder * s,GetByteContext * gb)1015 static int parse_decoder_init(DCALbrDecoder *s, GetByteContext *gb)
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
1077 s->nchannels_total = ff_dca_count_chs_for_mask(s->ch_mask & ~DCA_SPEAKER_PAIR_LFE1);
1078 s->nchannels = FFMIN(s->nchannels_total, DCA_LBR_CHANNELS);
1079
1080 // Setup band limit
1081 switch (s->flags & LBR_FLAG_BAND_LIMIT_MASK) {
1082 case LBR_FLAG_BAND_LIMIT_NONE:
1083 s->band_limit = 0;
1084 break;
1085 case LBR_FLAG_BAND_LIMIT_1_2:
1086 s->band_limit = 1;
1087 break;
1088 case LBR_FLAG_BAND_LIMIT_1_4:
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
1117 s->g3_avg_only_start_sb = s->nsubbands * ff_dca_avg_g3_freqs[s->res_profile] / (s->limited_rate / 2);
1118 if (s->g3_avg_only_start_sb > s->nsubbands)
1119 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;
1151 s->ch_mask = DCA_SPEAKER_PAIR_LR;
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
ff_dca_lbr_parse(DCALbrDecoder * s,uint8_t * data,DCAExssAsset * asset)1167 int ff_dca_lbr_parse(DCALbrDecoder *s, uint8_t *data, DCAExssAsset *asset)
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)) {
1193 case DCA_LBR_HEADER_SYNC_ONLY:
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;
1199 case DCA_LBR_HEADER_DECODER_INIT:
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");
1217 if (s->avctx->err_recognition & AV_EF_EXPLODE)
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:
1225 if (s->avctx->err_recognition & (AV_EF_CRCCHECK | AV_EF_CAREFUL)) {
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");
1234 if (s->avctx->err_recognition & AV_EF_EXPLODE)
1235 return AVERROR_INVALIDDATA;
1236 }
1237 } else {
1238 bytestream2_skip(&gb, 2);
1239 }
1240 break;
1241 case LBR_CHUNK_FRAME_NO_CSUM:
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);
1290 if (s->avctx->err_recognition & AV_EF_EXPLODE)
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
1319 case LBR_CHUNK_TONAL_SCF_GRP_1:
1320 case LBR_CHUNK_TONAL_SCF_GRP_2:
1321 case LBR_CHUNK_TONAL_SCF_GRP_3:
1322 case LBR_CHUNK_TONAL_SCF_GRP_4:
1323 case LBR_CHUNK_TONAL_SCF_GRP_5:
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 */
decode_grid(DCALbrDecoder * s,int ch1,int ch2)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 */
random_ts(DCALbrDecoder * s,int ch1,int ch2)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
predict(float * samples,const float * coeff,int nsamples)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
synth_lpc(DCALbrDecoder * s,int ch1,int ch2,int sb)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
filter_ts(DCALbrDecoder * s,int ch1,int ch2)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 */
decode_part_stereo(DCALbrDecoder * s,int ch1,int ch2)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 */
synth_tones(DCALbrDecoder * s,int ch,float * values,int group,int group_sf,int synth_idx)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 */
base_func_synth(DCALbrDecoder * s,int ch,float * values,int sf)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
transform_channel(DCALbrDecoder * s,int ch,float * output)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
ff_dca_lbr_filter_frame(DCALbrDecoder * s,AVFrame * frame)1734 int ff_dca_lbr_filter_frame(DCALbrDecoder *s, AVFrame *frame)
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;
1745 avctx->profile = FF_PROFILE_DTS_EXPRESS;
1746 avctx->bit_rate = s->bit_rate_scaled;
1747
1748 if (s->flags & LBR_FLAG_LFE_PRESENT) {
1749 avctx->channel_layout |= AV_CH_LOW_FREQUENCY;
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]],
1784 s->lfe_data, ff_dca_lfe_iir,
1785 s->lfe_history, 16 << s->freq_range);
1786 }
1787
1788 if ((ret = ff_side_data_update_matrix_encoding(frame, AV_MATRIX_ENCODING_NONE)) < 0)
1789 return ret;
1790
1791 return 0;
1792 }
1793
ff_dca_lbr_flush(DCALbrDecoder * s)1794 av_cold void ff_dca_lbr_flush(DCALbrDecoder *s)
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
ff_dca_lbr_init(DCALbrDecoder * s)1818 av_cold int ff_dca_lbr_init(DCALbrDecoder *s)
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
ff_dca_lbr_close(DCALbrDecoder * s)1829 av_cold void ff_dca_lbr_close(DCALbrDecoder *s)
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 }
1839