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