FFmpeg coverage

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