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 | #include "avcodec.h" | ||
22 | #include "libavutil/channel_layout.h" | ||
23 | #include "dcadec.h" | ||
24 | #include "dcadata.h" | ||
25 | #include "dcamath.h" | ||
26 | #include "dca_syncwords.h" | ||
27 | #include "decode.h" | ||
28 | #include "unary.h" | ||
29 | |||
30 | 115073 | static int get_linear(GetBitContext *gb, int n) | |
31 | { | ||
32 | 115073 | unsigned int v = get_bits_long(gb, n); | |
33 | 115073 | return (v >> 1) ^ -(v & 1); | |
34 | } | ||
35 | |||
36 | 4945745 | static int get_rice_un(GetBitContext *gb, int k) | |
37 | { | ||
38 | 4945745 | unsigned int v = get_unary(gb, 1, get_bits_left(gb)); | |
39 | 4945745 | return (v << k) | get_bits_long(gb, k); | |
40 | } | ||
41 | |||
42 | 4945745 | static int get_rice(GetBitContext *gb, int k) | |
43 | { | ||
44 | 4945745 | unsigned int v = get_rice_un(gb, k); | |
45 | 4945745 | return (v >> 1) ^ -(v & 1); | |
46 | } | ||
47 | |||
48 | 856 | static void get_array(GetBitContext *gb, int32_t *array, int size, int n) | |
49 | { | ||
50 | int i; | ||
51 | |||
52 |
2/2✓ Branch 0 taken 69632 times.
✓ Branch 1 taken 856 times.
|
70488 | for (i = 0; i < size; i++) |
53 | 69632 | array[i] = get_bits(gb, n); | |
54 | 856 | } | |
55 | |||
56 | 15310 | static void get_linear_array(GetBitContext *gb, int32_t *array, int size, int n) | |
57 | { | ||
58 | int i; | ||
59 | |||
60 |
2/2✓ Branch 0 taken 14639 times.
✓ Branch 1 taken 671 times.
|
15310 | if (n == 0) |
61 | 14639 | memset(array, 0, sizeof(*array) * size); | |
62 |
2/2✓ Branch 0 taken 65601 times.
✓ Branch 1 taken 671 times.
|
66272 | else for (i = 0; i < size; i++) |
63 | 65601 | array[i] = get_linear(gb, n); | |
64 | 15310 | } | |
65 | |||
66 | 48028 | static void get_rice_array(GetBitContext *gb, int32_t *array, int size, int k) | |
67 | { | ||
68 | int i; | ||
69 | |||
70 |
2/2✓ Branch 0 taken 4811449 times.
✓ Branch 1 taken 48028 times.
|
4859477 | for (i = 0; i < size; i++) |
71 | 4811449 | array[i] = get_rice(gb, k); | |
72 | 48028 | } | |
73 | |||
74 | 147 | static int parse_dmix_coeffs(DCAXllDecoder *s, DCAXllChSet *c) | |
75 | { | ||
76 | // Size of downmix coefficient matrix | ||
77 |
2/2✓ Branch 0 taken 21 times.
✓ Branch 1 taken 126 times.
|
147 | int m = c->primary_chset ? ff_dca_dmix_primary_nch[c->dmix_type] : c->hier_ofs; |
78 | 147 | int i, j, *coeff_ptr = c->dmix_coeff; | |
79 | |||
80 |
2/2✓ Branch 0 taken 630 times.
✓ Branch 1 taken 147 times.
|
777 | for (i = 0; i < m; i++) { |
81 | 630 | int code, sign, coeff, scale, scale_inv = 0; | |
82 | unsigned int index; | ||
83 | |||
84 | // Downmix scale (only for non-primary channel sets) | ||
85 |
2/2✓ Branch 0 taken 588 times.
✓ Branch 1 taken 42 times.
|
630 | if (!c->primary_chset) { |
86 | 588 | code = get_bits(&s->gb, 9); | |
87 | 588 | sign = (code >> 8) - 1; | |
88 | 588 | index = (code & 0xff) - FF_DCA_DMIXTABLE_OFFSET; | |
89 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 588 times.
|
588 | if (index >= FF_DCA_INV_DMIXTABLE_SIZE) { |
90 | ✗ | av_log(s->avctx, AV_LOG_ERROR, "Invalid XLL downmix scale index\n"); | |
91 | ✗ | return AVERROR_INVALIDDATA; | |
92 | } | ||
93 | 588 | scale = ff_dca_dmixtable[index + FF_DCA_DMIXTABLE_OFFSET]; | |
94 | 588 | scale_inv = ff_dca_inv_dmixtable[index]; | |
95 | 588 | c->dmix_scale[i] = (scale ^ sign) - sign; | |
96 | 588 | c->dmix_scale_inv[i] = (scale_inv ^ sign) - sign; | |
97 | } | ||
98 | |||
99 | // Downmix coefficients | ||
100 |
2/2✓ Branch 0 taken 1470 times.
✓ Branch 1 taken 630 times.
|
2100 | for (j = 0; j < c->nchannels; j++) { |
101 | 1470 | code = get_bits(&s->gb, 9); | |
102 | 1470 | sign = (code >> 8) - 1; | |
103 | 1470 | index = code & 0xff; | |
104 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1470 times.
|
1470 | if (index >= FF_DCA_DMIXTABLE_SIZE) { |
105 | ✗ | av_log(s->avctx, AV_LOG_ERROR, "Invalid XLL downmix coefficient index\n"); | |
106 | ✗ | return AVERROR_INVALIDDATA; | |
107 | } | ||
108 | 1470 | coeff = ff_dca_dmixtable[index]; | |
109 |
2/2✓ Branch 0 taken 1218 times.
✓ Branch 1 taken 252 times.
|
1470 | if (!c->primary_chset) |
110 | // Multiply by |InvDmixScale| to get |UndoDmixScale| | ||
111 | 1218 | coeff = mul16(scale_inv, coeff); | |
112 | 1470 | *coeff_ptr++ = (coeff ^ sign) - sign; | |
113 | } | ||
114 | } | ||
115 | |||
116 | 147 | return 0; | |
117 | } | ||
118 | |||
119 | 2660 | static int chs_parse_header(DCAXllDecoder *s, DCAXllChSet *c, DCAExssAsset *asset) | |
120 | { | ||
121 | 2660 | int i, j, k, ret, band, header_size, header_pos = get_bits_count(&s->gb); | |
122 | 2660 | DCAXllChSet *p = &s->chset[0]; | |
123 | DCAXllBand *b; | ||
124 | |||
125 | // Size of channel set sub-header | ||
126 | 2660 | header_size = get_bits(&s->gb, 10) + 1; | |
127 | |||
128 | // Check CRC | ||
129 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 2660 times.
|
2660 | if (ff_dca_check_crc(s->avctx, &s->gb, header_pos, header_pos + header_size * 8)) { |
130 | ✗ | av_log(s->avctx, AV_LOG_ERROR, "Invalid XLL sub-header checksum\n"); | |
131 | ✗ | return AVERROR_INVALIDDATA; | |
132 | } | ||
133 | |||
134 | // Number of channels in the channel set | ||
135 | 2660 | c->nchannels = get_bits(&s->gb, 4) + 1; | |
136 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2660 times.
|
2660 | if (c->nchannels > DCA_XLL_CHANNELS_MAX) { |
137 | ✗ | avpriv_request_sample(s->avctx, "%d XLL channels", c->nchannels); | |
138 | ✗ | return AVERROR_PATCHWELCOME; | |
139 | } | ||
140 | |||
141 | // Residual type | ||
142 | 2660 | c->residual_encode = get_bits(&s->gb, c->nchannels); | |
143 | |||
144 | // PCM bit resolution | ||
145 | 2660 | c->pcm_bit_res = get_bits(&s->gb, 5) + 1; | |
146 | |||
147 | // Storage unit width | ||
148 | 2660 | c->storage_bit_res = get_bits(&s->gb, 5) + 1; | |
149 |
4/6✓ Branch 0 taken 2597 times.
✓ Branch 1 taken 63 times.
✓ Branch 2 taken 2597 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 2597 times.
|
2660 | if (c->storage_bit_res != 16 && c->storage_bit_res != 20 && c->storage_bit_res != 24) { |
150 | ✗ | avpriv_request_sample(s->avctx, "%d-bit XLL storage resolution", c->storage_bit_res); | |
151 | ✗ | return AVERROR_PATCHWELCOME; | |
152 | } | ||
153 | |||
154 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2660 times.
|
2660 | if (c->pcm_bit_res > c->storage_bit_res) { |
155 | ✗ | av_log(s->avctx, AV_LOG_ERROR, "Invalid PCM bit resolution for XLL channel set (%d > %d)\n", c->pcm_bit_res, c->storage_bit_res); | |
156 | ✗ | return AVERROR_INVALIDDATA; | |
157 | } | ||
158 | |||
159 | // Original sampling frequency | ||
160 | 2660 | c->freq = ff_dca_sampling_freqs[get_bits(&s->gb, 4)]; | |
161 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2660 times.
|
2660 | if (c->freq > 192000) { |
162 | ✗ | avpriv_request_sample(s->avctx, "%d Hz XLL sampling frequency", c->freq); | |
163 | ✗ | return AVERROR_PATCHWELCOME; | |
164 | } | ||
165 | |||
166 | // Sampling frequency modifier | ||
167 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 2660 times.
|
2660 | if (get_bits(&s->gb, 2)) { |
168 | ✗ | avpriv_request_sample(s->avctx, "XLL sampling frequency modifier"); | |
169 | ✗ | return AVERROR_PATCHWELCOME; | |
170 | } | ||
171 | |||
172 | // Which replacement set this channel set is member of | ||
173 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 2660 times.
|
2660 | if (get_bits(&s->gb, 2)) { |
174 | ✗ | avpriv_request_sample(s->avctx, "XLL replacement set"); | |
175 | ✗ | return AVERROR_PATCHWELCOME; | |
176 | } | ||
177 | |||
178 |
1/2✓ Branch 0 taken 2660 times.
✗ Branch 1 not taken.
|
2660 | if (asset->one_to_one_map_ch_to_spkr) { |
179 | // Primary channel set flag | ||
180 | 2660 | c->primary_chset = get_bits1(&s->gb); | |
181 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2660 times.
|
2660 | if (c->primary_chset != (c == p)) { |
182 | ✗ | av_log(s->avctx, AV_LOG_ERROR, "The first (and only) XLL channel set must be primary\n"); | |
183 | ✗ | return AVERROR_INVALIDDATA; | |
184 | } | ||
185 | |||
186 | // Downmix coefficients present in stream | ||
187 | 2660 | c->dmix_coeffs_present = get_bits1(&s->gb); | |
188 | |||
189 | // Downmix already performed by encoder | ||
190 |
3/4✓ Branch 0 taken 147 times.
✓ Branch 1 taken 2513 times.
✓ Branch 3 taken 147 times.
✗ Branch 4 not taken.
|
2660 | c->dmix_embedded = c->dmix_coeffs_present && get_bits1(&s->gb); |
191 | |||
192 | // Downmix type | ||
193 |
4/4✓ Branch 0 taken 147 times.
✓ Branch 1 taken 2513 times.
✓ Branch 2 taken 21 times.
✓ Branch 3 taken 126 times.
|
2660 | if (c->dmix_coeffs_present && c->primary_chset) { |
194 | 21 | c->dmix_type = get_bits(&s->gb, 3); | |
195 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 21 times.
|
21 | if (c->dmix_type >= DCA_DMIX_TYPE_COUNT) { |
196 | ✗ | av_log(s->avctx, AV_LOG_ERROR, "Invalid XLL primary channel set downmix type\n"); | |
197 | ✗ | return AVERROR_INVALIDDATA; | |
198 | } | ||
199 | } | ||
200 | |||
201 | // Whether the channel set is part of a hierarchy | ||
202 | 2660 | c->hier_chset = get_bits1(&s->gb); | |
203 |
1/4✗ Branch 0 not taken.
✓ Branch 1 taken 2660 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
2660 | if (!c->hier_chset && s->nchsets != 1) { |
204 | ✗ | avpriv_request_sample(s->avctx, "XLL channel set outside of hierarchy"); | |
205 | ✗ | return AVERROR_PATCHWELCOME; | |
206 | } | ||
207 | |||
208 | // Downmix coefficients | ||
209 |
3/4✓ Branch 0 taken 147 times.
✓ Branch 1 taken 2513 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 147 times.
|
2660 | if (c->dmix_coeffs_present && (ret = parse_dmix_coeffs(s, c)) < 0) |
210 | ✗ | return ret; | |
211 | |||
212 | // Channel mask enabled | ||
213 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 2660 times.
|
2660 | if (!get_bits1(&s->gb)) { |
214 | ✗ | avpriv_request_sample(s->avctx, "Disabled XLL channel mask"); | |
215 | ✗ | return AVERROR_PATCHWELCOME; | |
216 | } | ||
217 | |||
218 | // Channel mask for set | ||
219 | 2660 | c->ch_mask = get_bits_long(&s->gb, s->ch_mask_nbits); | |
220 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2660 times.
|
2660 | if (av_popcount(c->ch_mask) != c->nchannels) { |
221 | ✗ | av_log(s->avctx, AV_LOG_ERROR, "Invalid XLL channel mask\n"); | |
222 | ✗ | return AVERROR_INVALIDDATA; | |
223 | } | ||
224 | |||
225 | // Build the channel to speaker map | ||
226 |
2/2✓ Branch 0 taken 47339 times.
✓ Branch 1 taken 2660 times.
|
49999 | for (i = 0, j = 0; i < s->ch_mask_nbits; i++) |
227 |
2/2✓ Branch 0 taken 10643 times.
✓ Branch 1 taken 36696 times.
|
47339 | if (c->ch_mask & (1U << i)) |
228 | 10643 | c->ch_remap[j++] = i; | |
229 | } else { | ||
230 | // Mapping coeffs present flag | ||
231 | ✗ | if (c->nchannels != 2 || s->nchsets != 1 || get_bits1(&s->gb)) { | |
232 | ✗ | avpriv_request_sample(s->avctx, "Custom XLL channel to speaker mapping"); | |
233 | ✗ | return AVERROR_PATCHWELCOME; | |
234 | } | ||
235 | |||
236 | // Setup for LtRt decoding | ||
237 | ✗ | c->primary_chset = 1; | |
238 | ✗ | c->dmix_coeffs_present = 0; | |
239 | ✗ | c->dmix_embedded = 0; | |
240 | ✗ | c->hier_chset = 0; | |
241 | ✗ | c->ch_mask = DCA_SPEAKER_LAYOUT_STEREO; | |
242 | ✗ | c->ch_remap[0] = DCA_SPEAKER_L; | |
243 | ✗ | c->ch_remap[1] = DCA_SPEAKER_R; | |
244 | } | ||
245 | |||
246 |
2/2✓ Branch 0 taken 63 times.
✓ Branch 1 taken 2597 times.
|
2660 | if (c->freq > 96000) { |
247 | // Extra frequency bands flag | ||
248 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 63 times.
|
63 | if (get_bits1(&s->gb)) { |
249 | ✗ | avpriv_request_sample(s->avctx, "Extra XLL frequency bands"); | |
250 | ✗ | return AVERROR_PATCHWELCOME; | |
251 | } | ||
252 | 63 | c->nfreqbands = 2; | |
253 | } else { | ||
254 | 2597 | c->nfreqbands = 1; | |
255 | } | ||
256 | |||
257 | // Set the sampling frequency to that of the first frequency band. | ||
258 | // Frequency will be doubled again after bands assembly. | ||
259 | 2660 | c->freq >>= c->nfreqbands - 1; | |
260 | |||
261 | // Verify that all channel sets have the same audio characteristics | ||
262 |
4/6✓ Branch 0 taken 1303 times.
✓ Branch 1 taken 1357 times.
✓ Branch 2 taken 1303 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 1303 times.
✗ Branch 5 not taken.
|
2660 | if (c != p && (c->nfreqbands != p->nfreqbands || c->freq != p->freq |
263 |
1/2✓ Branch 0 taken 1303 times.
✗ Branch 1 not taken.
|
1303 | || c->pcm_bit_res != p->pcm_bit_res |
264 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1303 times.
|
1303 | || c->storage_bit_res != p->storage_bit_res)) { |
265 | ✗ | avpriv_request_sample(s->avctx, "Different XLL audio characteristics"); | |
266 | ✗ | return AVERROR_PATCHWELCOME; | |
267 | } | ||
268 | |||
269 | // Determine number of bits to read bit allocation coding parameter | ||
270 |
2/2✓ Branch 0 taken 2597 times.
✓ Branch 1 taken 63 times.
|
2660 | if (c->storage_bit_res > 16) |
271 | 2597 | c->nabits = 5; | |
272 |
1/2✓ Branch 0 taken 63 times.
✗ Branch 1 not taken.
|
63 | else if (c->storage_bit_res > 8) |
273 | 63 | c->nabits = 4; | |
274 | else | ||
275 | ✗ | c->nabits = 3; | |
276 | |||
277 | // Account for embedded downmix and decimator saturation | ||
278 |
6/6✓ Branch 0 taken 75 times.
✓ Branch 1 taken 2585 times.
✓ Branch 2 taken 21 times.
✓ Branch 3 taken 54 times.
✓ Branch 4 taken 63 times.
✓ Branch 5 taken 2543 times.
|
2660 | if ((s->nchsets > 1 || c->nfreqbands > 1) && c->nabits < 5) |
279 | 63 | c->nabits++; | |
280 | |||
281 |
2/2✓ Branch 0 taken 2723 times.
✓ Branch 1 taken 2660 times.
|
5383 | for (band = 0, b = c->bands; band < c->nfreqbands; band++, b++) { |
282 | // Pairwise channel decorrelation | ||
283 |
3/4✓ Branch 1 taken 2702 times.
✓ Branch 2 taken 21 times.
✓ Branch 3 taken 2702 times.
✗ Branch 4 not taken.
|
5425 | if ((b->decor_enabled = get_bits1(&s->gb)) && c->nchannels > 1) { |
284 | 2702 | int ch_nbits = av_ceil_log2(c->nchannels); | |
285 | |||
286 | // Original channel order | ||
287 |
2/2✓ Branch 0 taken 10874 times.
✓ Branch 1 taken 2702 times.
|
13576 | for (i = 0; i < c->nchannels; i++) { |
288 | 10874 | b->orig_order[i] = get_bits(&s->gb, ch_nbits); | |
289 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 10874 times.
|
10874 | if (b->orig_order[i] >= c->nchannels) { |
290 | ✗ | av_log(s->avctx, AV_LOG_ERROR, "Invalid XLL original channel order\n"); | |
291 | ✗ | return AVERROR_INVALIDDATA; | |
292 | } | ||
293 | } | ||
294 | |||
295 | // Pairwise channel coefficients | ||
296 |
2/2✓ Branch 0 taken 5437 times.
✓ Branch 1 taken 2702 times.
|
8139 | for (i = 0; i < c->nchannels / 2; i++) |
297 |
2/2✓ Branch 1 taken 1984 times.
✓ Branch 2 taken 3453 times.
|
5437 | b->decor_coeff[i] = get_bits1(&s->gb) ? get_linear(&s->gb, 7) : 0; |
298 | } else { | ||
299 |
2/2✓ Branch 0 taken 21 times.
✓ Branch 1 taken 21 times.
|
42 | for (i = 0; i < c->nchannels; i++) |
300 | 21 | b->orig_order[i] = i; | |
301 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 21 times.
|
21 | for (i = 0; i < c->nchannels / 2; i++) |
302 | ✗ | b->decor_coeff[i] = 0; | |
303 | } | ||
304 | |||
305 | // Adaptive predictor order | ||
306 | 2723 | b->highest_pred_order = 0; | |
307 |
2/2✓ Branch 0 taken 10895 times.
✓ Branch 1 taken 2723 times.
|
13618 | for (i = 0; i < c->nchannels; i++) { |
308 | 10895 | b->adapt_pred_order[i] = get_bits(&s->gb, 4); | |
309 |
2/2✓ Branch 0 taken 4074 times.
✓ Branch 1 taken 6821 times.
|
10895 | if (b->adapt_pred_order[i] > b->highest_pred_order) |
310 | 4074 | b->highest_pred_order = b->adapt_pred_order[i]; | |
311 | } | ||
312 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2723 times.
|
2723 | if (b->highest_pred_order > s->nsegsamples) { |
313 | ✗ | av_log(s->avctx, AV_LOG_ERROR, "Invalid XLL adaptive predicition order\n"); | |
314 | ✗ | return AVERROR_INVALIDDATA; | |
315 | } | ||
316 | |||
317 | // Fixed predictor order | ||
318 |
2/2✓ Branch 0 taken 10895 times.
✓ Branch 1 taken 2723 times.
|
13618 | for (i = 0; i < c->nchannels; i++) |
319 |
2/2✓ Branch 0 taken 1931 times.
✓ Branch 1 taken 8964 times.
|
10895 | b->fixed_pred_order[i] = b->adapt_pred_order[i] ? 0 : get_bits(&s->gb, 2); |
320 | |||
321 | // Adaptive predictor quantized reflection coefficients | ||
322 |
2/2✓ Branch 0 taken 10895 times.
✓ Branch 1 taken 2723 times.
|
13618 | for (i = 0; i < c->nchannels; i++) { |
323 |
2/2✓ Branch 0 taken 42257 times.
✓ Branch 1 taken 10895 times.
|
53152 | for (j = 0; j < b->adapt_pred_order[i]; j++) { |
324 | 42257 | k = get_linear(&s->gb, 8); | |
325 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 42257 times.
|
42257 | if (k == -128) { |
326 | ✗ | av_log(s->avctx, AV_LOG_ERROR, "Invalid XLL reflection coefficient index\n"); | |
327 | ✗ | return AVERROR_INVALIDDATA; | |
328 | } | ||
329 |
2/2✓ Branch 0 taken 15112 times.
✓ Branch 1 taken 27145 times.
|
42257 | if (k < 0) |
330 | 15112 | b->adapt_refl_coeff[i][j] = -(int)ff_dca_xll_refl_coeff[-k]; | |
331 | else | ||
332 | 27145 | b->adapt_refl_coeff[i][j] = (int)ff_dca_xll_refl_coeff[ k]; | |
333 | } | ||
334 | } | ||
335 | |||
336 | // Downmix performed by encoder in extension frequency band | ||
337 |
5/6✓ Branch 0 taken 168 times.
✓ Branch 1 taken 2555 times.
✓ Branch 2 taken 21 times.
✓ Branch 3 taken 147 times.
✓ Branch 5 taken 21 times.
✗ Branch 6 not taken.
|
2723 | b->dmix_embedded = c->dmix_embedded && (band == 0 || get_bits1(&s->gb)); |
338 | |||
339 | // MSB/LSB split flag in extension frequency band | ||
340 |
7/8✓ Branch 0 taken 2660 times.
✓ Branch 1 taken 63 times.
✓ Branch 2 taken 2408 times.
✓ Branch 3 taken 252 times.
✓ Branch 4 taken 63 times.
✓ Branch 5 taken 2408 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 63 times.
|
2723 | if ((band == 0 && s->scalable_lsbs) || (band != 0 && get_bits1(&s->gb))) { |
341 | // Size of LSB section in any segment | ||
342 | 252 | b->lsb_section_size = get_bits_long(&s->gb, s->seg_size_nbits); | |
343 |
2/4✓ Branch 0 taken 252 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 252 times.
|
252 | if (b->lsb_section_size < 0 || b->lsb_section_size > s->frame_size) { |
344 | ✗ | av_log(s->avctx, AV_LOG_ERROR, "Invalid LSB section size\n"); | |
345 | ✗ | return AVERROR_INVALIDDATA; | |
346 | } | ||
347 | |||
348 | // Account for optional CRC bytes after LSB section | ||
349 |
4/6✓ Branch 0 taken 60 times.
✓ Branch 1 taken 192 times.
✓ Branch 2 taken 60 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 60 times.
✗ Branch 5 not taken.
|
252 | if (b->lsb_section_size && (s->band_crc_present > 2 || |
350 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 60 times.
|
60 | (band == 0 && s->band_crc_present > 1))) |
351 | ✗ | b->lsb_section_size += 2; | |
352 | |||
353 | // Number of bits to represent the samples in LSB part | ||
354 |
2/2✓ Branch 0 taken 903 times.
✓ Branch 1 taken 252 times.
|
1155 | for (i = 0; i < c->nchannels; i++) { |
355 | 903 | b->nscalablelsbs[i] = get_bits(&s->gb, 4); | |
356 |
3/4✓ Branch 0 taken 120 times.
✓ Branch 1 taken 783 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 120 times.
|
903 | if (b->nscalablelsbs[i] && !b->lsb_section_size) { |
357 | ✗ | av_log(s->avctx, AV_LOG_ERROR, "LSB section missing with non-zero LSB width\n"); | |
358 | ✗ | return AVERROR_INVALIDDATA; | |
359 | } | ||
360 | } | ||
361 | } else { | ||
362 | 2471 | b->lsb_section_size = 0; | |
363 |
2/2✓ Branch 0 taken 9992 times.
✓ Branch 1 taken 2471 times.
|
12463 | for (i = 0; i < c->nchannels; i++) |
364 | 9992 | b->nscalablelsbs[i] = 0; | |
365 | } | ||
366 | |||
367 | // Scalable resolution flag in extension frequency band | ||
368 |
7/8✓ Branch 0 taken 2660 times.
✓ Branch 1 taken 63 times.
✓ Branch 2 taken 2408 times.
✓ Branch 3 taken 252 times.
✓ Branch 4 taken 63 times.
✓ Branch 5 taken 2408 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 63 times.
|
2723 | if ((band == 0 && s->scalable_lsbs) || (band != 0 && get_bits1(&s->gb))) { |
369 | // Number of bits discarded by authoring | ||
370 |
2/2✓ Branch 0 taken 903 times.
✓ Branch 1 taken 252 times.
|
1155 | for (i = 0; i < c->nchannels; i++) |
371 | 903 | b->bit_width_adjust[i] = get_bits(&s->gb, 4); | |
372 | } else { | ||
373 |
2/2✓ Branch 0 taken 9992 times.
✓ Branch 1 taken 2471 times.
|
12463 | for (i = 0; i < c->nchannels; i++) |
374 | 9992 | b->bit_width_adjust[i] = 0; | |
375 | } | ||
376 | } | ||
377 | |||
378 | // Reserved | ||
379 | // Byte align | ||
380 | // CRC16 of channel set sub-header | ||
381 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 2660 times.
|
2660 | if (ff_dca_seek_bits(&s->gb, header_pos + header_size * 8)) { |
382 | ✗ | av_log(s->avctx, AV_LOG_ERROR, "Read past end of XLL sub-header\n"); | |
383 | ✗ | return AVERROR_INVALIDDATA; | |
384 | } | ||
385 | |||
386 | 2660 | return 0; | |
387 | } | ||
388 | |||
389 | 2590 | static int chs_alloc_msb_band_data(DCAXllDecoder *s, DCAXllChSet *c) | |
390 | { | ||
391 |
2/2✓ Branch 0 taken 56 times.
✓ Branch 1 taken 2534 times.
|
2590 | int ndecisamples = c->nfreqbands > 1 ? DCA_XLL_DECI_HISTORY_MAX : 0; |
392 | 2590 | int nchsamples = s->nframesamples + ndecisamples; | |
393 | 2590 | int i, j, nsamples = nchsamples * c->nchannels * c->nfreqbands; | |
394 | int32_t *ptr; | ||
395 | |||
396 | // Reallocate MSB sample buffer | ||
397 | 2590 | av_fast_malloc(&c->sample_buffer[0], &c->sample_size[0], nsamples * sizeof(int32_t)); | |
398 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2590 times.
|
2590 | if (!c->sample_buffer[0]) |
399 | ✗ | return AVERROR(ENOMEM); | |
400 | |||
401 | 2590 | ptr = c->sample_buffer[0] + ndecisamples; | |
402 |
2/2✓ Branch 0 taken 2646 times.
✓ Branch 1 taken 2590 times.
|
5236 | for (i = 0; i < c->nfreqbands; i++) { |
403 |
2/2✓ Branch 0 taken 10713 times.
✓ Branch 1 taken 2646 times.
|
13359 | for (j = 0; j < c->nchannels; j++) { |
404 | 10713 | c->bands[i].msb_sample_buffer[j] = ptr; | |
405 | 10713 | ptr += nchsamples; | |
406 | } | ||
407 | } | ||
408 | |||
409 | 2590 | return 0; | |
410 | } | ||
411 | |||
412 | 2590 | static int chs_alloc_lsb_band_data(DCAXllDecoder *s, DCAXllChSet *c) | |
413 | { | ||
414 | 2590 | int i, j, nsamples = 0; | |
415 | int32_t *ptr; | ||
416 | |||
417 | // Determine number of frequency bands that have MSB/LSB split | ||
418 |
2/2✓ Branch 0 taken 2646 times.
✓ Branch 1 taken 2590 times.
|
5236 | for (i = 0; i < c->nfreqbands; i++) |
419 |
2/2✓ Branch 0 taken 56 times.
✓ Branch 1 taken 2590 times.
|
2646 | if (c->bands[i].lsb_section_size) |
420 | 56 | nsamples += s->nframesamples * c->nchannels; | |
421 |
2/2✓ Branch 0 taken 2534 times.
✓ Branch 1 taken 56 times.
|
2590 | if (!nsamples) |
422 | 2534 | return 0; | |
423 | |||
424 | // Reallocate LSB sample buffer | ||
425 | 56 | av_fast_malloc(&c->sample_buffer[1], &c->sample_size[1], nsamples * sizeof(int32_t)); | |
426 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 56 times.
|
56 | if (!c->sample_buffer[1]) |
427 | ✗ | return AVERROR(ENOMEM); | |
428 | |||
429 | 56 | ptr = c->sample_buffer[1]; | |
430 |
2/2✓ Branch 0 taken 56 times.
✓ Branch 1 taken 56 times.
|
112 | for (i = 0; i < c->nfreqbands; i++) { |
431 |
1/2✓ Branch 0 taken 56 times.
✗ Branch 1 not taken.
|
56 | if (c->bands[i].lsb_section_size) { |
432 |
2/2✓ Branch 0 taken 272 times.
✓ Branch 1 taken 56 times.
|
328 | for (j = 0; j < c->nchannels; j++) { |
433 | 272 | c->bands[i].lsb_sample_buffer[j] = ptr; | |
434 | 272 | ptr += s->nframesamples; | |
435 | } | ||
436 | } else { | ||
437 | ✗ | for (j = 0; j < c->nchannels; j++) | |
438 | ✗ | c->bands[i].lsb_sample_buffer[j] = NULL; | |
439 | } | ||
440 | } | ||
441 | |||
442 | 56 | return 0; | |
443 | } | ||
444 | |||
445 | 7856 | static int chs_parse_band_data(DCAXllDecoder *s, DCAXllChSet *c, int band, int seg, int band_data_end) | |
446 | { | ||
447 | 7856 | DCAXllBand *b = &c->bands[band]; | |
448 | int i, j, k; | ||
449 | |||
450 | // Start unpacking MSB portion of the segment | ||
451 |
3/4✓ Branch 0 taken 5210 times.
✓ Branch 1 taken 2646 times.
✓ Branch 3 taken 5210 times.
✗ Branch 4 not taken.
|
7856 | if (!(seg && get_bits1(&s->gb))) { |
452 | // Unpack segment type | ||
453 | // 0 - distinct coding parameters for each channel | ||
454 | // 1 - common coding parameters for all channels | ||
455 | 7856 | c->seg_common = get_bits1(&s->gb); | |
456 | |||
457 | // Determine number of coding parameters encoded in segment | ||
458 |
2/2✓ Branch 0 taken 5607 times.
✓ Branch 1 taken 2249 times.
|
7856 | k = c->seg_common ? 1 : c->nchannels; |
459 | |||
460 | // Unpack Rice coding parameters | ||
461 |
2/2✓ Branch 0 taken 25612 times.
✓ Branch 1 taken 7856 times.
|
33468 | for (i = 0; i < k; i++) { |
462 | // Unpack Rice coding flag | ||
463 | // 0 - linear code, 1 - Rice code | ||
464 | 25612 | c->rice_code_flag[i] = get_bits1(&s->gb); | |
465 | // Unpack Hybrid Rice coding flag | ||
466 | // 0 - Rice code, 1 - Hybrid Rice code | ||
467 |
6/6✓ Branch 0 taken 23363 times.
✓ Branch 1 taken 2249 times.
✓ Branch 2 taken 18940 times.
✓ Branch 3 taken 4423 times.
✓ Branch 5 taken 906 times.
✓ Branch 6 taken 18034 times.
|
25612 | if (!c->seg_common && c->rice_code_flag[i] && get_bits1(&s->gb)) |
468 | // Unpack binary code length for isolated samples | ||
469 | 906 | c->bitalloc_hybrid_linear[i] = get_bits(&s->gb, c->nabits) + 1; | |
470 | else | ||
471 | // 0 indicates no Hybrid Rice coding | ||
472 | 24706 | c->bitalloc_hybrid_linear[i] = 0; | |
473 | } | ||
474 | |||
475 | // Unpack coding parameters | ||
476 |
2/2✓ Branch 0 taken 25612 times.
✓ Branch 1 taken 7856 times.
|
33468 | for (i = 0; i < k; i++) { |
477 |
2/2✓ Branch 0 taken 8688 times.
✓ Branch 1 taken 16924 times.
|
25612 | if (seg == 0) { |
478 | // Unpack coding parameter for part A of segment 0 | ||
479 | 8688 | c->bitalloc_part_a[i] = get_bits(&s->gb, c->nabits); | |
480 | |||
481 | // Adjust for the linear code | ||
482 |
4/4✓ Branch 0 taken 777 times.
✓ Branch 1 taken 7911 times.
✓ Branch 2 taken 72 times.
✓ Branch 3 taken 705 times.
|
8688 | if (!c->rice_code_flag[i] && c->bitalloc_part_a[i]) |
483 | 72 | c->bitalloc_part_a[i]++; | |
484 | |||
485 |
2/2✓ Branch 0 taken 8000 times.
✓ Branch 1 taken 688 times.
|
8688 | if (!c->seg_common) |
486 | 8000 | c->nsamples_part_a[i] = b->adapt_pred_order[i]; | |
487 | else | ||
488 | 688 | c->nsamples_part_a[i] = b->highest_pred_order; | |
489 | } else { | ||
490 | 16924 | c->bitalloc_part_a[i] = 0; | |
491 | 16924 | c->nsamples_part_a[i] = 0; | |
492 | } | ||
493 | |||
494 | // Unpack coding parameter for part B of segment | ||
495 | 25612 | c->bitalloc_part_b[i] = get_bits(&s->gb, c->nabits); | |
496 | |||
497 | // Adjust for the linear code | ||
498 |
4/4✓ Branch 0 taken 5201 times.
✓ Branch 1 taken 20411 times.
✓ Branch 2 taken 599 times.
✓ Branch 3 taken 4602 times.
|
25612 | if (!c->rice_code_flag[i] && c->bitalloc_part_b[i]) |
499 | 599 | c->bitalloc_part_b[i]++; | |
500 | } | ||
501 | } | ||
502 | |||
503 | // Unpack entropy codes | ||
504 |
2/2✓ Branch 0 taken 32122 times.
✓ Branch 1 taken 7856 times.
|
39978 | for (i = 0; i < c->nchannels; i++) { |
505 | int32_t *part_a, *part_b; | ||
506 | int nsamples_part_b; | ||
507 | |||
508 | // Select index of coding parameters | ||
509 |
2/2✓ Branch 0 taken 23363 times.
✓ Branch 1 taken 8759 times.
|
32122 | k = c->seg_common ? 0 : i; |
510 | |||
511 | // Slice the segment into parts A and B | ||
512 | 32122 | part_a = b->msb_sample_buffer[i] + seg * s->nsegsamples; | |
513 | 32122 | part_b = part_a + c->nsamples_part_a[k]; | |
514 | 32122 | nsamples_part_b = s->nsegsamples - c->nsamples_part_a[k]; | |
515 | |||
516 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 32122 times.
|
32122 | if (get_bits_left(&s->gb) < 0) |
517 | ✗ | return AVERROR_INVALIDDATA; | |
518 | |||
519 |
2/2✓ Branch 0 taken 7655 times.
✓ Branch 1 taken 24467 times.
|
32122 | if (!c->rice_code_flag[k]) { |
520 | // Linear codes | ||
521 | // Unpack all residuals of part A of segment 0 | ||
522 | 7655 | get_linear_array(&s->gb, part_a, c->nsamples_part_a[k], | |
523 | c->bitalloc_part_a[k]); | ||
524 | |||
525 | // Unpack all residuals of part B of segment 0 and others | ||
526 | 7655 | get_linear_array(&s->gb, part_b, nsamples_part_b, | |
527 | c->bitalloc_part_b[k]); | ||
528 | } else { | ||
529 | // Rice codes | ||
530 | // Unpack all residuals of part A of segment 0 | ||
531 | 24467 | get_rice_array(&s->gb, part_a, c->nsamples_part_a[k], | |
532 | c->bitalloc_part_a[k]); | ||
533 | |||
534 |
2/2✓ Branch 0 taken 906 times.
✓ Branch 1 taken 23561 times.
|
24467 | if (c->bitalloc_hybrid_linear[k]) { |
535 | // Hybrid Rice codes | ||
536 | // Unpack the number of isolated samples | ||
537 | 906 | int nisosamples = get_bits(&s->gb, s->nsegsamples_log2); | |
538 | |||
539 | // Set all locations to 0 | ||
540 | 906 | memset(part_b, 0, sizeof(*part_b) * nsamples_part_b); | |
541 | |||
542 | // Extract the locations of isolated samples and flag by -1 | ||
543 |
2/2✓ Branch 0 taken 5231 times.
✓ Branch 1 taken 906 times.
|
6137 | for (j = 0; j < nisosamples; j++) { |
544 | 5231 | int loc = get_bits(&s->gb, s->nsegsamples_log2); | |
545 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 5231 times.
|
5231 | if (loc >= nsamples_part_b) { |
546 | ✗ | av_log(s->avctx, AV_LOG_ERROR, "Invalid isolated sample location\n"); | |
547 | ✗ | return AVERROR_INVALIDDATA; | |
548 | } | ||
549 | 5231 | part_b[loc] = -1; | |
550 | } | ||
551 | |||
552 | // Unpack all residuals of part B of segment 0 and others | ||
553 |
2/2✓ Branch 0 taken 139527 times.
✓ Branch 1 taken 906 times.
|
140433 | for (j = 0; j < nsamples_part_b; j++) { |
554 |
2/2✓ Branch 0 taken 5231 times.
✓ Branch 1 taken 134296 times.
|
139527 | if (part_b[j]) |
555 | 5231 | part_b[j] = get_linear(&s->gb, c->bitalloc_hybrid_linear[k]); | |
556 | else | ||
557 | 134296 | part_b[j] = get_rice(&s->gb, c->bitalloc_part_b[k]); | |
558 | } | ||
559 | } else { | ||
560 | // Rice codes | ||
561 | // Unpack all residuals of part B of segment 0 and others | ||
562 | 23561 | get_rice_array(&s->gb, part_b, nsamples_part_b, c->bitalloc_part_b[k]); | |
563 | } | ||
564 | } | ||
565 | } | ||
566 | |||
567 | // Unpack decimator history for frequency band 1 | ||
568 |
4/4✓ Branch 0 taken 2646 times.
✓ Branch 1 taken 5210 times.
✓ Branch 2 taken 56 times.
✓ Branch 3 taken 2590 times.
|
7856 | if (seg == 0 && band == 1) { |
569 | 56 | int nbits = get_bits(&s->gb, 5) + 1; | |
570 |
2/2✓ Branch 0 taken 224 times.
✓ Branch 1 taken 56 times.
|
280 | for (i = 0; i < c->nchannels; i++) |
571 |
2/2✓ Branch 0 taken 1568 times.
✓ Branch 1 taken 224 times.
|
1792 | for (j = 1; j < DCA_XLL_DECI_HISTORY_MAX; j++) |
572 | 1568 | c->deci_history[i][j] = get_sbits_long(&s->gb, nbits); | |
573 | } | ||
574 | |||
575 | // Start unpacking LSB portion of the segment | ||
576 |
2/2✓ Branch 0 taken 428 times.
✓ Branch 1 taken 7428 times.
|
7856 | if (b->lsb_section_size) { |
577 | // Skip to the start of LSB portion | ||
578 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 428 times.
|
428 | if (ff_dca_seek_bits(&s->gb, band_data_end - b->lsb_section_size * 8)) { |
579 | ✗ | av_log(s->avctx, AV_LOG_ERROR, "Read past end of XLL band data\n"); | |
580 | ✗ | return AVERROR_INVALIDDATA; | |
581 | } | ||
582 | |||
583 | // Unpack all LSB parts of residuals of this segment | ||
584 |
2/2✓ Branch 0 taken 2120 times.
✓ Branch 1 taken 428 times.
|
2548 | for (i = 0; i < c->nchannels; i++) { |
585 |
2/2✓ Branch 0 taken 856 times.
✓ Branch 1 taken 1264 times.
|
2120 | if (b->nscalablelsbs[i]) { |
586 | 856 | get_array(&s->gb, | |
587 | 856 | b->lsb_sample_buffer[i] + seg * s->nsegsamples, | |
588 | s->nsegsamples, b->nscalablelsbs[i]); | ||
589 | } | ||
590 | } | ||
591 | } | ||
592 | |||
593 | // Skip to the end of band data | ||
594 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 7856 times.
|
7856 | if (ff_dca_seek_bits(&s->gb, band_data_end)) { |
595 | ✗ | av_log(s->avctx, AV_LOG_ERROR, "Read past end of XLL band data\n"); | |
596 | ✗ | return AVERROR_INVALIDDATA; | |
597 | } | ||
598 | |||
599 | 7856 | return 0; | |
600 | } | ||
601 | |||
602 | 68 | static av_cold void chs_clear_band_data(DCAXllDecoder *s, DCAXllChSet *c, int band, int seg) | |
603 | { | ||
604 | 68 | DCAXllBand *b = &c->bands[band]; | |
605 | int i, offset, nsamples; | ||
606 | |||
607 |
1/2✓ Branch 0 taken 68 times.
✗ Branch 1 not taken.
|
68 | if (seg < 0) { |
608 | 68 | offset = 0; | |
609 | 68 | nsamples = s->nframesamples; | |
610 | } else { | ||
611 | ✗ | offset = seg * s->nsegsamples; | |
612 | ✗ | nsamples = s->nsegsamples; | |
613 | } | ||
614 | |||
615 |
2/2✓ Branch 0 taken 254 times.
✓ Branch 1 taken 68 times.
|
322 | for (i = 0; i < c->nchannels; i++) { |
616 | 254 | memset(b->msb_sample_buffer[i] + offset, 0, nsamples * sizeof(int32_t)); | |
617 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 254 times.
|
254 | if (b->lsb_section_size) |
618 | ✗ | memset(b->lsb_sample_buffer[i] + offset, 0, nsamples * sizeof(int32_t)); | |
619 | } | ||
620 | |||
621 |
3/4✓ Branch 0 taken 68 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 10 times.
✓ Branch 3 taken 58 times.
|
68 | if (seg <= 0 && band) |
622 | 10 | memset(c->deci_history, 0, sizeof(c->deci_history)); | |
623 | |||
624 |
1/2✓ Branch 0 taken 68 times.
✗ Branch 1 not taken.
|
68 | if (seg < 0) { |
625 | 68 | memset(b->nscalablelsbs, 0, sizeof(b->nscalablelsbs)); | |
626 | 68 | memset(b->bit_width_adjust, 0, sizeof(b->bit_width_adjust)); | |
627 | } | ||
628 | 68 | } | |
629 | |||
630 | 2646 | static void chs_filter_band_data(DCAXllDecoder *s, DCAXllChSet *c, int band) | |
631 | { | ||
632 | 2646 | DCAXllBand *b = &c->bands[band]; | |
633 | 2646 | int nsamples = s->nframesamples; | |
634 | int i, j, k; | ||
635 | |||
636 | // Inverse adaptive or fixed prediction | ||
637 |
2/2✓ Branch 0 taken 10713 times.
✓ Branch 1 taken 2646 times.
|
13359 | for (i = 0; i < c->nchannels; i++) { |
638 | 10713 | int32_t *buf = b->msb_sample_buffer[i]; | |
639 | 10713 | int order = b->adapt_pred_order[i]; | |
640 |
2/2✓ Branch 0 taken 8897 times.
✓ Branch 1 taken 1816 times.
|
10713 | if (order > 0) { |
641 | int coeff[DCA_XLL_ADAPT_PRED_ORDER_MAX]; | ||
642 | // Conversion from reflection coefficients to direct form coefficients | ||
643 |
2/2✓ Branch 0 taken 41701 times.
✓ Branch 1 taken 8897 times.
|
50598 | for (j = 0; j < order; j++) { |
644 | 41701 | int rc = b->adapt_refl_coeff[i][j]; | |
645 |
2/2✓ Branch 0 taken 66925 times.
✓ Branch 1 taken 41701 times.
|
108626 | for (k = 0; k < (j + 1) / 2; k++) { |
646 | 66925 | int tmp1 = coeff[ k ]; | |
647 | 66925 | int tmp2 = coeff[j - k - 1]; | |
648 | 66925 | coeff[ k ] = tmp1 + mul16(rc, tmp2); | |
649 | 66925 | coeff[j - k - 1] = tmp2 + mul16(rc, tmp1); | |
650 | } | ||
651 | 41701 | coeff[j] = rc; | |
652 | } | ||
653 | // Inverse adaptive prediction | ||
654 |
2/2✓ Branch 0 taken 4662555 times.
✓ Branch 1 taken 8897 times.
|
4671452 | for (j = 0; j < nsamples - order; j++) { |
655 | 4662555 | int64_t err = 0; | |
656 |
2/2✓ Branch 0 taken 22250005 times.
✓ Branch 1 taken 4662555 times.
|
26912560 | for (k = 0; k < order; k++) |
657 | 22250005 | err += (int64_t)buf[j + k] * coeff[order - k - 1]; | |
658 | 4662555 | buf[j + k] -= (SUINT)clip23(norm16(err)); | |
659 | } | ||
660 | } else { | ||
661 | // Inverse fixed coefficient prediction | ||
662 |
2/2✓ Branch 0 taken 575 times.
✓ Branch 1 taken 1816 times.
|
2391 | for (j = 0; j < b->fixed_pred_order[i]; j++) |
663 |
2/2✓ Branch 0 taken 310721 times.
✓ Branch 1 taken 575 times.
|
311296 | for (k = 1; k < nsamples; k++) |
664 | 310721 | buf[k] += (unsigned)buf[k - 1]; | |
665 | } | ||
666 | } | ||
667 | |||
668 | // Inverse pairwise channel decorrellation | ||
669 |
2/2✓ Branch 0 taken 2639 times.
✓ Branch 1 taken 7 times.
|
2646 | if (b->decor_enabled) { |
670 | int32_t *tmp[DCA_XLL_CHANNELS_MAX]; | ||
671 | |||
672 |
2/2✓ Branch 0 taken 5353 times.
✓ Branch 1 taken 2639 times.
|
7992 | for (i = 0; i < c->nchannels / 2; i++) { |
673 | 5353 | int coeff = b->decor_coeff[i]; | |
674 |
2/2✓ Branch 0 taken 1815 times.
✓ Branch 1 taken 3538 times.
|
5353 | if (coeff) { |
675 | 1815 | s->dcadsp->decor(b->msb_sample_buffer[i * 2 + 1], | |
676 | 1815 | b->msb_sample_buffer[i * 2 ], | |
677 | coeff, nsamples); | ||
678 | } | ||
679 | } | ||
680 | |||
681 | // Reorder channel pointers to the original order | ||
682 |
2/2✓ Branch 0 taken 10706 times.
✓ Branch 1 taken 2639 times.
|
13345 | for (i = 0; i < c->nchannels; i++) |
683 | 10706 | tmp[i] = b->msb_sample_buffer[i]; | |
684 | |||
685 |
2/2✓ Branch 0 taken 10706 times.
✓ Branch 1 taken 2639 times.
|
13345 | for (i = 0; i < c->nchannels; i++) |
686 | 10706 | b->msb_sample_buffer[b->orig_order[i]] = tmp[i]; | |
687 | } | ||
688 | |||
689 | // Map output channel pointers for frequency band 0 | ||
690 |
2/2✓ Branch 0 taken 2534 times.
✓ Branch 1 taken 112 times.
|
2646 | if (c->nfreqbands == 1) |
691 |
2/2✓ Branch 0 taken 10265 times.
✓ Branch 1 taken 2534 times.
|
12799 | for (i = 0; i < c->nchannels; i++) |
692 | 10265 | s->output_samples[c->ch_remap[i]] = b->msb_sample_buffer[i]; | |
693 | 2646 | } | |
694 | |||
695 | 8500 | static int chs_get_lsb_width(DCAXllDecoder *s, DCAXllChSet *c, int band, int ch) | |
696 | { | ||
697 | 8500 | int adj = c->bands[band].bit_width_adjust[ch]; | |
698 | 8500 | int shift = c->bands[band].nscalablelsbs[ch]; | |
699 | |||
700 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 8500 times.
|
8500 | if (s->fixed_lsb_width) |
701 | ✗ | shift = s->fixed_lsb_width; | |
702 |
3/4✓ Branch 0 taken 200 times.
✓ Branch 1 taken 8300 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 200 times.
|
8500 | else if (shift && adj) |
703 | ✗ | shift += adj - 1; | |
704 | else | ||
705 | 8500 | shift += adj; | |
706 | |||
707 | 8500 | return shift; | |
708 | } | ||
709 | |||
710 | 192 | static void chs_assemble_msbs_lsbs(DCAXllDecoder *s, DCAXllChSet *c, int band) | |
711 | { | ||
712 | 192 | DCAXllBand *b = &c->bands[band]; | |
713 | 192 | int n, ch, nsamples = s->nframesamples; | |
714 | |||
715 |
2/2✓ Branch 0 taken 795 times.
✓ Branch 1 taken 192 times.
|
987 | for (ch = 0; ch < c->nchannels; ch++) { |
716 | 795 | int shift = chs_get_lsb_width(s, c, band, ch); | |
717 |
2/2✓ Branch 0 taken 112 times.
✓ Branch 1 taken 683 times.
|
795 | if (shift) { |
718 | 112 | int32_t *msb = b->msb_sample_buffer[ch]; | |
719 |
1/2✓ Branch 0 taken 112 times.
✗ Branch 1 not taken.
|
112 | if (b->nscalablelsbs[ch]) { |
720 | 112 | int32_t *lsb = b->lsb_sample_buffer[ch]; | |
721 | 112 | int adj = b->bit_width_adjust[ch]; | |
722 |
2/2✓ Branch 0 taken 69632 times.
✓ Branch 1 taken 112 times.
|
69744 | for (n = 0; n < nsamples; n++) |
723 | 69632 | msb[n] = msb[n] * (SUINT)(1 << shift) + (lsb[n] << adj); | |
724 | } else { | ||
725 | ✗ | for (n = 0; n < nsamples; n++) | |
726 | ✗ | msb[n] = msb[n] * (SUINT)(1 << shift); | |
727 | } | ||
728 | } | ||
729 | } | ||
730 | 192 | } | |
731 | |||
732 | 56 | static int chs_assemble_freq_bands(DCAXllDecoder *s, DCAXllChSet *c) | |
733 | { | ||
734 | 56 | int ch, nsamples = s->nframesamples; | |
735 | int32_t *ptr; | ||
736 | |||
737 | av_assert1(c->nfreqbands > 1); | ||
738 | |||
739 | // Reallocate frequency band assembly buffer | ||
740 | 56 | av_fast_malloc(&c->sample_buffer[2], &c->sample_size[2], | |
741 | 56 | 2 * nsamples * c->nchannels * sizeof(int32_t)); | |
742 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 56 times.
|
56 | if (!c->sample_buffer[2]) |
743 | ✗ | return AVERROR(ENOMEM); | |
744 | |||
745 | // Assemble frequency bands 0 and 1 | ||
746 | 56 | ptr = c->sample_buffer[2]; | |
747 |
2/2✓ Branch 0 taken 224 times.
✓ Branch 1 taken 56 times.
|
280 | for (ch = 0; ch < c->nchannels; ch++) { |
748 | 224 | int32_t *band0 = c->bands[0].msb_sample_buffer[ch]; | |
749 | 224 | int32_t *band1 = c->bands[1].msb_sample_buffer[ch]; | |
750 | |||
751 | // Copy decimator history | ||
752 | 224 | memcpy(band0 - DCA_XLL_DECI_HISTORY_MAX, | |
753 | 224 | c->deci_history[ch], sizeof(c->deci_history[0])); | |
754 | |||
755 | // Filter | ||
756 | 224 | s->dcadsp->assemble_freq_bands(ptr, band0, band1, | |
757 | ff_dca_xll_band_coeff, | ||
758 | nsamples); | ||
759 | |||
760 | // Remap output channel pointer to assembly buffer | ||
761 | 224 | s->output_samples[c->ch_remap[ch]] = ptr; | |
762 | 224 | ptr += nsamples * 2; | |
763 | } | ||
764 | |||
765 | 56 | return 0; | |
766 | } | ||
767 | |||
768 | 1357 | static int parse_common_header(DCAXllDecoder *s) | |
769 | { | ||
770 | int stream_ver, header_size, frame_size_nbits, nframesegs_log2; | ||
771 | |||
772 | // XLL extension sync word | ||
773 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 1357 times.
|
1357 | if (get_bits_long(&s->gb, 32) != DCA_SYNCWORD_XLL) { |
774 | ✗ | av_log(s->avctx, AV_LOG_VERBOSE, "Invalid XLL sync word\n"); | |
775 | ✗ | return AVERROR(EAGAIN); | |
776 | } | ||
777 | |||
778 | // Version number | ||
779 | 1357 | stream_ver = get_bits(&s->gb, 4) + 1; | |
780 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1357 times.
|
1357 | if (stream_ver > 1) { |
781 | ✗ | avpriv_request_sample(s->avctx, "XLL stream version %d", stream_ver); | |
782 | ✗ | return AVERROR_PATCHWELCOME; | |
783 | } | ||
784 | |||
785 | // Lossless frame header length | ||
786 | 1357 | header_size = get_bits(&s->gb, 8) + 1; | |
787 | |||
788 | // Check CRC | ||
789 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 1357 times.
|
1357 | if (ff_dca_check_crc(s->avctx, &s->gb, 32, header_size * 8)) { |
790 | ✗ | av_log(s->avctx, AV_LOG_ERROR, "Invalid XLL common header checksum\n"); | |
791 | ✗ | return AVERROR_INVALIDDATA; | |
792 | } | ||
793 | |||
794 | // Number of bits used to read frame size | ||
795 | 1357 | frame_size_nbits = get_bits(&s->gb, 5) + 1; | |
796 | |||
797 | // Number of bytes in a lossless frame | ||
798 | 1357 | s->frame_size = get_bits_long(&s->gb, frame_size_nbits); | |
799 |
2/4✓ Branch 0 taken 1357 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 1357 times.
|
1357 | if (s->frame_size < 0 || s->frame_size >= DCA_XLL_PBR_BUFFER_MAX) { |
800 | ✗ | av_log(s->avctx, AV_LOG_ERROR, "Invalid XLL frame size (%d bytes)\n", s->frame_size); | |
801 | ✗ | return AVERROR_INVALIDDATA; | |
802 | } | ||
803 | 1357 | s->frame_size++; | |
804 | |||
805 | // Number of channels sets per frame | ||
806 | 1357 | s->nchsets = get_bits(&s->gb, 4) + 1; | |
807 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1357 times.
|
1357 | if (s->nchsets > DCA_XLL_CHSETS_MAX) { |
808 | ✗ | avpriv_request_sample(s->avctx, "%d XLL channel sets", s->nchsets); | |
809 | ✗ | return AVERROR_PATCHWELCOME; | |
810 | } | ||
811 | |||
812 | // Number of segments per frame | ||
813 | 1357 | nframesegs_log2 = get_bits(&s->gb, 4); | |
814 | 1357 | s->nframesegs = 1 << nframesegs_log2; | |
815 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1357 times.
|
1357 | if (s->nframesegs > 1024) { |
816 | ✗ | av_log(s->avctx, AV_LOG_ERROR, "Too many segments per XLL frame\n"); | |
817 | ✗ | return AVERROR_INVALIDDATA; | |
818 | } | ||
819 | |||
820 | // Samples in segment per one frequency band for the first channel set | ||
821 | // Maximum value is 256 for sampling frequencies <= 48 kHz | ||
822 | // Maximum value is 512 for sampling frequencies > 48 kHz | ||
823 | 1357 | s->nsegsamples_log2 = get_bits(&s->gb, 4); | |
824 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1357 times.
|
1357 | if (!s->nsegsamples_log2) { |
825 | ✗ | av_log(s->avctx, AV_LOG_ERROR, "Too few samples per XLL segment\n"); | |
826 | ✗ | return AVERROR_INVALIDDATA; | |
827 | } | ||
828 | 1357 | s->nsegsamples = 1 << s->nsegsamples_log2; | |
829 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1357 times.
|
1357 | if (s->nsegsamples > 512) { |
830 | ✗ | av_log(s->avctx, AV_LOG_ERROR, "Too many samples per XLL segment\n"); | |
831 | ✗ | return AVERROR_INVALIDDATA; | |
832 | } | ||
833 | |||
834 | // Samples in frame per one frequency band for the first channel set | ||
835 | 1357 | s->nframesamples_log2 = s->nsegsamples_log2 + nframesegs_log2; | |
836 | 1357 | s->nframesamples = 1 << s->nframesamples_log2; | |
837 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1357 times.
|
1357 | if (s->nframesamples > 65536) { |
838 | ✗ | av_log(s->avctx, AV_LOG_ERROR, "Too many samples per XLL frame\n"); | |
839 | ✗ | return AVERROR_INVALIDDATA; | |
840 | } | ||
841 | |||
842 | // Number of bits used to read segment size | ||
843 | 1357 | s->seg_size_nbits = get_bits(&s->gb, 5) + 1; | |
844 | |||
845 | // Presence of CRC16 within each frequency band | ||
846 | // 0 - No CRC16 within band | ||
847 | // 1 - CRC16 placed at the end of MSB0 | ||
848 | // 2 - CRC16 placed at the end of MSB0 and LSB0 | ||
849 | // 3 - CRC16 placed at the end of MSB0 and LSB0 and other frequency bands | ||
850 | 1357 | s->band_crc_present = get_bits(&s->gb, 2); | |
851 | |||
852 | // MSB/LSB split flag | ||
853 | 1357 | s->scalable_lsbs = get_bits1(&s->gb); | |
854 | |||
855 | // Channel position mask | ||
856 | 1357 | s->ch_mask_nbits = get_bits(&s->gb, 5) + 1; | |
857 | |||
858 | // Fixed LSB width | ||
859 |
2/2✓ Branch 0 taken 126 times.
✓ Branch 1 taken 1231 times.
|
1357 | if (s->scalable_lsbs) |
860 | 126 | s->fixed_lsb_width = get_bits(&s->gb, 4); | |
861 | else | ||
862 | 1231 | s->fixed_lsb_width = 0; | |
863 | |||
864 | // Reserved | ||
865 | // Byte align | ||
866 | // Header CRC16 protection | ||
867 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 1357 times.
|
1357 | if (ff_dca_seek_bits(&s->gb, header_size * 8)) { |
868 | ✗ | av_log(s->avctx, AV_LOG_ERROR, "Read past end of XLL common header\n"); | |
869 | ✗ | return AVERROR_INVALIDDATA; | |
870 | } | ||
871 | |||
872 | 1357 | return 0; | |
873 | } | ||
874 | |||
875 | 3883 | static int is_hier_dmix_chset(DCAXllChSet *c) | |
876 | { | ||
877 |
4/6✓ Branch 0 taken 3883 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 276 times.
✓ Branch 3 taken 3607 times.
✓ Branch 4 taken 276 times.
✗ Branch 5 not taken.
|
3883 | return !c->primary_chset && c->dmix_embedded && c->hier_chset; |
878 | } | ||
879 | |||
880 | 1458 | static DCAXllChSet *find_next_hier_dmix_chset(DCAXllDecoder *s, DCAXllChSet *c) | |
881 | { | ||
882 |
1/2✓ Branch 0 taken 1458 times.
✗ Branch 1 not taken.
|
1458 | if (c->hier_chset) |
883 |
2/2✓ Branch 0 taken 1282 times.
✓ Branch 1 taken 1393 times.
|
2675 | while (++c < &s->chset[s->nchsets]) |
884 |
2/2✓ Branch 1 taken 65 times.
✓ Branch 2 taken 1217 times.
|
1282 | if (is_hier_dmix_chset(c)) |
885 | 65 | return c; | |
886 | |||
887 | 1393 | return NULL; | |
888 | } | ||
889 | |||
890 | 21 | static void prescale_down_mix(DCAXllChSet *c, DCAXllChSet *o) | |
891 | { | ||
892 | 21 | int i, j, *coeff_ptr = c->dmix_coeff; | |
893 | |||
894 |
2/2✓ Branch 0 taken 42 times.
✓ Branch 1 taken 21 times.
|
63 | for (i = 0; i < c->hier_ofs; i++) { |
895 | 42 | int scale = o->dmix_scale[i]; | |
896 | 42 | int scale_inv = o->dmix_scale_inv[i]; | |
897 | 42 | c->dmix_scale[i] = mul15(c->dmix_scale[i], scale); | |
898 | 42 | c->dmix_scale_inv[i] = mul16(c->dmix_scale_inv[i], scale_inv); | |
899 |
2/2✓ Branch 0 taken 168 times.
✓ Branch 1 taken 42 times.
|
210 | for (j = 0; j < c->nchannels; j++) { |
900 | 168 | int coeff = mul16(*coeff_ptr, scale_inv); | |
901 | 168 | *coeff_ptr++ = mul15(coeff, o->dmix_scale[c->hier_ofs + j]); | |
902 | } | ||
903 | } | ||
904 | 21 | } | |
905 | |||
906 | 1357 | static int parse_sub_headers(DCAXllDecoder *s, DCAExssAsset *asset) | |
907 | { | ||
908 | 1357 | DCAContext *dca = s->avctx->priv_data; | |
909 | DCAXllChSet *c; | ||
910 | int i, ret; | ||
911 | |||
912 | // Parse channel set headers | ||
913 | 1357 | s->nfreqbands = 0; | |
914 | 1357 | s->nchannels = 0; | |
915 | 1357 | s->nreschsets = 0; | |
916 |
2/2✓ Branch 0 taken 2660 times.
✓ Branch 1 taken 1357 times.
|
4017 | for (i = 0, c = s->chset; i < s->nchsets; i++, c++) { |
917 | 2660 | c->hier_ofs = s->nchannels; | |
918 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 2660 times.
|
2660 | if ((ret = chs_parse_header(s, c, asset)) < 0) |
919 | ✗ | return ret; | |
920 |
2/2✓ Branch 0 taken 1357 times.
✓ Branch 1 taken 1303 times.
|
2660 | if (c->nfreqbands > s->nfreqbands) |
921 | 1357 | s->nfreqbands = c->nfreqbands; | |
922 |
1/2✓ Branch 0 taken 2660 times.
✗ Branch 1 not taken.
|
2660 | if (c->hier_chset) |
923 | 2660 | s->nchannels += c->nchannels; | |
924 |
2/2✓ Branch 0 taken 1345 times.
✓ Branch 1 taken 1315 times.
|
2660 | if (c->residual_encode != (1 << c->nchannels) - 1) |
925 | 1345 | s->nreschsets++; | |
926 | } | ||
927 | |||
928 | // Pre-scale downmixing coefficients for all non-primary channel sets | ||
929 |
2/2✓ Branch 0 taken 1303 times.
✓ Branch 1 taken 1357 times.
|
2660 | for (i = s->nchsets - 1, c = &s->chset[i]; i > 0; i--, c--) { |
930 |
2/2✓ Branch 1 taken 126 times.
✓ Branch 2 taken 1177 times.
|
1303 | if (is_hier_dmix_chset(c)) { |
931 | 126 | DCAXllChSet *o = find_next_hier_dmix_chset(s, c); | |
932 |
2/2✓ Branch 0 taken 21 times.
✓ Branch 1 taken 105 times.
|
126 | if (o) |
933 | 21 | prescale_down_mix(c, o); | |
934 | } | ||
935 | } | ||
936 | |||
937 | // Determine number of active channel sets to decode | ||
938 |
3/3✓ Branch 0 taken 60 times.
✓ Branch 1 taken 60 times.
✓ Branch 2 taken 1237 times.
|
1357 | switch (dca->request_channel_layout) { |
939 | 60 | case DCA_SPEAKER_LAYOUT_STEREO: | |
940 | 60 | s->nactivechsets = 1; | |
941 | 60 | break; | |
942 | 60 | case DCA_SPEAKER_LAYOUT_5POINT0: | |
943 | case DCA_SPEAKER_LAYOUT_5POINT1: | ||
944 |
3/4✓ Branch 0 taken 14 times.
✓ Branch 1 taken 46 times.
✓ Branch 2 taken 14 times.
✗ Branch 3 not taken.
|
60 | s->nactivechsets = (s->chset[0].nchannels < 5 && s->nchsets > 1) ? 2 : 1; |
945 | 60 | break; | |
946 | 1237 | default: | |
947 | 1237 | s->nactivechsets = s->nchsets; | |
948 | 1237 | break; | |
949 | } | ||
950 | |||
951 | 1357 | return 0; | |
952 | } | ||
953 | |||
954 | 1357 | static int parse_navi_table(DCAXllDecoder *s) | |
955 | { | ||
956 | int chs, seg, band, navi_nb, navi_pos, *navi_ptr; | ||
957 | DCAXllChSet *c; | ||
958 | |||
959 | // Determine size of NAVI table | ||
960 | 1357 | navi_nb = s->nfreqbands * s->nframesegs * s->nchsets; | |
961 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1357 times.
|
1357 | if (navi_nb > 1024) { |
962 | ✗ | av_log(s->avctx, AV_LOG_ERROR, "Too many NAVI entries (%d)\n", navi_nb); | |
963 | ✗ | return AVERROR_INVALIDDATA; | |
964 | } | ||
965 | |||
966 | // Reallocate NAVI table | ||
967 | 1357 | av_fast_malloc(&s->navi, &s->navi_size, navi_nb * sizeof(*s->navi)); | |
968 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1357 times.
|
1357 | if (!s->navi) |
969 | ✗ | return AVERROR(ENOMEM); | |
970 | |||
971 | // Parse NAVI | ||
972 | 1357 | navi_pos = get_bits_count(&s->gb); | |
973 | 1357 | navi_ptr = s->navi; | |
974 |
2/2✓ Branch 0 taken 1399 times.
✓ Branch 1 taken 1357 times.
|
2756 | for (band = 0; band < s->nfreqbands; band++) { |
975 |
2/2✓ Branch 0 taken 4356 times.
✓ Branch 1 taken 1399 times.
|
5755 | for (seg = 0; seg < s->nframesegs; seg++) { |
976 |
2/2✓ Branch 0 taken 8274 times.
✓ Branch 1 taken 4356 times.
|
12630 | for (chs = 0, c = s->chset; chs < s->nchsets; chs++, c++) { |
977 | 8274 | int size = 0; | |
978 |
1/2✓ Branch 0 taken 8274 times.
✗ Branch 1 not taken.
|
8274 | if (c->nfreqbands > band) { |
979 | 8274 | size = get_bits_long(&s->gb, s->seg_size_nbits); | |
980 |
2/4✓ Branch 0 taken 8274 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 8274 times.
|
8274 | if (size < 0 || size >= s->frame_size) { |
981 | ✗ | av_log(s->avctx, AV_LOG_ERROR, "Invalid NAVI segment size (%d bytes)\n", size); | |
982 | ✗ | return AVERROR_INVALIDDATA; | |
983 | } | ||
984 | 8274 | size++; | |
985 | } | ||
986 | 8274 | *navi_ptr++ = size; | |
987 | } | ||
988 | } | ||
989 | } | ||
990 | |||
991 | // Byte align | ||
992 | // CRC16 | ||
993 | 1357 | skip_bits(&s->gb, -get_bits_count(&s->gb) & 7); | |
994 | 1357 | skip_bits(&s->gb, 16); | |
995 | |||
996 | // Check CRC | ||
997 |
1/2✗ Branch 2 not taken.
✓ Branch 3 taken 1357 times.
|
1357 | if (ff_dca_check_crc(s->avctx, &s->gb, navi_pos, get_bits_count(&s->gb))) { |
998 | ✗ | av_log(s->avctx, AV_LOG_ERROR, "Invalid NAVI checksum\n"); | |
999 | ✗ | return AVERROR_INVALIDDATA; | |
1000 | } | ||
1001 | |||
1002 | 1357 | return 0; | |
1003 | } | ||
1004 | |||
1005 | 1357 | static int parse_band_data(DCAXllDecoder *s) | |
1006 | { | ||
1007 | int ret, chs, seg, band, navi_pos, *navi_ptr; | ||
1008 | DCAXllChSet *c; | ||
1009 | |||
1010 |
2/2✓ Branch 0 taken 2590 times.
✓ Branch 1 taken 1357 times.
|
3947 | for (chs = 0, c = s->chset; chs < s->nactivechsets; chs++, c++) { |
1011 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 2590 times.
|
2590 | if ((ret = chs_alloc_msb_band_data(s, c)) < 0) |
1012 | ✗ | return ret; | |
1013 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 2590 times.
|
2590 | if ((ret = chs_alloc_lsb_band_data(s, c)) < 0) |
1014 | ✗ | return ret; | |
1015 | } | ||
1016 | |||
1017 | 1357 | navi_pos = get_bits_count(&s->gb); | |
1018 | 1357 | navi_ptr = s->navi; | |
1019 |
2/2✓ Branch 0 taken 1399 times.
✓ Branch 1 taken 1357 times.
|
2756 | for (band = 0; band < s->nfreqbands; band++) { |
1020 |
2/2✓ Branch 0 taken 4356 times.
✓ Branch 1 taken 1399 times.
|
5755 | for (seg = 0; seg < s->nframesegs; seg++) { |
1021 |
2/2✓ Branch 0 taken 8274 times.
✓ Branch 1 taken 4356 times.
|
12630 | for (chs = 0, c = s->chset; chs < s->nchsets; chs++, c++) { |
1022 |
1/2✓ Branch 0 taken 8274 times.
✗ Branch 1 not taken.
|
8274 | if (c->nfreqbands > band) { |
1023 | 8274 | navi_pos += *navi_ptr * 8; | |
1024 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 8274 times.
|
8274 | if (navi_pos > s->gb.size_in_bits) { |
1025 | ✗ | av_log(s->avctx, AV_LOG_ERROR, "Invalid NAVI position\n"); | |
1026 | ✗ | return AVERROR_INVALIDDATA; | |
1027 | } | ||
1028 |
3/4✓ Branch 0 taken 7856 times.
✓ Branch 1 taken 418 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 7856 times.
|
16130 | if (chs < s->nactivechsets && |
1029 | 7856 | (ret = chs_parse_band_data(s, c, band, seg, navi_pos)) < 0) { | |
1030 | ✗ | if (s->avctx->err_recognition & AV_EF_EXPLODE) | |
1031 | ✗ | return ret; | |
1032 | ✗ | chs_clear_band_data(s, c, band, seg); | |
1033 | } | ||
1034 | 8274 | skip_bits_long(&s->gb, navi_pos - get_bits_count(&s->gb)); | |
1035 | } | ||
1036 | 8274 | navi_ptr++; | |
1037 | } | ||
1038 | } | ||
1039 | } | ||
1040 | |||
1041 | 1357 | return 0; | |
1042 | } | ||
1043 | |||
1044 | 1357 | static int parse_frame(DCAXllDecoder *s, const uint8_t *data, int size, DCAExssAsset *asset) | |
1045 | { | ||
1046 | int ret; | ||
1047 | |||
1048 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 1357 times.
|
1357 | if ((ret = init_get_bits8(&s->gb, data, size)) < 0) |
1049 | ✗ | return ret; | |
1050 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 1357 times.
|
1357 | if ((ret = parse_common_header(s)) < 0) |
1051 | ✗ | return ret; | |
1052 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 1357 times.
|
1357 | if ((ret = parse_sub_headers(s, asset)) < 0) |
1053 | ✗ | return ret; | |
1054 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 1357 times.
|
1357 | if ((ret = parse_navi_table(s)) < 0) |
1055 | ✗ | return ret; | |
1056 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 1357 times.
|
1357 | if ((ret = parse_band_data(s)) < 0) |
1057 | ✗ | return ret; | |
1058 | |||
1059 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 1357 times.
|
1357 | if (s->frame_size * 8 > FFALIGN(get_bits_count(&s->gb), 32)) { |
1060 | unsigned int extradata_syncword; | ||
1061 | |||
1062 | // Align to dword | ||
1063 | ✗ | skip_bits_long(&s->gb, -get_bits_count(&s->gb) & 31); | |
1064 | |||
1065 | ✗ | extradata_syncword = show_bits_long(&s->gb, 32); | |
1066 | |||
1067 | ✗ | if (extradata_syncword == DCA_SYNCWORD_XLL_X) { | |
1068 | ✗ | s->x_syncword_present = 1; | |
1069 | ✗ | } else if ((extradata_syncword >> 1) == (DCA_SYNCWORD_XLL_X_IMAX >> 1)) { | |
1070 | ✗ | s->x_imax_syncword_present = 1; | |
1071 | } | ||
1072 | } | ||
1073 | |||
1074 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 1357 times.
|
1357 | if (ff_dca_seek_bits(&s->gb, s->frame_size * 8)) { |
1075 | ✗ | av_log(s->avctx, AV_LOG_ERROR, "Read past end of XLL frame\n"); | |
1076 | ✗ | return AVERROR_INVALIDDATA; | |
1077 | } | ||
1078 | 1357 | return ret; | |
1079 | } | ||
1080 | |||
1081 | 99 | static void clear_pbr(DCAXllDecoder *s) | |
1082 | { | ||
1083 | 99 | s->pbr_length = 0; | |
1084 | 99 | s->pbr_delay = 0; | |
1085 | 99 | } | |
1086 | |||
1087 | ✗ | static int copy_to_pbr(DCAXllDecoder *s, const uint8_t *data, int size, int delay) | |
1088 | { | ||
1089 | ✗ | if (size > DCA_XLL_PBR_BUFFER_MAX) | |
1090 | ✗ | return AVERROR(ENOSPC); | |
1091 | |||
1092 | ✗ | if (!s->pbr_buffer && !(s->pbr_buffer = av_malloc(DCA_XLL_PBR_BUFFER_MAX + AV_INPUT_BUFFER_PADDING_SIZE))) | |
1093 | ✗ | return AVERROR(ENOMEM); | |
1094 | |||
1095 | ✗ | memcpy(s->pbr_buffer, data, size); | |
1096 | ✗ | s->pbr_length = size; | |
1097 | ✗ | s->pbr_delay = delay; | |
1098 | ✗ | return 0; | |
1099 | } | ||
1100 | |||
1101 | 1357 | static int parse_frame_no_pbr(DCAXllDecoder *s, const uint8_t *data, int size, DCAExssAsset *asset) | |
1102 | { | ||
1103 | 1357 | int ret = parse_frame(s, data, size, asset); | |
1104 | |||
1105 | // If XLL packet data didn't start with a sync word, we must have jumped | ||
1106 | // right into the middle of PBR smoothing period | ||
1107 |
1/6✗ Branch 0 not taken.
✓ Branch 1 taken 1357 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
|
1357 | if (ret == AVERROR(EAGAIN) && asset->xll_sync_present && asset->xll_sync_offset < size) { |
1108 | // Skip to the next sync word in this packet | ||
1109 | ✗ | data += asset->xll_sync_offset; | |
1110 | ✗ | size -= asset->xll_sync_offset; | |
1111 | |||
1112 | // If decoding delay is set, put the frame into PBR buffer and return | ||
1113 | // failure code. Higher level decoder is expected to switch to lossy | ||
1114 | // core decoding or mute its output until decoding delay expires. | ||
1115 | ✗ | if (asset->xll_delay_nframes > 0) { | |
1116 | ✗ | if ((ret = copy_to_pbr(s, data, size, asset->xll_delay_nframes)) < 0) | |
1117 | ✗ | return ret; | |
1118 | ✗ | return AVERROR(EAGAIN); | |
1119 | } | ||
1120 | |||
1121 | // No decoding delay, just parse the frame in place | ||
1122 | ✗ | ret = parse_frame(s, data, size, asset); | |
1123 | } | ||
1124 | |||
1125 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1357 times.
|
1357 | if (ret < 0) |
1126 | ✗ | return ret; | |
1127 | |||
1128 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1357 times.
|
1357 | if (s->frame_size > size) |
1129 | ✗ | return AVERROR(EINVAL); | |
1130 | |||
1131 | // If the XLL decoder didn't consume full packet, start PBR smoothing period | ||
1132 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1357 times.
|
1357 | if (s->frame_size < size) |
1133 | ✗ | if ((ret = copy_to_pbr(s, data + s->frame_size, size - s->frame_size, 0)) < 0) | |
1134 | ✗ | return ret; | |
1135 | |||
1136 | 1357 | return 0; | |
1137 | } | ||
1138 | |||
1139 | ✗ | static int parse_frame_pbr(DCAXllDecoder *s, const uint8_t *data, int size, DCAExssAsset *asset) | |
1140 | { | ||
1141 | int ret; | ||
1142 | |||
1143 | ✗ | if (size > DCA_XLL_PBR_BUFFER_MAX - s->pbr_length) { | |
1144 | ✗ | ret = AVERROR(ENOSPC); | |
1145 | ✗ | goto fail; | |
1146 | } | ||
1147 | |||
1148 | ✗ | memcpy(s->pbr_buffer + s->pbr_length, data, size); | |
1149 | ✗ | s->pbr_length += size; | |
1150 | |||
1151 | // Respect decoding delay after synchronization error | ||
1152 | ✗ | if (s->pbr_delay > 0 && --s->pbr_delay) | |
1153 | ✗ | return AVERROR(EAGAIN); | |
1154 | |||
1155 | ✗ | if ((ret = parse_frame(s, s->pbr_buffer, s->pbr_length, asset)) < 0) | |
1156 | ✗ | goto fail; | |
1157 | |||
1158 | ✗ | if (s->frame_size > s->pbr_length) { | |
1159 | ✗ | ret = AVERROR(EINVAL); | |
1160 | ✗ | goto fail; | |
1161 | } | ||
1162 | |||
1163 | ✗ | if (s->frame_size == s->pbr_length) { | |
1164 | // End of PBR smoothing period | ||
1165 | ✗ | clear_pbr(s); | |
1166 | } else { | ||
1167 | ✗ | s->pbr_length -= s->frame_size; | |
1168 | ✗ | memmove(s->pbr_buffer, s->pbr_buffer + s->frame_size, s->pbr_length); | |
1169 | } | ||
1170 | |||
1171 | ✗ | return 0; | |
1172 | |||
1173 | ✗ | fail: | |
1174 | // For now, throw out all PBR state on failure. | ||
1175 | // Perhaps we can be smarter and try to resync somehow. | ||
1176 | ✗ | clear_pbr(s); | |
1177 | ✗ | return ret; | |
1178 | } | ||
1179 | |||
1180 | 1357 | int ff_dca_xll_parse(DCAXllDecoder *s, const uint8_t *data, DCAExssAsset *asset) | |
1181 | { | ||
1182 | int ret; | ||
1183 | |||
1184 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1357 times.
|
1357 | if (s->hd_stream_id != asset->hd_stream_id) { |
1185 | ✗ | clear_pbr(s); | |
1186 | ✗ | s->hd_stream_id = asset->hd_stream_id; | |
1187 | } | ||
1188 | |||
1189 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1357 times.
|
1357 | if (s->pbr_length) |
1190 | ✗ | ret = parse_frame_pbr(s, data + asset->xll_offset, asset->xll_size, asset); | |
1191 | else | ||
1192 | 1357 | ret = parse_frame_no_pbr(s, data + asset->xll_offset, asset->xll_size, asset); | |
1193 | |||
1194 | 1357 | return ret; | |
1195 | } | ||
1196 | |||
1197 | 50 | static void undo_down_mix(DCAXllDecoder *s, DCAXllChSet *o, int band) | |
1198 | { | ||
1199 | 50 | int i, j, k, nchannels = 0, *coeff_ptr = o->dmix_coeff; | |
1200 | DCAXllChSet *c; | ||
1201 | |||
1202 |
1/2✓ Branch 0 taken 55 times.
✗ Branch 1 not taken.
|
55 | for (i = 0, c = s->chset; i < s->nactivechsets; i++, c++) { |
1203 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 55 times.
|
55 | if (!c->hier_chset) |
1204 | ✗ | continue; | |
1205 | |||
1206 | av_assert1(band < c->nfreqbands); | ||
1207 |
2/2✓ Branch 0 taken 180 times.
✓ Branch 1 taken 55 times.
|
235 | for (j = 0; j < c->nchannels; j++) { |
1208 |
2/2✓ Branch 0 taken 450 times.
✓ Branch 1 taken 180 times.
|
630 | for (k = 0; k < o->nchannels; k++) { |
1209 | 450 | int coeff = *coeff_ptr++; | |
1210 |
2/2✓ Branch 0 taken 100 times.
✓ Branch 1 taken 350 times.
|
450 | if (coeff) { |
1211 | 100 | s->dcadsp->dmix_sub(c->bands[band].msb_sample_buffer[j], | |
1212 | 100 | o->bands[band].msb_sample_buffer[k], | |
1213 | 100 | coeff, s->nframesamples); | |
1214 |
2/2✓ Branch 0 taken 20 times.
✓ Branch 1 taken 80 times.
|
100 | if (band) |
1215 | 20 | s->dcadsp->dmix_sub(c->deci_history[j], | |
1216 | 20 | o->deci_history[k], | |
1217 | coeff, DCA_XLL_DECI_HISTORY_MAX); | ||
1218 | } | ||
1219 | } | ||
1220 | } | ||
1221 | |||
1222 | 55 | nchannels += c->nchannels; | |
1223 |
2/2✓ Branch 0 taken 50 times.
✓ Branch 1 taken 5 times.
|
55 | if (nchannels >= o->hier_ofs) |
1224 | 50 | break; | |
1225 | } | ||
1226 | 50 | } | |
1227 | |||
1228 | 50 | static void scale_down_mix(DCAXllDecoder *s, DCAXllChSet *o, int band) | |
1229 | { | ||
1230 | 50 | int i, j, nchannels = 0; | |
1231 | DCAXllChSet *c; | ||
1232 | |||
1233 |
1/2✓ Branch 0 taken 55 times.
✗ Branch 1 not taken.
|
55 | for (i = 0, c = s->chset; i < s->nactivechsets; i++, c++) { |
1234 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 55 times.
|
55 | if (!c->hier_chset) |
1235 | ✗ | continue; | |
1236 | |||
1237 | av_assert1(band < c->nfreqbands); | ||
1238 |
2/2✓ Branch 0 taken 240 times.
✓ Branch 1 taken 55 times.
|
295 | for (j = 0; j < c->nchannels; j++) { |
1239 | 240 | int scale = o->dmix_scale[nchannels++]; | |
1240 |
2/2✓ Branch 0 taken 180 times.
✓ Branch 1 taken 60 times.
|
240 | if (scale != (1 << 15)) { |
1241 | 180 | s->dcadsp->dmix_scale(c->bands[band].msb_sample_buffer[j], | |
1242 | 180 | scale, s->nframesamples); | |
1243 |
2/2✓ Branch 0 taken 10 times.
✓ Branch 1 taken 170 times.
|
180 | if (band) |
1244 | 10 | s->dcadsp->dmix_scale(c->deci_history[j], | |
1245 | scale, DCA_XLL_DECI_HISTORY_MAX); | ||
1246 | } | ||
1247 | } | ||
1248 | |||
1249 |
2/2✓ Branch 0 taken 50 times.
✓ Branch 1 taken 5 times.
|
55 | if (nchannels >= o->hier_ofs) |
1250 | 50 | break; | |
1251 | } | ||
1252 | 50 | } | |
1253 | |||
1254 | // Clear all band data and replace non-residual encoded channels with lossy | ||
1255 | // counterparts | ||
1256 | 58 | static av_cold void force_lossy_output(DCAXllDecoder *s, DCAXllChSet *c) | |
1257 | { | ||
1258 | 58 | DCAContext *dca = s->avctx->priv_data; | |
1259 | int band, ch; | ||
1260 | |||
1261 |
2/2✓ Branch 0 taken 68 times.
✓ Branch 1 taken 58 times.
|
126 | for (band = 0; band < c->nfreqbands; band++) |
1262 | 68 | chs_clear_band_data(s, c, band, -1); | |
1263 | |||
1264 |
2/2✓ Branch 0 taken 226 times.
✓ Branch 1 taken 58 times.
|
284 | for (ch = 0; ch < c->nchannels; ch++) { |
1265 |
2/2✓ Branch 0 taken 156 times.
✓ Branch 1 taken 70 times.
|
226 | if (!(c->residual_encode & (1 << ch))) |
1266 | 156 | continue; | |
1267 |
2/2✓ Branch 1 taken 24 times.
✓ Branch 2 taken 46 times.
|
70 | if (ff_dca_core_map_spkr(&dca->core, c->ch_remap[ch]) < 0) |
1268 | 24 | continue; | |
1269 | 46 | c->residual_encode &= ~(1 << ch); | |
1270 | } | ||
1271 | 58 | } | |
1272 | |||
1273 | 1332 | static int combine_residual_frame(DCAXllDecoder *s, DCAXllChSet *c) | |
1274 | { | ||
1275 | 1332 | DCAContext *dca = s->avctx->priv_data; | |
1276 | 1332 | int ch, nsamples = s->nframesamples; | |
1277 | DCAXllChSet *o; | ||
1278 | |||
1279 | // Verify that core is compatible | ||
1280 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1332 times.
|
1332 | if (!(dca->packet & DCA_PACKET_CORE)) { |
1281 | ✗ | av_log(s->avctx, AV_LOG_ERROR, "Residual encoded channels are present without core\n"); | |
1282 | ✗ | return AVERROR(EINVAL); | |
1283 | } | ||
1284 | |||
1285 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1332 times.
|
1332 | if (c->freq != dca->core.output_rate) { |
1286 | ✗ | av_log(s->avctx, AV_LOG_WARNING, "Sample rate mismatch between core (%d Hz) and XLL (%d Hz)\n", dca->core.output_rate, c->freq); | |
1287 | ✗ | return AVERROR_INVALIDDATA; | |
1288 | } | ||
1289 | |||
1290 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1332 times.
|
1332 | if (nsamples != dca->core.npcmsamples) { |
1291 | ✗ | av_log(s->avctx, AV_LOG_WARNING, "Number of samples per frame mismatch between core (%d) and XLL (%d)\n", dca->core.npcmsamples, nsamples); | |
1292 | ✗ | return AVERROR_INVALIDDATA; | |
1293 | } | ||
1294 | |||
1295 | // See if this channel set is downmixed and find the next channel set in | ||
1296 | // hierarchy. If downmixed, undo core pre-scaling before combining with | ||
1297 | // residual (residual is not scaled). | ||
1298 | 1332 | o = find_next_hier_dmix_chset(s, c); | |
1299 | |||
1300 | // Reduce core bit width and combine with residual | ||
1301 |
2/2✓ Branch 0 taken 7862 times.
✓ Branch 1 taken 1332 times.
|
9194 | for (ch = 0; ch < c->nchannels; ch++) { |
1302 | int n, spkr, shift, round; | ||
1303 | int32_t *src, *dst; | ||
1304 | |||
1305 |
2/2✓ Branch 0 taken 157 times.
✓ Branch 1 taken 7705 times.
|
7862 | if (c->residual_encode & (1 << ch)) |
1306 | 157 | continue; | |
1307 | |||
1308 | // Map this channel to core speaker | ||
1309 | 7705 | spkr = ff_dca_core_map_spkr(&dca->core, c->ch_remap[ch]); | |
1310 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 7705 times.
|
7705 | if (spkr < 0) { |
1311 | ✗ | av_log(s->avctx, AV_LOG_WARNING, "Residual encoded channel (%d) references unavailable core channel\n", c->ch_remap[ch]); | |
1312 | ✗ | return AVERROR_INVALIDDATA; | |
1313 | } | ||
1314 | |||
1315 | // Account for LSB width | ||
1316 | 7705 | shift = 24 - c->pcm_bit_res + chs_get_lsb_width(s, c, 0, ch); | |
1317 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 7705 times.
|
7705 | if (shift > 24) { |
1318 | ✗ | av_log(s->avctx, AV_LOG_WARNING, "Invalid core shift (%d bits)\n", shift); | |
1319 | ✗ | return AVERROR_INVALIDDATA; | |
1320 | } | ||
1321 | |||
1322 |
2/2✓ Branch 0 taken 249 times.
✓ Branch 1 taken 7456 times.
|
7705 | round = shift > 0 ? 1 << (shift - 1) : 0; |
1323 | |||
1324 | 7705 | src = dca->core.output_samples[spkr]; | |
1325 | 7705 | dst = c->bands[0].msb_sample_buffer[ch]; | |
1326 |
2/2✓ Branch 0 taken 187 times.
✓ Branch 1 taken 7518 times.
|
7705 | if (o) { |
1327 | // Undo embedded core downmix pre-scaling | ||
1328 | 187 | int scale_inv = o->dmix_scale_inv[c->hier_ofs + ch]; | |
1329 |
2/2✓ Branch 0 taken 121856 times.
✓ Branch 1 taken 187 times.
|
122043 | for (n = 0; n < nsamples; n++) |
1330 | 121856 | dst[n] += (SUINT)clip23((mul16(src[n], scale_inv) + round) >> shift); | |
1331 | } else { | ||
1332 | // No downmix scaling | ||
1333 |
2/2✓ Branch 0 taken 3988480 times.
✓ Branch 1 taken 7518 times.
|
3995998 | for (n = 0; n < nsamples; n++) |
1334 | 3988480 | dst[n] += (unsigned)((src[n] + round) >> shift); | |
1335 | } | ||
1336 | } | ||
1337 | |||
1338 | 1332 | return 0; | |
1339 | } | ||
1340 | |||
1341 | 1357 | int ff_dca_xll_filter_frame(DCAXllDecoder *s, AVFrame *frame) | |
1342 | { | ||
1343 | 1357 | AVCodecContext *avctx = s->avctx; | |
1344 | 1357 | DCAContext *dca = avctx->priv_data; | |
1345 | 1357 | DCAExssAsset *asset = &dca->exss.assets[0]; | |
1346 | 1357 | DCAXllChSet *p = &s->chset[0], *c; | |
1347 | 1357 | enum AVMatrixEncoding matrix_encoding = AV_MATRIX_ENCODING_NONE; | |
1348 | int i, j, k, ret, shift, nsamples, request_mask; | ||
1349 | int ch_remap[DCA_SPEAKER_COUNT]; | ||
1350 | |||
1351 | // Force lossy downmixed output during recovery | ||
1352 |
2/2✓ Branch 0 taken 36 times.
✓ Branch 1 taken 1321 times.
|
1357 | if (dca->packet & DCA_PACKET_RECOVERY) { |
1353 |
2/2✓ Branch 0 taken 78 times.
✓ Branch 1 taken 36 times.
|
114 | for (i = 0, c = s->chset; i < s->nchsets; i++, c++) { |
1354 |
2/2✓ Branch 0 taken 58 times.
✓ Branch 1 taken 20 times.
|
78 | if (i < s->nactivechsets) |
1355 | 58 | force_lossy_output(s, c); | |
1356 | |||
1357 |
2/2✓ Branch 0 taken 42 times.
✓ Branch 1 taken 36 times.
|
78 | if (!c->primary_chset) |
1358 | 42 | c->dmix_embedded = 0; | |
1359 | } | ||
1360 | |||
1361 | 36 | s->scalable_lsbs = 0; | |
1362 | 36 | s->fixed_lsb_width = 0; | |
1363 | } | ||
1364 | |||
1365 | // Filter frequency bands for active channel sets | ||
1366 | 1357 | s->output_mask = 0; | |
1367 |
2/2✓ Branch 0 taken 2590 times.
✓ Branch 1 taken 1357 times.
|
3947 | for (i = 0, c = s->chset; i < s->nactivechsets; i++, c++) { |
1368 | 2590 | chs_filter_band_data(s, c, 0); | |
1369 | |||
1370 |
2/2✓ Branch 0 taken 1332 times.
✓ Branch 1 taken 1258 times.
|
2590 | if (c->residual_encode != (1 << c->nchannels) - 1 |
1371 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 1332 times.
|
1332 | && (ret = combine_residual_frame(s, c)) < 0) |
1372 | ✗ | return ret; | |
1373 | |||
1374 |
2/2✓ Branch 0 taken 136 times.
✓ Branch 1 taken 2454 times.
|
2590 | if (s->scalable_lsbs) |
1375 | 136 | chs_assemble_msbs_lsbs(s, c, 0); | |
1376 | |||
1377 |
2/2✓ Branch 0 taken 56 times.
✓ Branch 1 taken 2534 times.
|
2590 | if (c->nfreqbands > 1) { |
1378 | 56 | chs_filter_band_data(s, c, 1); | |
1379 | 56 | chs_assemble_msbs_lsbs(s, c, 1); | |
1380 | } | ||
1381 | |||
1382 | 2590 | s->output_mask |= c->ch_mask; | |
1383 | } | ||
1384 | |||
1385 | // Undo hierarchial downmix and/or apply scaling | ||
1386 |
2/2✓ Branch 0 taken 1298 times.
✓ Branch 1 taken 1312 times.
|
2610 | for (i = 1, c = &s->chset[1]; i < s->nchsets; i++, c++) { |
1387 |
2/2✓ Branch 1 taken 1213 times.
✓ Branch 2 taken 85 times.
|
1298 | if (!is_hier_dmix_chset(c)) |
1388 | 1213 | continue; | |
1389 | |||
1390 |
2/2✓ Branch 0 taken 45 times.
✓ Branch 1 taken 40 times.
|
85 | if (i >= s->nactivechsets) { |
1391 |
2/2✓ Branch 0 taken 50 times.
✓ Branch 1 taken 45 times.
|
95 | for (j = 0; j < c->nfreqbands; j++) |
1392 |
1/2✓ Branch 0 taken 50 times.
✗ Branch 1 not taken.
|
50 | if (c->bands[j].dmix_embedded) |
1393 | 50 | scale_down_mix(s, c, j); | |
1394 | 45 | break; | |
1395 | } | ||
1396 | |||
1397 |
2/2✓ Branch 0 taken 50 times.
✓ Branch 1 taken 40 times.
|
90 | for (j = 0; j < c->nfreqbands; j++) |
1398 |
1/2✓ Branch 0 taken 50 times.
✗ Branch 1 not taken.
|
50 | if (c->bands[j].dmix_embedded) |
1399 | 50 | undo_down_mix(s, c, j); | |
1400 | } | ||
1401 | |||
1402 | // Assemble frequency bands for active channel sets | ||
1403 |
2/2✓ Branch 0 taken 42 times.
✓ Branch 1 taken 1315 times.
|
1357 | if (s->nfreqbands > 1) { |
1404 |
2/2✓ Branch 0 taken 56 times.
✓ Branch 1 taken 42 times.
|
98 | for (i = 0; i < s->nactivechsets; i++) |
1405 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 56 times.
|
56 | if ((ret = chs_assemble_freq_bands(s, &s->chset[i])) < 0) |
1406 | ✗ | return ret; | |
1407 | } | ||
1408 | |||
1409 | // Normalize to regular 5.1 layout if downmixing | ||
1410 |
2/2✓ Branch 0 taken 120 times.
✓ Branch 1 taken 1237 times.
|
1357 | if (dca->request_channel_layout) { |
1411 |
2/2✓ Branch 0 taken 35 times.
✓ Branch 1 taken 85 times.
|
120 | if (s->output_mask & DCA_SPEAKER_MASK_Lss) { |
1412 | 35 | s->output_samples[DCA_SPEAKER_Ls] = s->output_samples[DCA_SPEAKER_Lss]; | |
1413 | 35 | s->output_mask = (s->output_mask & ~DCA_SPEAKER_MASK_Lss) | DCA_SPEAKER_MASK_Ls; | |
1414 | } | ||
1415 |
2/2✓ Branch 0 taken 35 times.
✓ Branch 1 taken 85 times.
|
120 | if (s->output_mask & DCA_SPEAKER_MASK_Rss) { |
1416 | 35 | s->output_samples[DCA_SPEAKER_Rs] = s->output_samples[DCA_SPEAKER_Rss]; | |
1417 | 35 | s->output_mask = (s->output_mask & ~DCA_SPEAKER_MASK_Rss) | DCA_SPEAKER_MASK_Rs; | |
1418 | } | ||
1419 | } | ||
1420 | |||
1421 | // Handle downmixing to stereo request | ||
1422 |
2/2✓ Branch 0 taken 60 times.
✓ Branch 1 taken 1297 times.
|
1357 | if (dca->request_channel_layout == DCA_SPEAKER_LAYOUT_STEREO |
1423 |
3/4✓ Branch 0 taken 60 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 7 times.
✓ Branch 3 taken 53 times.
|
60 | && DCA_HAS_STEREO(s->output_mask) && p->dmix_embedded |
1424 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 7 times.
|
7 | && (p->dmix_type == DCA_DMIX_TYPE_LoRo || |
1425 | ✗ | p->dmix_type == DCA_DMIX_TYPE_LtRt)) | |
1426 | 7 | request_mask = DCA_SPEAKER_LAYOUT_STEREO; | |
1427 | else | ||
1428 | 1350 | request_mask = s->output_mask; | |
1429 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 1357 times.
|
1357 | if (!ff_dca_set_channel_layout(avctx, ch_remap, request_mask)) |
1430 | ✗ | return AVERROR(EINVAL); | |
1431 | |||
1432 | 1357 | avctx->sample_rate = p->freq << (s->nfreqbands - 1); | |
1433 | |||
1434 |
2/3✓ Branch 0 taken 42 times.
✓ Branch 1 taken 1315 times.
✗ Branch 2 not taken.
|
1357 | switch (p->storage_bit_res) { |
1435 | 42 | case 16: | |
1436 | 42 | avctx->sample_fmt = AV_SAMPLE_FMT_S16P; | |
1437 | 42 | shift = 16 - p->pcm_bit_res; | |
1438 | 42 | break; | |
1439 | 1315 | case 20: | |
1440 | case 24: | ||
1441 | 1315 | avctx->sample_fmt = AV_SAMPLE_FMT_S32P; | |
1442 | 1315 | shift = 24 - p->pcm_bit_res; | |
1443 | 1315 | break; | |
1444 | ✗ | default: | |
1445 | ✗ | return AVERROR(EINVAL); | |
1446 | } | ||
1447 | |||
1448 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1357 times.
|
1357 | if (s->x_imax_syncword_present) { |
1449 | ✗ | avctx->profile = AV_PROFILE_DTS_HD_MA_X_IMAX; | |
1450 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1357 times.
|
1357 | } else if (s->x_syncword_present) { |
1451 | ✗ | avctx->profile = AV_PROFILE_DTS_HD_MA_X; | |
1452 | } else { | ||
1453 | 1357 | avctx->profile = AV_PROFILE_DTS_HD_MA; | |
1454 | } | ||
1455 | |||
1456 | 1357 | avctx->bits_per_raw_sample = p->storage_bit_res; | |
1457 | 1357 | avctx->bit_rate = 0; | |
1458 | |||
1459 | 1357 | frame->nb_samples = nsamples = s->nframesamples << (s->nfreqbands - 1); | |
1460 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 1357 times.
|
1357 | if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) |
1461 | ✗ | return ret; | |
1462 | |||
1463 | // Downmix primary channel set to stereo | ||
1464 |
2/2✓ Branch 0 taken 7 times.
✓ Branch 1 taken 1350 times.
|
1357 | if (request_mask != s->output_mask) { |
1465 | 7 | ff_dca_downmix_to_stereo_fixed(s->dcadsp, s->output_samples, | |
1466 | 7 | p->dmix_coeff, nsamples, | |
1467 | s->output_mask); | ||
1468 | } | ||
1469 | |||
1470 |
2/2✓ Branch 0 taken 10461 times.
✓ Branch 1 taken 1357 times.
|
11818 | for (i = 0; i < avctx->ch_layout.nb_channels; i++) { |
1471 | 10461 | int32_t *samples = s->output_samples[ch_remap[i]]; | |
1472 |
2/2✓ Branch 0 taken 224 times.
✓ Branch 1 taken 10237 times.
|
10461 | if (frame->format == AV_SAMPLE_FMT_S16P) { |
1473 | 224 | int16_t *plane = (int16_t *)frame->extended_data[i]; | |
1474 |
2/2✓ Branch 0 taken 458752 times.
✓ Branch 1 taken 224 times.
|
458976 | for (k = 0; k < nsamples; k++) |
1475 | 458752 | plane[k] = av_clip_int16(samples[k] * (SUINT)(1 << shift)); | |
1476 | } else { | ||
1477 | 10237 | int32_t *plane = (int32_t *)frame->extended_data[i]; | |
1478 |
2/2✓ Branch 0 taken 5414400 times.
✓ Branch 1 taken 10237 times.
|
5424637 | for (k = 0; k < nsamples; k++) |
1479 | 5414400 | plane[k] = clip23(samples[k] * (SUINT)(1 << shift)) * (1 << 8); | |
1480 | } | ||
1481 | } | ||
1482 | |||
1483 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1357 times.
|
1357 | if (!asset->one_to_one_map_ch_to_spkr) { |
1484 | ✗ | if (asset->representation_type == DCA_REPR_TYPE_LtRt) | |
1485 | ✗ | matrix_encoding = AV_MATRIX_ENCODING_DOLBY; | |
1486 | ✗ | else if (asset->representation_type == DCA_REPR_TYPE_LhRh) | |
1487 | ✗ | matrix_encoding = AV_MATRIX_ENCODING_DOLBYHEADPHONE; | |
1488 |
3/4✓ Branch 0 taken 7 times.
✓ Branch 1 taken 1350 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 7 times.
|
1357 | } else if (request_mask != s->output_mask && p->dmix_type == DCA_DMIX_TYPE_LtRt) { |
1489 | ✗ | matrix_encoding = AV_MATRIX_ENCODING_DOLBY; | |
1490 | } | ||
1491 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 1357 times.
|
1357 | if ((ret = ff_side_data_update_matrix_encoding(frame, matrix_encoding)) < 0) |
1492 | ✗ | return ret; | |
1493 | |||
1494 | 1357 | return 0; | |
1495 | } | ||
1496 | |||
1497 | ✗ | av_cold void ff_dca_xll_flush(DCAXllDecoder *s) | |
1498 | { | ||
1499 | ✗ | clear_pbr(s); | |
1500 | ✗ | } | |
1501 | |||
1502 | 99 | av_cold void ff_dca_xll_close(DCAXllDecoder *s) | |
1503 | { | ||
1504 | DCAXllChSet *c; | ||
1505 | int i, j; | ||
1506 | |||
1507 |
2/2✓ Branch 0 taken 297 times.
✓ Branch 1 taken 99 times.
|
396 | for (i = 0, c = s->chset; i < DCA_XLL_CHSETS_MAX; i++, c++) { |
1508 |
2/2✓ Branch 0 taken 891 times.
✓ Branch 1 taken 297 times.
|
1188 | for (j = 0; j < DCA_XLL_SAMPLE_BUFFERS_MAX; j++) { |
1509 | 891 | av_freep(&c->sample_buffer[j]); | |
1510 | 891 | c->sample_size[j] = 0; | |
1511 | } | ||
1512 | } | ||
1513 | |||
1514 | 99 | av_freep(&s->navi); | |
1515 | 99 | s->navi_size = 0; | |
1516 | |||
1517 | 99 | av_freep(&s->pbr_buffer); | |
1518 | 99 | clear_pbr(s); | |
1519 | 99 | } | |
1520 |