FFmpeg coverage

Directory: ../../../ffmpeg/
File: src/libavcodec/dca_lbr.c
Date: 2024-04-24 02:45:42
Exec Total Coverage
Lines: 15 1019 1.5%
Functions: 3 40 7.5%
Branches: 3 686 0.4%
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.h"
25 #include "libavutil/mem_internal.h"
26
27 #include "dcadec.h"
28 #include "dcadata.h"
29 #include "dcahuff.h"
30 #include "dca_syncwords.h"
31 #include "bytestream.h"
32 #include "decode.h"
33
34 #define AMP_MAX 56
35
36 enum LBRFlags {
37 LBR_FLAG_24_BIT = 0x01,
38 LBR_FLAG_LFE_PRESENT = 0x02,
39 LBR_FLAG_BAND_LIMIT_2_3 = 0x04,
40 LBR_FLAG_BAND_LIMIT_1_2 = 0x08,
41 LBR_FLAG_BAND_LIMIT_1_3 = 0x0c,
42 LBR_FLAG_BAND_LIMIT_1_4 = 0x10,
43 LBR_FLAG_BAND_LIMIT_1_8 = 0x18,
44 LBR_FLAG_BAND_LIMIT_NONE = 0x14,
45 LBR_FLAG_BAND_LIMIT_MASK = 0x1c,
46 LBR_FLAG_DMIX_STEREO = 0x20,
47 LBR_FLAG_DMIX_MULTI_CH = 0x40
48 };
49
50 enum LBRChunkTypes {
51 LBR_CHUNK_NULL = 0x00,
52 LBR_CHUNK_PAD = 0x01,
53 LBR_CHUNK_FRAME = 0x04,
54 LBR_CHUNK_FRAME_NO_CSUM = 0x06,
55 LBR_CHUNK_LFE = 0x0a,
56 LBR_CHUNK_ECS = 0x0b,
57 LBR_CHUNK_RESERVED_1 = 0x0c,
58 LBR_CHUNK_RESERVED_2 = 0x0d,
59 LBR_CHUNK_SCF = 0x0e,
60 LBR_CHUNK_TONAL = 0x10,
61 LBR_CHUNK_TONAL_GRP_1 = 0x11,
62 LBR_CHUNK_TONAL_GRP_2 = 0x12,
63 LBR_CHUNK_TONAL_GRP_3 = 0x13,
64 LBR_CHUNK_TONAL_GRP_4 = 0x14,
65 LBR_CHUNK_TONAL_GRP_5 = 0x15,
66 LBR_CHUNK_TONAL_SCF = 0x16,
67 LBR_CHUNK_TONAL_SCF_GRP_1 = 0x17,
68 LBR_CHUNK_TONAL_SCF_GRP_2 = 0x18,
69 LBR_CHUNK_TONAL_SCF_GRP_3 = 0x19,
70 LBR_CHUNK_TONAL_SCF_GRP_4 = 0x1a,
71 LBR_CHUNK_TONAL_SCF_GRP_5 = 0x1b,
72 LBR_CHUNK_RES_GRID_LR = 0x30,
73 LBR_CHUNK_RES_GRID_LR_LAST = 0x3f,
74 LBR_CHUNK_RES_GRID_HR = 0x40,
75 LBR_CHUNK_RES_GRID_HR_LAST = 0x4f,
76 LBR_CHUNK_RES_TS_1 = 0x50,
77 LBR_CHUNK_RES_TS_1_LAST = 0x5f,
78 LBR_CHUNK_RES_TS_2 = 0x60,
79 LBR_CHUNK_RES_TS_2_LAST = 0x6f,
80 LBR_CHUNK_EXTENSION = 0x7f
81 };
82
83 typedef struct LBRChunk {
84 int id, len;
85 const uint8_t *data;
86 } LBRChunk;
87
88 static const int8_t channel_reorder_nolfe[7][5] = {
89 { 0, -1, -1, -1, -1 }, // C
90 { 0, 1, -1, -1, -1 }, // LR
91 { 0, 1, 2, -1, -1 }, // LR C
92 { 0, 1, -1, -1, -1 }, // LsRs
93 { 1, 2, 0, -1, -1 }, // LsRs C
94 { 0, 1, 2, 3, -1 }, // LR LsRs
95 { 0, 1, 3, 4, 2 }, // LR LsRs C
96 };
97
98 static const int8_t channel_reorder_lfe[7][5] = {
99 { 0, -1, -1, -1, -1 }, // C
100 { 0, 1, -1, -1, -1 }, // LR
101 { 0, 1, 2, -1, -1 }, // LR C
102 { 1, 2, -1, -1, -1 }, // LsRs
103 { 2, 3, 0, -1, -1 }, // LsRs C
104 { 0, 1, 3, 4, -1 }, // LR LsRs
105 { 0, 1, 4, 5, 2 }, // LR LsRs C
106 };
107
108 static const uint8_t lfe_index[7] = {
109 1, 2, 3, 0, 1, 2, 3
110 };
111
112 static const uint16_t channel_layouts[7] = {
113 AV_CH_LAYOUT_MONO,
114 AV_CH_LAYOUT_STEREO,
115 AV_CH_LAYOUT_SURROUND,
116 AV_CH_SIDE_LEFT | AV_CH_SIDE_RIGHT,
117 AV_CH_FRONT_CENTER | AV_CH_SIDE_LEFT | AV_CH_SIDE_RIGHT,
118 AV_CH_LAYOUT_2_2,
119 AV_CH_LAYOUT_5POINT0
120 };
121
122 static float cos_tab[256];
123 static const float lpc_tab[16] = {
124 /* lpc_tab[i] = sin((i - 8) * (M_PI / ((i < 8) ? 17 : 15))) */
125 -0.995734176295034521871191178905, -0.961825643172819070408796290732,
126 -0.895163291355062322067016499754, -0.798017227280239503332805112796,
127 -0.673695643646557211712691912426, -0.526432162877355800244607799141,
128 -0.361241666187152948744714596184, -0.183749517816570331574408839621,
129 0.0, 0.207911690817759337101742284405,
130 0.406736643075800207753985990341, 0.587785252292473129168705954639,
131 0.743144825477394235014697048974, 0.866025403784438646763723170753,
132 0.951056516295153572116439333379, 0.994521895368273336922691944981
133 };
134
135 54 av_cold void ff_dca_lbr_init_tables(void)
136 {
137 int i;
138
139
2/2
✓ Branch 0 taken 13824 times.
✓ Branch 1 taken 54 times.
 13878 for (i = 0; i < 256; i++)
140 13824 cos_tab[i] = cos(M_PI * i / 128);
141 54 }
142
143 ✗ static int parse_lfe_24(DCALbrDecoder *s)
144 {
145 ✗ int step_max = FF_ARRAY_ELEMS(ff_dca_lfe_step_size_24) - 1;
146 int i, ps, si, code, step_i;
147 float step, value, delta;
148
149 ✗ ps = get_bits(&s->gb, 24);
150 ✗ si = ps >> 23;
151
152 ✗ value = (((ps & 0x7fffff) ^ -si) + si) * (1.0f / 0x7fffff);
153
154 ✗ step_i = get_bits(&s->gb, 8);
155 ✗ if (step_i > step_max) {
156 ✗ av_log(s->avctx, AV_LOG_ERROR, "Invalid LFE step size index\n");
157 ✗ return AVERROR_INVALIDDATA;
158 }
159
160 ✗ step = ff_dca_lfe_step_size_24[step_i];
161
162 ✗ for (i = 0; i < 64; i++) {
163 ✗ code = get_bits(&s->gb, 6);
164
165 ✗ delta = step * 0.03125f;
166 ✗ if (code & 16)
167 ✗ delta += step;
168 ✗ if (code & 8)
169 ✗ delta += step * 0.5f;
170 ✗ if (code & 4)
171 ✗ delta += step * 0.25f;
172 ✗ if (code & 2)
173 ✗ delta += step * 0.125f;
174 ✗ if (code & 1)
175 ✗ delta += step * 0.0625f;
176
177 ✗ if (code & 32) {
178 ✗ value -= delta;
179 ✗ if (value < -3.0f)
180 ✗ value = -3.0f;
181 } else {
182 ✗ value += delta;
183 ✗ if (value > 3.0f)
184 ✗ value = 3.0f;
185 }
186
187 ✗ step_i += ff_dca_lfe_delta_index_24[code & 31];
188 ✗ step_i = av_clip(step_i, 0, step_max);
189
190 ✗ step = ff_dca_lfe_step_size_24[step_i];
191 ✗ s->lfe_data[i] = value * s->lfe_scale;
192 }
193
194 ✗ return 0;
195 }
196
197 ✗ static int parse_lfe_16(DCALbrDecoder *s)
198 {
199 ✗ int step_max = FF_ARRAY_ELEMS(ff_dca_lfe_step_size_16) - 1;
200 int i, ps, si, code, step_i;
201 float step, value, delta;
202
203 ✗ ps = get_bits(&s->gb, 16);
204 ✗ si = ps >> 15;
205
206 ✗ value = (((ps & 0x7fff) ^ -si) + si) * (1.0f / 0x7fff);
207
208 ✗ step_i = get_bits(&s->gb, 8);
209 ✗ if (step_i > step_max) {
210 ✗ av_log(s->avctx, AV_LOG_ERROR, "Invalid LFE step size index\n");
211 ✗ return AVERROR_INVALIDDATA;
212 }
213
214 ✗ step = ff_dca_lfe_step_size_16[step_i];
215
216 ✗ for (i = 0; i < 64; i++) {
217 ✗ code = get_bits(&s->gb, 4);
218
219 ✗ delta = step * 0.125f;
220 ✗ if (code & 4)
221 ✗ delta += step;
222 ✗ if (code & 2)
223 ✗ delta += step * 0.5f;
224 ✗ if (code & 1)
225 ✗ delta += step * 0.25f;
226
227 ✗ if (code & 8) {
228 ✗ value -= delta;
229 ✗ if (value < -3.0f)
230 ✗ value = -3.0f;
231 } else {
232 ✗ value += delta;
233 ✗ if (value > 3.0f)
234 ✗ value = 3.0f;
235 }
236
237 ✗ step_i += ff_dca_lfe_delta_index_16[code & 7];
238 ✗ step_i = av_clip(step_i, 0, step_max);
239
240 ✗ step = ff_dca_lfe_step_size_16[step_i];
241 ✗ s->lfe_data[i] = value * s->lfe_scale;
242 }
243
244 ✗ return 0;
245 }
246
247 ✗ static int parse_lfe_chunk(DCALbrDecoder *s, LBRChunk *chunk)
248 {
249 int ret;
250
251 ✗ if (!(s->flags & LBR_FLAG_LFE_PRESENT))
252 ✗ return 0;
253
254 ✗ if (!chunk->len)
255 ✗ return 0;
256
257 ✗ ret = init_get_bits8(&s->gb, chunk->data, chunk->len);
258 ✗ if (ret < 0)
259 ✗ return ret;
260
261 // Determine bit depth from chunk size
262 ✗ if (chunk->len >= 52)
263 ✗ return parse_lfe_24(s);
264 ✗ if (chunk->len >= 35)
265 ✗ return parse_lfe_16(s);
266
267 ✗ av_log(s->avctx, AV_LOG_ERROR, "LFE chunk too short\n");
268 ✗ return AVERROR_INVALIDDATA;
269 }
270
271 ✗ static inline int parse_vlc(GetBitContext *s, const VLC *vlc,
272 int nb_bits, int max_depth)
273 {
274 ✗ int v = get_vlc2(s, vlc->table, nb_bits, max_depth);
275 ✗ if (v >= 0)
276 ✗ return v;
277 // Rare value
278 ✗ return get_bits(s, get_bits(s, 3) + 1);
279 }
280
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], DCA_TNL_GRP_VLC_BITS, 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, DCA_TNL_SCF_VLC_BITS, 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, DCA_DAMP_VLC_BITS, 1);
331 ✗ phs[ch] = phs[main_ch] - parse_vlc(&s->gb, &ff_dca_vlc_dph, DCA_DPH_VLC_BITS, 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
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
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 */
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
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, DCA_FST_RSD_VLC_BITS, 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, DCA_RSD_APPRX_VLC_BITS, 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, DCA_RSD_AMP_VLC_BITS, 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
496 ✗ static int parse_st_code(GetBitContext *s, int min_v)
497 {
498 ✗ unsigned int v = parse_vlc(s, &ff_dca_vlc_st_grid, DCA_ST_GRID_VLC_BITS, 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
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, DCA_AVG_G3_VLC_BITS, 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, DCA_AVG_G3_VLC_BITS, 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
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, DCA_AVG_G3_VLC_BITS, 2) - 16;
598 }
599 }
600
601 ✗ return 0;
602 }
603
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, DCA_GRID_VLC_BITS, 2) - 16;
619 }
620
621 // Flag scale factors for this subband parsed
622 ✗ s->grid_3_pres[ch] |= 1U << sb;
623 }
624 }
625
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 */
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
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 */
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
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
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
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, DCA_GRID_VLC_BITS, 2);
902 }
903 } else {
904 ✗ memset(g2_scf, 0, 8);
905 }
906 }
907 }
908 }
909
910 ✗ return 0;
911 }
912
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
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
954 ✗ static int init_sample_rate(DCALbrDecoder *s)
955 {
956 ✗ double scale = (-1.0 / (1 << 17)) * sqrt(1 << (2 - s->limited_range));
957 ✗ float scale_t = scale;
958 ✗ int i, br_per_ch = s->bit_rate_scaled / s->nchannels_total;
959 int ret;
960
961 ✗ av_tx_uninit(&s->imdct);
962
963 ✗ ret = av_tx_init(&s->imdct, &s->imdct_fn, AV_TX_FLOAT_MDCT, 1,
964 ✗ 1 << (s->freq_range + 5), &scale_t, AV_TX_FULL_IMDCT);
965 ✗ if (ret < 0)
966 ✗ return ret;
967
968 ✗ for (i = 0; i < 32 << s->freq_range; i++)
969 ✗ s->window[i] = ff_dca_long_window[i << (2 - s->freq_range)];
970
971 ✗ if (br_per_ch < 14000)
972 ✗ scale = 0.85;
973 ✗ else if (br_per_ch < 32000)
974 ✗ scale = (br_per_ch - 14000) * (1.0 / 120000) + 0.85;
975 else
976 ✗ scale = 1.0;
977
978 ✗ scale *= 1.0 / INT_MAX;
979
980 ✗ for (i = 0; i < s->nsubbands; i++) {
981 ✗ if (i < 2)
982 ✗ s->sb_scf[i] = 0; // The first two subbands are always zero
983 ✗ else if (i < 5)
984 ✗ s->sb_scf[i] = (i - 1) * 0.25 * 0.785 * scale;
985 else
986 ✗ s->sb_scf[i] = 0.785 * scale;
987 }
988
989 ✗ s->lfe_scale = (16 << s->freq_range) * 0.0000078265894;
990
991 ✗ return 0;
992 }
993
994 ✗ static int alloc_sample_buffer(DCALbrDecoder *s)
995 {
996 // Reserve space for history and padding
997 ✗ int nchsamples = DCA_LBR_TIME_SAMPLES + DCA_LBR_TIME_HISTORY * 2;
998 ✗ int nsamples = nchsamples * s->nchannels * s->nsubbands;
999 int ch, sb;
1000 float *ptr;
1001
1002 // Reallocate time sample buffer
1003 ✗ av_fast_mallocz(&s->ts_buffer, &s->ts_size, nsamples * sizeof(float));
1004 ✗ if (!s->ts_buffer)
1005 ✗ return AVERROR(ENOMEM);
1006
1007 ✗ ptr = s->ts_buffer + DCA_LBR_TIME_HISTORY;
1008 ✗ for (ch = 0; ch < s->nchannels; ch++) {
1009 ✗ for (sb = 0; sb < s->nsubbands; sb++) {
1010 ✗ s->time_samples[ch][sb] = ptr;
1011 ✗ ptr += nchsamples;
1012 }
1013 }
1014
1015 ✗ return 0;
1016 }
1017
1018 ✗ static int parse_decoder_init(DCALbrDecoder *s, GetByteContext *gb)
1019 {
1020 ✗ int old_rate = s->sample_rate;
1021 ✗ int old_band_limit = s->band_limit;
1022 ✗ int old_nchannels = s->nchannels;
1023 int version, bit_rate_hi;
1024 unsigned int sr_code;
1025
1026 // Sample rate of LBR audio
1027 ✗ sr_code = bytestream2_get_byte(gb);
1028 ✗ if (sr_code >= FF_ARRAY_ELEMS(ff_dca_sampling_freqs)) {
1029 ✗ av_log(s->avctx, AV_LOG_ERROR, "Invalid LBR sample rate\n");
1030 ✗ return AVERROR_INVALIDDATA;
1031 }
1032 ✗ s->sample_rate = ff_dca_sampling_freqs[sr_code];
1033 ✗ if (s->sample_rate > 48000) {
1034 ✗ avpriv_report_missing_feature(s->avctx, "%d Hz LBR sample rate", s->sample_rate);
1035 ✗ return AVERROR_PATCHWELCOME;
1036 }
1037
1038 // LBR speaker mask
1039 ✗ s->ch_mask = bytestream2_get_le16(gb);
1040 ✗ if (!(s->ch_mask & 0x7)) {
1041 ✗ avpriv_report_missing_feature(s->avctx, "LBR channel mask %#x", s->ch_mask);
1042 ✗ return AVERROR_PATCHWELCOME;
1043 }
1044 ✗ if ((s->ch_mask & 0xfff0) && !(s->warned & 1)) {
1045 ✗ avpriv_report_missing_feature(s->avctx, "LBR channel mask %#x", s->ch_mask);
1046 ✗ s->warned |= 1;
1047 }
1048
1049 // LBR bitstream version
1050 ✗ version = bytestream2_get_le16(gb);
1051 ✗ if ((version & 0xff00) != 0x0800) {
1052 ✗ avpriv_report_missing_feature(s->avctx, "LBR stream version %#x", version);
1053 ✗ return AVERROR_PATCHWELCOME;
1054 }
1055
1056 // Flags for LBR decoder initialization
1057 ✗ s->flags = bytestream2_get_byte(gb);
1058 ✗ if (s->flags & LBR_FLAG_DMIX_MULTI_CH) {
1059 ✗ avpriv_report_missing_feature(s->avctx, "LBR multi-channel downmix");
1060 ✗ return AVERROR_PATCHWELCOME;
1061 }
1062 ✗ if ((s->flags & LBR_FLAG_LFE_PRESENT) && s->sample_rate != 48000) {
1063 ✗ if (!(s->warned & 2)) {
1064 ✗ avpriv_report_missing_feature(s->avctx, "%d Hz LFE interpolation", s->sample_rate);
1065 ✗ s->warned |= 2;
1066 }
1067 ✗ s->flags &= ~LBR_FLAG_LFE_PRESENT;
1068 }
1069
1070 // Most significant bit rate nibbles
1071 ✗ bit_rate_hi = bytestream2_get_byte(gb);
1072
1073 // Least significant original bit rate word
1074 ✗ s->bit_rate_orig = bytestream2_get_le16(gb) | ((bit_rate_hi & 0x0F) << 16);
1075
1076 // Least significant scaled bit rate word
1077 ✗ s->bit_rate_scaled = bytestream2_get_le16(gb) | ((bit_rate_hi & 0xF0) << 12);
1078
1079 // Setup number of fullband channels
1080 ✗ s->nchannels_total = ff_dca_count_chs_for_mask(s->ch_mask & ~DCA_SPEAKER_PAIR_LFE1);
1081 ✗ s->nchannels = FFMIN(s->nchannels_total, DCA_LBR_CHANNELS);
1082
1083 // Setup band limit
1084 ✗ switch (s->flags & LBR_FLAG_BAND_LIMIT_MASK) {
1085 ✗ case LBR_FLAG_BAND_LIMIT_NONE:
1086 ✗ s->band_limit = 0;
1087 ✗ break;
1088 ✗ case LBR_FLAG_BAND_LIMIT_1_2:
1089 ✗ s->band_limit = 1;
1090 ✗ break;
1091 ✗ case LBR_FLAG_BAND_LIMIT_1_4:
1092 ✗ s->band_limit = 2;
1093 ✗ break;
1094 ✗ default:
1095 ✗ avpriv_report_missing_feature(s->avctx, "LBR band limit %#x", s->flags & LBR_FLAG_BAND_LIMIT_MASK);
1096 ✗ return AVERROR_PATCHWELCOME;
1097 }
1098
1099 // Setup frequency range
1100 ✗ s->freq_range = ff_dca_freq_ranges[sr_code];
1101
1102 // Setup resolution profile
1103 ✗ if (s->bit_rate_orig >= 44000 * (s->nchannels_total + 2))
1104 ✗ s->res_profile = 2;
1105 ✗ else if (s->bit_rate_orig >= 25000 * (s->nchannels_total + 2))
1106 ✗ s->res_profile = 1;
1107 else
1108 ✗ s->res_profile = 0;
1109
1110 // Setup limited sample rate, number of subbands, etc
1111 ✗ s->limited_rate = s->sample_rate >> s->band_limit;
1112 ✗ s->limited_range = s->freq_range - s->band_limit;
1113 ✗ if (s->limited_range < 0) {
1114 ✗ av_log(s->avctx, AV_LOG_ERROR, "Invalid LBR band limit for frequency range\n");
1115 ✗ return AVERROR_INVALIDDATA;
1116 }
1117
1118 ✗ s->nsubbands = 8 << s->limited_range;
1119
1120 ✗ s->g3_avg_only_start_sb = s->nsubbands * ff_dca_avg_g3_freqs[s->res_profile] / (s->limited_rate / 2);
1121 ✗ if (s->g3_avg_only_start_sb > s->nsubbands)
1122 ✗ s->g3_avg_only_start_sb = s->nsubbands;
1123
1124 ✗ s->min_mono_subband = s->nsubbands * 2000 / (s->limited_rate / 2);
1125 ✗ if (s->min_mono_subband > s->nsubbands)
1126 ✗ s->min_mono_subband = s->nsubbands;
1127
1128 ✗ s->max_mono_subband = s->nsubbands * 14000 / (s->limited_rate / 2);
1129 ✗ if (s->max_mono_subband > s->nsubbands)
1130 ✗ s->max_mono_subband = s->nsubbands;
1131
1132 // Handle change of sample rate
1133 ✗ if ((old_rate != s->sample_rate || old_band_limit != s->band_limit) && init_sample_rate(s) < 0)
1134 ✗ return AVERROR(ENOMEM);
1135
1136 // Setup stereo downmix
1137 ✗ if (s->flags & LBR_FLAG_DMIX_STEREO) {
1138 ✗ DCAContext *dca = s->avctx->priv_data;
1139
1140 ✗ if (s->nchannels_total < 3 || s->nchannels_total > DCA_LBR_CHANNELS_TOTAL - 2) {
1141 ✗ av_log(s->avctx, AV_LOG_ERROR, "Invalid number of channels for LBR stereo downmix\n");
1142 ✗ return AVERROR_INVALIDDATA;
1143 }
1144
1145 // This decoder doesn't support ECS chunk
1146 ✗ if (dca->request_channel_layout != DCA_SPEAKER_LAYOUT_STEREO && !(s->warned & 4)) {
1147 ✗ avpriv_report_missing_feature(s->avctx, "Embedded LBR stereo downmix");
1148 ✗ s->warned |= 4;
1149 }
1150
1151 // Account for extra downmixed channel pair
1152 ✗ s->nchannels_total += 2;
1153 ✗ s->nchannels = 2;
1154 ✗ s->ch_mask = DCA_SPEAKER_PAIR_LR;
1155 ✗ s->flags &= ~LBR_FLAG_LFE_PRESENT;
1156 }
1157
1158 // Handle change of sample rate or number of channels
1159 ✗ if (old_rate != s->sample_rate
1160 ✗ || old_band_limit != s->band_limit
1161 ✗ || old_nchannels != s->nchannels) {
1162 ✗ if (alloc_sample_buffer(s) < 0)
1163 ✗ return AVERROR(ENOMEM);
1164 ✗ ff_dca_lbr_flush(s);
1165 }
1166
1167 ✗ return 0;
1168 }
1169
1170 ✗ int ff_dca_lbr_parse(DCALbrDecoder *s, const uint8_t *data, DCAExssAsset *asset)
1171 {
1172 struct {
1173 LBRChunk lfe;
1174 LBRChunk tonal;
1175 LBRChunk tonal_grp[5];
1176 LBRChunk grid1[DCA_LBR_CHANNELS / 2];
1177 LBRChunk hr_grid[DCA_LBR_CHANNELS / 2];
1178 LBRChunk ts1[DCA_LBR_CHANNELS / 2];
1179 LBRChunk ts2[DCA_LBR_CHANNELS / 2];
1180 ✗ } chunk = { {0} };
1181
1182 GetByteContext gb;
1183
1184 int i, ch, sb, sf, ret, group, chunk_id, chunk_len;
1185
1186 ✗ bytestream2_init(&gb, data + asset->lbr_offset, asset->lbr_size);
1187
1188 // LBR sync word
1189 ✗ if (bytestream2_get_be32(&gb) != DCA_SYNCWORD_LBR) {
1190 ✗ av_log(s->avctx, AV_LOG_ERROR, "Invalid LBR sync word\n");
1191 ✗ return AVERROR_INVALIDDATA;
1192 }
1193
1194 // LBR header type
1195 ✗ switch (bytestream2_get_byte(&gb)) {
1196 ✗ case DCA_LBR_HEADER_SYNC_ONLY:
1197 ✗ if (!s->sample_rate) {
1198 ✗ av_log(s->avctx, AV_LOG_ERROR, "LBR decoder not initialized\n");
1199 ✗ return AVERROR_INVALIDDATA;
1200 }
1201 ✗ break;
1202 ✗ case DCA_LBR_HEADER_DECODER_INIT:
1203 ✗ if ((ret = parse_decoder_init(s, &gb)) < 0) {
1204 ✗ s->sample_rate = 0;
1205 ✗ return ret;
1206 }
1207 ✗ break;
1208 ✗ default:
1209 ✗ av_log(s->avctx, AV_LOG_ERROR, "Invalid LBR header type\n");
1210 ✗ return AVERROR_INVALIDDATA;
1211 }
1212
1213 // LBR frame chunk header
1214 ✗ chunk_id = bytestream2_get_byte(&gb);
1215 ✗ chunk_len = (chunk_id & 0x80) ? bytestream2_get_be16(&gb) : bytestream2_get_byte(&gb);
1216
1217 ✗ if (chunk_len > bytestream2_get_bytes_left(&gb)) {
1218 ✗ chunk_len = bytestream2_get_bytes_left(&gb);
1219 ✗ av_log(s->avctx, AV_LOG_WARNING, "LBR frame chunk was truncated\n");
1220 ✗ if (s->avctx->err_recognition & AV_EF_EXPLODE)
1221 ✗ return AVERROR_INVALIDDATA;
1222 }
1223
1224 ✗ bytestream2_init(&gb, gb.buffer, chunk_len);
1225
1226 ✗ switch (chunk_id & 0x7f) {
1227 ✗ case LBR_CHUNK_FRAME:
1228 ✗ if (s->avctx->err_recognition & (AV_EF_CRCCHECK | AV_EF_CAREFUL)) {
1229 ✗ int checksum = bytestream2_get_be16(&gb);
1230 ✗ uint16_t res = chunk_id;
1231 ✗ res += (chunk_len >> 8) & 0xff;
1232 ✗ res += chunk_len & 0xff;
1233 ✗ for (i = 0; i < chunk_len - 2; i++)
1234 ✗ res += gb.buffer[i];
1235 ✗ if (checksum != res) {
1236 ✗ av_log(s->avctx, AV_LOG_WARNING, "Invalid LBR checksum\n");
1237 ✗ if (s->avctx->err_recognition & AV_EF_EXPLODE)
1238 ✗ return AVERROR_INVALIDDATA;
1239 }
1240 } else {
1241 ✗ bytestream2_skip(&gb, 2);
1242 }
1243 ✗ break;
1244 ✗ case LBR_CHUNK_FRAME_NO_CSUM:
1245 ✗ break;
1246 ✗ default:
1247 ✗ av_log(s->avctx, AV_LOG_ERROR, "Invalid LBR frame chunk ID\n");
1248 ✗ return AVERROR_INVALIDDATA;
1249 }
1250
1251 // Clear current frame
1252 ✗ memset(s->quant_levels, 0, sizeof(s->quant_levels));
1253 ✗ memset(s->sb_indices, 0xff, sizeof(s->sb_indices));
1254 ✗ memset(s->sec_ch_sbms, 0, sizeof(s->sec_ch_sbms));
1255 ✗ memset(s->sec_ch_lrms, 0, sizeof(s->sec_ch_lrms));
1256 ✗ memset(s->ch_pres, 0, sizeof(s->ch_pres));
1257 ✗ memset(s->grid_1_scf, 0, sizeof(s->grid_1_scf));
1258 ✗ memset(s->grid_2_scf, 0, sizeof(s->grid_2_scf));
1259 ✗ memset(s->grid_3_avg, 0, sizeof(s->grid_3_avg));
1260 ✗ memset(s->grid_3_scf, 0, sizeof(s->grid_3_scf));
1261 ✗ memset(s->grid_3_pres, 0, sizeof(s->grid_3_pres));
1262 ✗ memset(s->tonal_scf, 0, sizeof(s->tonal_scf));
1263 ✗ memset(s->lfe_data, 0, sizeof(s->lfe_data));
1264 ✗ s->part_stereo_pres = 0;
1265 ✗ s->framenum = (s->framenum + 1) & 31;
1266
1267 ✗ for (ch = 0; ch < s->nchannels; ch++) {
1268 ✗ for (sb = 0; sb < s->nsubbands / 4; sb++) {
1269 ✗ s->part_stereo[ch][sb][0] = s->part_stereo[ch][sb][4];
1270 ✗ s->part_stereo[ch][sb][4] = 16;
1271 }
1272 }
1273
1274 ✗ memset(s->lpc_coeff[s->framenum & 1], 0, sizeof(s->lpc_coeff[0]));
1275
1276 ✗ for (group = 0; group < 5; group++) {
1277 ✗ for (sf = 0; sf < 1 << group; sf++) {
1278 ✗ int sf_idx = ((s->framenum << group) + sf) & 31;
1279 ✗ s->tonal_bounds[group][sf_idx][0] =
1280 ✗ s->tonal_bounds[group][sf_idx][1] = s->ntones;
1281 }
1282 }
1283
1284 // Parse chunk headers
1285 ✗ while (bytestream2_get_bytes_left(&gb) > 0) {
1286 ✗ chunk_id = bytestream2_get_byte(&gb);
1287 ✗ chunk_len = (chunk_id & 0x80) ? bytestream2_get_be16(&gb) : bytestream2_get_byte(&gb);
1288 ✗ chunk_id &= 0x7f;
1289
1290 ✗ if (chunk_len > bytestream2_get_bytes_left(&gb)) {
1291 ✗ chunk_len = bytestream2_get_bytes_left(&gb);
1292 ✗ av_log(s->avctx, AV_LOG_WARNING, "LBR chunk %#x was truncated\n", chunk_id);
1293 ✗ if (s->avctx->err_recognition & AV_EF_EXPLODE)
1294 ✗ return AVERROR_INVALIDDATA;
1295 }
1296
1297 ✗ switch (chunk_id) {
1298 ✗ case LBR_CHUNK_LFE:
1299 ✗ chunk.lfe.len = chunk_len;
1300 ✗ chunk.lfe.data = gb.buffer;
1301 ✗ break;
1302
1303 ✗ case LBR_CHUNK_SCF:
1304 case LBR_CHUNK_TONAL:
1305 case LBR_CHUNK_TONAL_SCF:
1306 ✗ chunk.tonal.id = chunk_id;
1307 ✗ chunk.tonal.len = chunk_len;
1308 ✗ chunk.tonal.data = gb.buffer;
1309 ✗ break;
1310
1311 ✗ case LBR_CHUNK_TONAL_GRP_1:
1312 case LBR_CHUNK_TONAL_GRP_2:
1313 case LBR_CHUNK_TONAL_GRP_3:
1314 case LBR_CHUNK_TONAL_GRP_4:
1315 case LBR_CHUNK_TONAL_GRP_5:
1316 ✗ i = LBR_CHUNK_TONAL_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_TONAL_SCF_GRP_1:
1323 case LBR_CHUNK_TONAL_SCF_GRP_2:
1324 case LBR_CHUNK_TONAL_SCF_GRP_3:
1325 case LBR_CHUNK_TONAL_SCF_GRP_4:
1326 case LBR_CHUNK_TONAL_SCF_GRP_5:
1327 ✗ i = LBR_CHUNK_TONAL_SCF_GRP_5 - chunk_id;
1328 ✗ chunk.tonal_grp[i].id = i;
1329 ✗ chunk.tonal_grp[i].len = chunk_len;
1330 ✗ chunk.tonal_grp[i].data = gb.buffer;
1331 ✗ break;
1332
1333 ✗ case LBR_CHUNK_RES_GRID_LR:
1334 case LBR_CHUNK_RES_GRID_LR + 1:
1335 case LBR_CHUNK_RES_GRID_LR + 2:
1336 ✗ i = chunk_id - LBR_CHUNK_RES_GRID_LR;
1337 ✗ chunk.grid1[i].len = chunk_len;
1338 ✗ chunk.grid1[i].data = gb.buffer;
1339 ✗ break;
1340
1341 ✗ case LBR_CHUNK_RES_GRID_HR:
1342 case LBR_CHUNK_RES_GRID_HR + 1:
1343 case LBR_CHUNK_RES_GRID_HR + 2:
1344 ✗ i = chunk_id - LBR_CHUNK_RES_GRID_HR;
1345 ✗ chunk.hr_grid[i].len = chunk_len;
1346 ✗ chunk.hr_grid[i].data = gb.buffer;
1347 ✗ break;
1348
1349 ✗ case LBR_CHUNK_RES_TS_1:
1350 case LBR_CHUNK_RES_TS_1 + 1:
1351 case LBR_CHUNK_RES_TS_1 + 2:
1352 ✗ i = chunk_id - LBR_CHUNK_RES_TS_1;
1353 ✗ chunk.ts1[i].len = chunk_len;
1354 ✗ chunk.ts1[i].data = gb.buffer;
1355 ✗ break;
1356
1357 ✗ case LBR_CHUNK_RES_TS_2:
1358 case LBR_CHUNK_RES_TS_2 + 1:
1359 case LBR_CHUNK_RES_TS_2 + 2:
1360 ✗ i = chunk_id - LBR_CHUNK_RES_TS_2;
1361 ✗ chunk.ts2[i].len = chunk_len;
1362 ✗ chunk.ts2[i].data = gb.buffer;
1363 ✗ break;
1364 }
1365
1366 ✗ bytestream2_skip(&gb, chunk_len);
1367 }
1368
1369 // Parse the chunks
1370 ✗ ret = parse_lfe_chunk(s, &chunk.lfe);
1371
1372 ✗ ret |= parse_tonal_chunk(s, &chunk.tonal);
1373
1374 ✗ for (i = 0; i < 5; i++)
1375 ✗ ret |= parse_tonal_group(s, &chunk.tonal_grp[i]);
1376
1377 ✗ for (i = 0; i < (s->nchannels + 1) / 2; i++) {
1378 ✗ int ch1 = i * 2;
1379 ✗ int ch2 = FFMIN(ch1 + 1, s->nchannels - 1);
1380
1381 ✗ if (parse_grid_1_chunk (s, &chunk.grid1 [i], ch1, ch2) < 0 ||
1382 ✗ parse_high_res_grid(s, &chunk.hr_grid[i], ch1, ch2) < 0) {
1383 ✗ ret = -1;
1384 ✗ continue;
1385 }
1386
1387 // TS chunks depend on both grids. TS_2 depends on TS_1.
1388 ✗ if (!chunk.grid1[i].len || !chunk.hr_grid[i].len || !chunk.ts1[i].len)
1389 ✗ continue;
1390
1391 ✗ if (parse_ts1_chunk(s, &chunk.ts1[i], ch1, ch2) < 0 ||
1392 ✗ parse_ts2_chunk(s, &chunk.ts2[i], ch1, ch2) < 0) {
1393 ✗ ret = -1;
1394 ✗ continue;
1395 }
1396 }
1397
1398 ✗ if (ret < 0 && (s->avctx->err_recognition & AV_EF_EXPLODE))
1399 ✗ return AVERROR_INVALIDDATA;
1400
1401 ✗ return 0;
1402 }
1403
1404 /**
1405 * Reconstruct high-frequency resolution grid from first and third grids
1406 */
1407 ✗ static void decode_grid(DCALbrDecoder *s, int ch1, int ch2)
1408 {
1409 int i, ch, sb;
1410
1411 ✗ for (ch = ch1; ch <= ch2; ch++) {
1412 ✗ for (sb = 0; sb < s->nsubbands; sb++) {
1413 ✗ int g1_sb = ff_dca_scf_to_grid_1[sb];
1414
1415 ✗ uint8_t *g1_scf_a = s->grid_1_scf[ch][g1_sb ];
1416 ✗ uint8_t *g1_scf_b = s->grid_1_scf[ch][g1_sb + 1];
1417
1418 ✗ int w1 = ff_dca_grid_1_weights[g1_sb ][sb];
1419 ✗ int w2 = ff_dca_grid_1_weights[g1_sb + 1][sb];
1420
1421 ✗ uint8_t *hr_scf = s->high_res_scf[ch][sb];
1422
1423 ✗ if (sb < 4) {
1424 ✗ for (i = 0; i < 8; i++) {
1425 ✗ int scf = w1 * g1_scf_a[i] + w2 * g1_scf_b[i];
1426 ✗ hr_scf[i] = scf >> 7;
1427 }
1428 } else {
1429 ✗ int8_t *g3_scf = s->grid_3_scf[ch][sb - 4];
1430 ✗ int g3_avg = s->grid_3_avg[ch][sb - 4];
1431
1432 ✗ for (i = 0; i < 8; i++) {
1433 ✗ int scf = w1 * g1_scf_a[i] + w2 * g1_scf_b[i];
1434 ✗ hr_scf[i] = (scf >> 7) - g3_avg - g3_scf[i];
1435 }
1436 }
1437 }
1438 }
1439 ✗ }
1440
1441 /**
1442 * Fill unallocated subbands with randomness
1443 */
1444 ✗ static void random_ts(DCALbrDecoder *s, int ch1, int ch2)
1445 {
1446 int i, j, k, ch, sb;
1447
1448 ✗ for (ch = ch1; ch <= ch2; ch++) {
1449 ✗ for (sb = 0; sb < s->nsubbands; sb++) {
1450 ✗ float *samples = s->time_samples[ch][sb];
1451
1452 ✗ if (s->ch_pres[ch] & (1U << sb))
1453 ✗ continue; // Skip allocated subband
1454
1455 ✗ if (sb < 2) {
1456 // The first two subbands are always zero
1457 ✗ memset(samples, 0, DCA_LBR_TIME_SAMPLES * sizeof(float));
1458 ✗ } else if (sb < 10) {
1459 ✗ for (i = 0; i < DCA_LBR_TIME_SAMPLES; i++)
1460 ✗ samples[i] = lbr_rand(s, sb);
1461 } else {
1462 ✗ for (i = 0; i < DCA_LBR_TIME_SAMPLES / 8; i++, samples += 8) {
1463 ✗ float accum[8] = { 0 };
1464
1465 // Modulate by subbands 2-5 in blocks of 8
1466 ✗ for (k = 2; k < 6; k++) {
1467 ✗ float *other = &s->time_samples[ch][k][i * 8];
1468 ✗ for (j = 0; j < 8; j++)
1469 ✗ accum[j] += fabs(other[j]);
1470 }
1471
1472 ✗ for (j = 0; j < 8; j++)
1473 ✗ samples[j] = (accum[j] * 0.25f + 0.5f) * lbr_rand(s, sb);
1474 }
1475 }
1476 }
1477 }
1478 ✗ }
1479
1480 ✗ static void predict(float *samples, const float *coeff, int nsamples)
1481 {
1482 int i, j;
1483
1484 ✗ for (i = 0; i < nsamples; i++) {
1485 ✗ float res = 0;
1486 ✗ for (j = 0; j < 8; j++)
1487 ✗ res += coeff[j] * samples[i - j - 1];
1488 ✗ samples[i] -= res;
1489 }
1490 ✗ }
1491
1492 ✗ static void synth_lpc(DCALbrDecoder *s, int ch1, int ch2, int sb)
1493 {
1494 ✗ int f = s->framenum & 1;
1495 int ch;
1496
1497 ✗ for (ch = ch1; ch <= ch2; ch++) {
1498 ✗ float *samples = s->time_samples[ch][sb];
1499
1500 ✗ if (!(s->ch_pres[ch] & (1U << sb)))
1501 ✗ continue;
1502
1503 ✗ if (sb < 2) {
1504 ✗ predict(samples, s->lpc_coeff[f^1][ch][sb][1], 16);
1505 ✗ predict(samples + 16, s->lpc_coeff[f ][ch][sb][0], 64);
1506 ✗ predict(samples + 80, s->lpc_coeff[f ][ch][sb][1], 48);
1507 } else {
1508 ✗ predict(samples, s->lpc_coeff[f^1][ch][sb][0], 16);
1509 ✗ predict(samples + 16, s->lpc_coeff[f ][ch][sb][0], 112);
1510 }
1511 }
1512 ✗ }
1513
1514 ✗ static void filter_ts(DCALbrDecoder *s, int ch1, int ch2)
1515 {
1516 int i, j, sb, ch;
1517
1518 ✗ for (sb = 0; sb < s->nsubbands; sb++) {
1519 // Scale factors
1520 ✗ for (ch = ch1; ch <= ch2; ch++) {
1521 ✗ float *samples = s->time_samples[ch][sb];
1522 ✗ uint8_t *hr_scf = s->high_res_scf[ch][sb];
1523 ✗ if (sb < 4) {
1524 ✗ for (i = 0; i < DCA_LBR_TIME_SAMPLES / 16; i++, samples += 16) {
1525 ✗ unsigned int scf = hr_scf[i];
1526 ✗ if (scf > AMP_MAX)
1527 ✗ scf = AMP_MAX;
1528 ✗ for (j = 0; j < 16; j++)
1529 ✗ samples[j] *= ff_dca_quant_amp[scf];
1530 }
1531 } else {
1532 ✗ uint8_t *g2_scf = s->grid_2_scf[ch][ff_dca_scf_to_grid_2[sb]];
1533 ✗ for (i = 0; i < DCA_LBR_TIME_SAMPLES / 2; i++, samples += 2) {
1534 ✗ unsigned int scf = hr_scf[i / 8] - g2_scf[i];
1535 ✗ if (scf > AMP_MAX)
1536 ✗ scf = AMP_MAX;
1537 ✗ samples[0] *= ff_dca_quant_amp[scf];
1538 ✗ samples[1] *= ff_dca_quant_amp[scf];
1539 }
1540 }
1541 }
1542
1543 // Mid-side stereo
1544 ✗ if (ch1 != ch2) {
1545 ✗ float *samples_l = s->time_samples[ch1][sb];
1546 ✗ float *samples_r = s->time_samples[ch2][sb];
1547 ✗ int ch2_pres = s->ch_pres[ch2] & (1U << sb);
1548
1549 ✗ for (i = 0; i < DCA_LBR_TIME_SAMPLES / 16; i++) {
1550 ✗ int sbms = (s->sec_ch_sbms[ch1 / 2][sb] >> i) & 1;
1551 ✗ int lrms = (s->sec_ch_lrms[ch1 / 2][sb] >> i) & 1;
1552
1553 ✗ if (sb >= s->min_mono_subband) {
1554 ✗ if (lrms && ch2_pres) {
1555 ✗ if (sbms) {
1556 ✗ for (j = 0; j < 16; j++) {
1557 ✗ float tmp = samples_l[j];
1558 ✗ samples_l[j] = samples_r[j];
1559 ✗ samples_r[j] = -tmp;
1560 }
1561 } else {
1562 ✗ for (j = 0; j < 16; j++) {
1563 ✗ float tmp = samples_l[j];
1564 ✗ samples_l[j] = samples_r[j];
1565 ✗ samples_r[j] = tmp;
1566 }
1567 }
1568 ✗ } else if (!ch2_pres) {
1569 ✗ if (sbms && (s->part_stereo_pres & (1 << ch1))) {
1570 ✗ for (j = 0; j < 16; j++)
1571 ✗ samples_r[j] = -samples_l[j];
1572 } else {
1573 ✗ for (j = 0; j < 16; j++)
1574 ✗ samples_r[j] = samples_l[j];
1575 }
1576 }
1577 ✗ } else if (sbms && ch2_pres) {
1578 ✗ for (j = 0; j < 16; j++) {
1579 ✗ float tmp = samples_l[j];
1580 ✗ samples_l[j] = (tmp + samples_r[j]) * 0.5f;
1581 ✗ samples_r[j] = (tmp - samples_r[j]) * 0.5f;
1582 }
1583 }
1584
1585 ✗ samples_l += 16;
1586 ✗ samples_r += 16;
1587 }
1588 }
1589
1590 // Inverse prediction
1591 ✗ if (sb < 3)
1592 ✗ synth_lpc(s, ch1, ch2, sb);
1593 }
1594 ✗ }
1595
1596 /**
1597 * Modulate by interpolated partial stereo coefficients
1598 */
1599 ✗ static void decode_part_stereo(DCALbrDecoder *s, int ch1, int ch2)
1600 {
1601 int i, ch, sb, sf;
1602
1603 ✗ for (ch = ch1; ch <= ch2; ch++) {
1604 ✗ for (sb = s->min_mono_subband; sb < s->nsubbands; sb++) {
1605 ✗ uint8_t *pt_st = s->part_stereo[ch][(sb - s->min_mono_subband) / 4];
1606 ✗ float *samples = s->time_samples[ch][sb];
1607
1608 ✗ if (s->ch_pres[ch2] & (1U << sb))
1609 ✗ continue;
1610
1611 ✗ for (sf = 1; sf <= 4; sf++, samples += 32) {
1612 ✗ float prev = ff_dca_st_coeff[pt_st[sf - 1]];
1613 ✗ float next = ff_dca_st_coeff[pt_st[sf ]];
1614
1615 ✗ for (i = 0; i < 32; i++)
1616 ✗ samples[i] *= (32 - i) * prev + i * next;
1617 }
1618 }
1619 }
1620 ✗ }
1621
1622 /**
1623 * Synthesise tones in the given group for the given tonal subframe
1624 */
1625 ✗ static void synth_tones(DCALbrDecoder *s, int ch, float *values,
1626 int group, int group_sf, int synth_idx)
1627 {
1628 int i, start, count;
1629
1630 ✗ if (synth_idx < 0)
1631 ✗ return;
1632
1633 ✗ start = s->tonal_bounds[group][group_sf][0];
1634 ✗ count = (s->tonal_bounds[group][group_sf][1] - start) & (DCA_LBR_TONES - 1);
1635
1636 ✗ for (i = 0; i < count; i++) {
1637 ✗ DCALbrTone *t = &s->tones[(start + i) & (DCA_LBR_TONES - 1)];
1638
1639 ✗ if (t->amp[ch]) {
1640 ✗ float amp = ff_dca_synth_env[synth_idx] * ff_dca_quant_amp[t->amp[ch]];
1641 ✗ float c = amp * cos_tab[(t->phs[ch] ) & 255];
1642 ✗ float s = amp * cos_tab[(t->phs[ch] + 64) & 255];
1643 ✗ const float *cf = ff_dca_corr_cf[t->f_delt];
1644 ✗ int x_freq = t->x_freq;
1645
1646 ✗ switch (x_freq) {
1647 ✗ case 0:
1648 ✗ goto p0;
1649 ✗ case 1:
1650 ✗ values[3] += cf[0] * -s;
1651 ✗ values[2] += cf[1] * c;
1652 ✗ values[1] += cf[2] * s;
1653 ✗ values[0] += cf[3] * -c;
1654 ✗ goto p1;
1655 ✗ case 2:
1656 ✗ values[2] += cf[0] * -s;
1657 ✗ values[1] += cf[1] * c;
1658 ✗ values[0] += cf[2] * s;
1659 ✗ goto p2;
1660 ✗ case 3:
1661 ✗ values[1] += cf[0] * -s;
1662 ✗ values[0] += cf[1] * c;
1663 ✗ goto p3;
1664 ✗ case 4:
1665 ✗ values[0] += cf[0] * -s;
1666 ✗ goto p4;
1667 }
1668
1669 ✗ values[x_freq - 5] += cf[ 0] * -s;
1670 ✗ p4: values[x_freq - 4] += cf[ 1] * c;
1671 ✗ p3: values[x_freq - 3] += cf[ 2] * s;
1672 ✗ p2: values[x_freq - 2] += cf[ 3] * -c;
1673 ✗ p1: values[x_freq - 1] += cf[ 4] * -s;
1674 ✗ p0: values[x_freq ] += cf[ 5] * c;
1675 ✗ values[x_freq + 1] += cf[ 6] * s;
1676 ✗ values[x_freq + 2] += cf[ 7] * -c;
1677 ✗ values[x_freq + 3] += cf[ 8] * -s;
1678 ✗ values[x_freq + 4] += cf[ 9] * c;
1679 ✗ values[x_freq + 5] += cf[10] * s;
1680 }
1681
1682 ✗ t->phs[ch] += t->ph_rot;
1683 }
1684 }
1685
1686 /**
1687 * Synthesise all tones in all groups for the given residual subframe
1688 */
1689 ✗ static void base_func_synth(DCALbrDecoder *s, int ch, float *values, int sf)
1690 {
1691 int group;
1692
1693 // Tonal vs residual shift is 22 subframes
1694 ✗ for (group = 0; group < 5; group++) {
1695 ✗ int group_sf = (s->framenum << group) + ((sf - 22) >> (5 - group));
1696 ✗ int synth_idx = ((((sf - 22) & 31) << group) & 31) + (1 << group) - 1;
1697
1698 ✗ synth_tones(s, ch, values, group, (group_sf - 1) & 31, 30 - synth_idx);
1699 ✗ synth_tones(s, ch, values, group, (group_sf ) & 31, synth_idx);
1700 }
1701 ✗ }
1702
1703 ✗ static void transform_channel(DCALbrDecoder *s, int ch, float *output)
1704 {
1705 ✗ LOCAL_ALIGNED_32(float, values, [DCA_LBR_SUBBANDS ], [4]);
1706 ✗ LOCAL_ALIGNED_32(float, result, [DCA_LBR_SUBBANDS * 2], [4]);
1707 ✗ int sf, sb, nsubbands = s->nsubbands, noutsubbands = 8 << s->freq_range;
1708
1709 // Clear inactive subbands
1710 ✗ if (nsubbands < noutsubbands)
1711 ✗ memset(values[nsubbands], 0, (noutsubbands - nsubbands) * sizeof(values[0]));
1712
1713 ✗ for (sf = 0; sf < DCA_LBR_TIME_SAMPLES / 4; sf++) {
1714 // Hybrid filterbank
1715 ✗ s->dcadsp->lbr_bank(values, s->time_samples[ch],
1716 ✗ ff_dca_bank_coeff, sf * 4, nsubbands);
1717
1718 ✗ base_func_synth(s, ch, values[0], sf);
1719
1720 ✗ s->imdct_fn(s->imdct, result[0], values[0], sizeof(float));
1721
1722 // Long window and overlap-add
1723 ✗ s->fdsp->vector_fmul_add(output, result[0], s->window,
1724 ✗ s->history[ch], noutsubbands * 4);
1725 ✗ s->fdsp->vector_fmul_reverse(s->history[ch], result[noutsubbands],
1726 ✗ s->window, noutsubbands * 4);
1727 ✗ output += noutsubbands * 4;
1728 }
1729
1730 // Update history for LPC and forward MDCT
1731 ✗ for (sb = 0; sb < nsubbands; sb++) {
1732 ✗ float *samples = s->time_samples[ch][sb] - DCA_LBR_TIME_HISTORY;
1733 ✗ memcpy(samples, samples + DCA_LBR_TIME_SAMPLES, DCA_LBR_TIME_HISTORY * sizeof(float));
1734 }
1735 ✗ }
1736
1737 ✗ int ff_dca_lbr_filter_frame(DCALbrDecoder *s, AVFrame *frame)
1738 {
1739 ✗ AVCodecContext *avctx = s->avctx;
1740 ✗ int i, ret, nchannels, ch_conf = (s->ch_mask & 0x7) - 1;
1741 const int8_t *reorder;
1742 ✗ uint64_t channel_mask = channel_layouts[ch_conf];
1743
1744 ✗ nchannels = av_popcount64(channel_mask);
1745 ✗ avctx->sample_rate = s->sample_rate;
1746 ✗ avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;
1747 ✗ avctx->bits_per_raw_sample = 0;
1748 ✗ avctx->profile = AV_PROFILE_DTS_EXPRESS;
1749 ✗ avctx->bit_rate = s->bit_rate_scaled;
1750
1751 ✗ if (s->flags & LBR_FLAG_LFE_PRESENT) {
1752 ✗ channel_mask |= AV_CH_LOW_FREQUENCY;
1753 ✗ reorder = channel_reorder_lfe[ch_conf];
1754 } else {
1755 ✗ reorder = channel_reorder_nolfe[ch_conf];
1756 }
1757
1758 ✗ av_channel_layout_uninit(&avctx->ch_layout);
1759 ✗ av_channel_layout_from_mask(&avctx->ch_layout, channel_mask);
1760
1761 ✗ frame->nb_samples = 1024 << s->freq_range;
1762 ✗ if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
1763 ✗ return ret;
1764
1765 // Filter fullband channels
1766 ✗ for (i = 0; i < (s->nchannels + 1) / 2; i++) {
1767 ✗ int ch1 = i * 2;
1768 ✗ int ch2 = FFMIN(ch1 + 1, s->nchannels - 1);
1769
1770 ✗ decode_grid(s, ch1, ch2);
1771
1772 ✗ random_ts(s, ch1, ch2);
1773
1774 ✗ filter_ts(s, ch1, ch2);
1775
1776 ✗ if (ch1 != ch2 && (s->part_stereo_pres & (1 << ch1)))
1777 ✗ decode_part_stereo(s, ch1, ch2);
1778
1779 ✗ if (ch1 < nchannels)
1780 ✗ transform_channel(s, ch1, (float *)frame->extended_data[reorder[ch1]]);
1781
1782 ✗ if (ch1 != ch2 && ch2 < nchannels)
1783 ✗ transform_channel(s, ch2, (float *)frame->extended_data[reorder[ch2]]);
1784 }
1785
1786 // Interpolate LFE channel
1787 ✗ if (s->flags & LBR_FLAG_LFE_PRESENT) {
1788 ✗ s->dcadsp->lfe_iir((float *)frame->extended_data[lfe_index[ch_conf]],
1789 ✗ s->lfe_data, ff_dca_lfe_iir,
1790 ✗ s->lfe_history, 16 << s->freq_range);
1791 }
1792
1793 ✗ if ((ret = ff_side_data_update_matrix_encoding(frame, AV_MATRIX_ENCODING_NONE)) < 0)
1794 ✗ return ret;
1795
1796 ✗ return 0;
1797 }
1798
1799 ✗ av_cold void ff_dca_lbr_flush(DCALbrDecoder *s)
1800 {
1801 int ch, sb;
1802
1803 ✗ if (!s->sample_rate)
1804 ✗ return;
1805
1806 // Clear history
1807 ✗ memset(s->part_stereo, 16, sizeof(s->part_stereo));
1808 ✗ memset(s->lpc_coeff, 0, sizeof(s->lpc_coeff));
1809 ✗ memset(s->history, 0, sizeof(s->history));
1810 ✗ memset(s->tonal_bounds, 0, sizeof(s->tonal_bounds));
1811 ✗ memset(s->lfe_history, 0, sizeof(s->lfe_history));
1812 ✗ s->framenum = 0;
1813 ✗ s->ntones = 0;
1814
1815 ✗ for (ch = 0; ch < s->nchannels; ch++) {
1816 ✗ for (sb = 0; sb < s->nsubbands; sb++) {
1817 ✗ float *samples = s->time_samples[ch][sb] - DCA_LBR_TIME_HISTORY;
1818 ✗ memset(samples, 0, DCA_LBR_TIME_HISTORY * sizeof(float));
1819 }
1820 }
1821 }
1822
1823 99 av_cold int ff_dca_lbr_init(DCALbrDecoder *s)
1824 {
1825
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 99 times.
 99 if (!(s->fdsp = avpriv_float_dsp_alloc(0)))
1826 ✗ return AVERROR(ENOMEM);
1827
1828 99 s->lbr_rand = 1;
1829 99 return 0;
1830 }
1831
1832 99 av_cold void ff_dca_lbr_close(DCALbrDecoder *s)
1833 {
1834 99 s->sample_rate = 0;
1835
1836 99 av_freep(&s->ts_buffer);
1837 99 s->ts_size = 0;
1838
1839 99 av_freep(&s->fdsp);
1840 99 av_tx_uninit(&s->imdct);
1841 99 }
1842