Line | Branch | Exec | Source |
---|---|---|---|
1 | /* | ||
2 | * RKA decoder | ||
3 | * Copyright (c) 2023 Paul B Mahol | ||
4 | * | ||
5 | * This file is part of FFmpeg. | ||
6 | * | ||
7 | * FFmpeg is free software; you can redistribute it and/or | ||
8 | * modify it under the terms of the GNU Lesser General Public | ||
9 | * License as published by the Free Software Foundation; either | ||
10 | * version 2.1 of the License, or (at your option) any later version. | ||
11 | * | ||
12 | * FFmpeg is distributed in the hope that it will be useful, | ||
13 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
15 | * Lesser General Public License for more details. | ||
16 | * | ||
17 | * You should have received a copy of the GNU Lesser General Public | ||
18 | * License along with FFmpeg; if not, write to the Free Software | ||
19 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA | ||
20 | */ | ||
21 | |||
22 | #include "libavutil/channel_layout.h" | ||
23 | #include "libavutil/intreadwrite.h" | ||
24 | |||
25 | #include "avcodec.h" | ||
26 | #include "codec_internal.h" | ||
27 | #include "bytestream.h" | ||
28 | #include "decode.h" | ||
29 | |||
30 | typedef struct ACoder { | ||
31 | GetByteContext gb; | ||
32 | uint32_t low, high; | ||
33 | uint32_t value; | ||
34 | } ACoder; | ||
35 | |||
36 | typedef struct FiltCoeffs { | ||
37 | int32_t coeffs[257]; | ||
38 | unsigned size; | ||
39 | } FiltCoeffs; | ||
40 | |||
41 | typedef struct Model64 { | ||
42 | uint32_t zero[2]; | ||
43 | uint32_t sign[2]; | ||
44 | unsigned size; | ||
45 | int bits; | ||
46 | |||
47 | uint16_t val4[65]; | ||
48 | uint16_t val1[65]; | ||
49 | } Model64; | ||
50 | |||
51 | typedef struct AdaptiveModel { | ||
52 | int last; | ||
53 | int total; | ||
54 | int buf_size; | ||
55 | int16_t sum; | ||
56 | uint16_t aprob0; | ||
57 | uint16_t aprob1; | ||
58 | uint16_t *prob[2]; | ||
59 | } AdaptiveModel; | ||
60 | |||
61 | typedef struct ChContext { | ||
62 | int cmode; | ||
63 | int cmode2; | ||
64 | int last_nb_decoded; | ||
65 | unsigned srate_pad; | ||
66 | unsigned pos_idx; | ||
67 | |||
68 | AdaptiveModel *filt_size; | ||
69 | AdaptiveModel *filt_bits; | ||
70 | |||
71 | uint32_t *bprob[2]; | ||
72 | |||
73 | AdaptiveModel position; | ||
74 | AdaptiveModel fshift; | ||
75 | AdaptiveModel nb_segments; | ||
76 | AdaptiveModel coeff_bits[11]; | ||
77 | |||
78 | Model64 mdl64[4][11]; | ||
79 | |||
80 | int32_t buf0[131072+2560]; | ||
81 | int32_t buf1[131072+2560]; | ||
82 | } ChContext; | ||
83 | |||
84 | typedef struct RKAContext { | ||
85 | AVClass *class; | ||
86 | |||
87 | ACoder ac; | ||
88 | ChContext ch[2]; | ||
89 | |||
90 | int bps; | ||
91 | int align; | ||
92 | int channels; | ||
93 | int correlated; | ||
94 | int frame_samples; | ||
95 | int last_nb_samples; | ||
96 | uint32_t total_nb_samples; | ||
97 | uint32_t samples_left; | ||
98 | |||
99 | uint32_t bprob[2][257]; | ||
100 | |||
101 | AdaptiveModel filt_size; | ||
102 | AdaptiveModel filt_bits; | ||
103 | } RKAContext; | ||
104 | |||
105 | 448 | static int adaptive_model_init(AdaptiveModel *am, int buf_size) | |
106 | { | ||
107 | 448 | am->buf_size = buf_size; | |
108 | 448 | am->sum = 2000; | |
109 | 448 | am->aprob0 = 0; | |
110 | 448 | am->aprob1 = 0; | |
111 | 448 | am->total = 0; | |
112 | |||
113 |
2/2✓ Branch 0 taken 60 times.
✓ Branch 1 taken 388 times.
|
448 | if (!am->prob[0]) |
114 | 60 | am->prob[0] = av_malloc_array(buf_size + 5, sizeof(*am->prob[0])); | |
115 |
2/2✓ Branch 0 taken 60 times.
✓ Branch 1 taken 388 times.
|
448 | if (!am->prob[1]) |
116 | 60 | am->prob[1] = av_malloc_array(buf_size + 5, sizeof(*am->prob[1])); | |
117 | |||
118 |
2/4✓ Branch 0 taken 448 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 448 times.
|
448 | if (!am->prob[0] || !am->prob[1]) |
119 | ✗ | return AVERROR(ENOMEM); | |
120 | 448 | memset(am->prob[0], 0, (buf_size + 5) * sizeof(*am->prob[0])); | |
121 | 448 | memset(am->prob[1], 0, (buf_size + 5) * sizeof(*am->prob[1])); | |
122 | 448 | return 0; | |
123 | } | ||
124 | |||
125 | 60 | static void adaptive_model_free(AdaptiveModel *am) | |
126 | { | ||
127 | 60 | av_freep(&am->prob[0]); | |
128 | 60 | av_freep(&am->prob[1]); | |
129 | 60 | } | |
130 | |||
131 | 2 | static av_cold int rka_decode_init(AVCodecContext *avctx) | |
132 | { | ||
133 | 2 | RKAContext *s = avctx->priv_data; | |
134 | int cmode; | ||
135 | |||
136 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
|
2 | if (avctx->extradata_size < 16) |
137 | ✗ | return AVERROR_INVALIDDATA; | |
138 | |||
139 | 2 | s->bps = avctx->bits_per_raw_sample = avctx->extradata[13]; | |
140 | |||
141 |
1/3✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
✗ Branch 2 not taken.
|
2 | switch (s->bps) { |
142 | ✗ | case 8: | |
143 | ✗ | avctx->sample_fmt = AV_SAMPLE_FMT_U8P; | |
144 | ✗ | break; | |
145 | 2 | case 16: | |
146 | 2 | avctx->sample_fmt = AV_SAMPLE_FMT_S16P; | |
147 | 2 | break; | |
148 | ✗ | default: | |
149 | ✗ | return AVERROR_INVALIDDATA; | |
150 | } | ||
151 | |||
152 | 2 | av_channel_layout_uninit(&avctx->ch_layout); | |
153 | 2 | s->channels = avctx->ch_layout.nb_channels = avctx->extradata[12]; | |
154 |
2/4✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 2 times.
|
2 | if (s->channels < 1 || s->channels > 2) |
155 | ✗ | return AVERROR_INVALIDDATA; | |
156 | |||
157 | 2 | s->align = (s->channels * (avctx->bits_per_raw_sample >> 3)); | |
158 | 2 | s->samples_left = s->total_nb_samples = (AV_RL32(avctx->extradata + 4)) / s->align; | |
159 | 2 | s->frame_samples = 131072 / s->align; | |
160 | 2 | s->last_nb_samples = s->total_nb_samples % s->frame_samples; | |
161 | 2 | s->correlated = avctx->extradata[15] & 1; | |
162 | |||
163 | 2 | cmode = avctx->extradata[14] & 0xf; | |
164 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
|
2 | if ((avctx->extradata[15] & 4) != 0) |
165 | ✗ | cmode = -cmode; | |
166 | |||
167 |
1/2✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
|
2 | s->ch[0].cmode = s->ch[1].cmode = cmode < 0 ? 2 : cmode; |
168 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
|
2 | s->ch[0].cmode2 = cmode < 0 ? FFABS(cmode) : 0; |
169 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
|
2 | s->ch[1].cmode2 = cmode < 0 ? FFABS(cmode) : 0; |
170 | 2 | av_log(avctx, AV_LOG_DEBUG, "cmode: %d\n", cmode); | |
171 | |||
172 | 2 | return 0; | |
173 | } | ||
174 | |||
175 | 1232 | static void model64_init(Model64 *m, unsigned bits) | |
176 | { | ||
177 | unsigned x; | ||
178 | |||
179 | 1232 | m->bits = bits; | |
180 | 1232 | m->size = 64; | |
181 | 1232 | m->zero[0] = 1; | |
182 | |||
183 | 1232 | x = (1 << (bits >> 1)) + 3; | |
184 | 1232 | x = FFMIN(x, 20); | |
185 | |||
186 | 1232 | m->zero[1] = x; | |
187 | 1232 | m->sign[0] = 1; | |
188 | 1232 | m->sign[1] = 1; | |
189 | |||
190 |
2/2✓ Branch 0 taken 80080 times.
✓ Branch 1 taken 1232 times.
|
81312 | for (int i = 0; i < FF_ARRAY_ELEMS(m->val4); i++) { |
191 | 80080 | m->val4[i] = 4; | |
192 | 80080 | m->val1[i] = 1; | |
193 | } | ||
194 | 1232 | } | |
195 | |||
196 | 28 | static int chctx_init(RKAContext *s, ChContext *c, | |
197 | int sample_rate, int bps) | ||
198 | { | ||
199 | int ret; | ||
200 | |||
201 | 28 | memset(c->buf0, 0, sizeof(c->buf0)); | |
202 | 28 | memset(c->buf1, 0, sizeof(c->buf1)); | |
203 | |||
204 | 28 | c->filt_size = &s->filt_size; | |
205 | 28 | c->filt_bits = &s->filt_bits; | |
206 | |||
207 | 28 | c->bprob[0] = s->bprob[0]; | |
208 | 28 | c->bprob[1] = s->bprob[1]; | |
209 | |||
210 | 28 | c->srate_pad = ((int64_t)sample_rate << 13) / 44100 & 0xFFFFFFFCU; | |
211 | 28 | c->pos_idx = 1; | |
212 | |||
213 |
2/2✓ Branch 0 taken 7196 times.
✓ Branch 1 taken 28 times.
|
7224 | for (int i = 0; i < FF_ARRAY_ELEMS(s->bprob[0]); i++) |
214 | 7196 | c->bprob[0][i] = c->bprob[1][i] = 1; | |
215 | |||
216 |
2/2✓ Branch 0 taken 308 times.
✓ Branch 1 taken 28 times.
|
336 | for (int i = 0; i < 11; i++) { |
217 | 308 | ret = adaptive_model_init(&c->coeff_bits[i], 32); | |
218 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 308 times.
|
308 | if (ret < 0) |
219 | ✗ | return ret; | |
220 | |||
221 | 308 | model64_init(&c->mdl64[0][i], i); | |
222 | 308 | model64_init(&c->mdl64[1][i], i); | |
223 | 308 | model64_init(&c->mdl64[2][i], i+1); | |
224 | 308 | model64_init(&c->mdl64[3][i], i+1); | |
225 | } | ||
226 | |||
227 | 28 | ret = adaptive_model_init(c->filt_size, 256); | |
228 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 28 times.
|
28 | if (ret < 0) |
229 | ✗ | return ret; | |
230 | 28 | ret = adaptive_model_init(c->filt_bits, 16); | |
231 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 28 times.
|
28 | if (ret < 0) |
232 | ✗ | return ret; | |
233 | 28 | ret = adaptive_model_init(&c->position, 16); | |
234 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 28 times.
|
28 | if (ret < 0) |
235 | ✗ | return ret; | |
236 | 28 | ret = adaptive_model_init(&c->nb_segments, 8); | |
237 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 28 times.
|
28 | if (ret < 0) |
238 | ✗ | return ret; | |
239 | 28 | return adaptive_model_init(&c->fshift, 32); | |
240 | } | ||
241 | |||
242 | 14 | static void init_acoder(ACoder *ac) | |
243 | { | ||
244 | 14 | ac->low = 0x0; | |
245 | 14 | ac->high = 0xffffffff; | |
246 | 14 | ac->value = bytestream2_get_be32(&ac->gb); | |
247 | 14 | } | |
248 | |||
249 | 4558875 | static int ac_decode_bool(ACoder *ac, int freq1, int freq2) | |
250 | { | ||
251 | unsigned help, add, high, value; | ||
252 | int low; | ||
253 | |||
254 | 4558875 | low = ac->low; | |
255 | 4558875 | help = ac->high / (unsigned)(freq2 + freq1); | |
256 | 4558875 | value = ac->value; | |
257 | 4558875 | add = freq1 * help; | |
258 | 4558875 | ac->high = help; | |
259 | |||
260 |
2/2✓ Branch 0 taken 2255650 times.
✓ Branch 1 taken 2303225 times.
|
4558875 | if (value - low >= add) { |
261 | 2255650 | ac->low = low = add + low; | |
262 | 2255650 | ac->high = high = freq2 * help; | |
263 | while (1) { | ||
264 |
2/2✓ Branch 0 taken 2256241 times.
✓ Branch 1 taken 234703 times.
|
2490944 | if ((low ^ (high + low)) > 0xFFFFFF) { |
265 |
2/2✓ Branch 0 taken 2255650 times.
✓ Branch 1 taken 591 times.
|
2256241 | if (high > 0xFFFF) |
266 | 2255650 | return 1; | |
267 | 591 | ac->high = (uint16_t)-(int16_t)low; | |
268 | } | ||
269 | |||
270 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 235294 times.
|
235294 | if (bytestream2_get_bytes_left(&ac->gb) <= 0) |
271 | ✗ | break; | |
272 | 235294 | ac->value = bytestream2_get_byteu(&ac->gb) | (ac->value << 8); | |
273 | 235294 | ac->high = high = ac->high << 8; | |
274 | 235294 | low = ac->low = ac->low << 8; | |
275 | } | ||
276 | ✗ | return -1; | |
277 | } | ||
278 | |||
279 | 2303225 | ac->high = add; | |
280 | while (1) { | ||
281 |
2/2✓ Branch 0 taken 2303787 times.
✓ Branch 1 taken 188574 times.
|
2492361 | if ((low ^ (add + low)) > 0xFFFFFF) { |
282 |
2/2✓ Branch 0 taken 2303225 times.
✓ Branch 1 taken 562 times.
|
2303787 | if (add > 0xFFFF) |
283 | 2303225 | return 0; | |
284 | 562 | ac->high = (uint16_t)-(int16_t)low; | |
285 | } | ||
286 | |||
287 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 189136 times.
|
189136 | if (bytestream2_get_bytes_left(&ac->gb) <= 0) |
288 | ✗ | break; | |
289 | 189136 | ac->value = bytestream2_get_byteu(&ac->gb) | (ac->value << 8); | |
290 | 189136 | ac->high = add = ac->high << 8; | |
291 | 189136 | low = ac->low = ac->low << 8; | |
292 | } | ||
293 | ✗ | return -1; | |
294 | } | ||
295 | |||
296 | 12855 | static int decode_bool(ACoder *ac, ChContext *c, int idx) | |
297 | { | ||
298 | uint32_t x; | ||
299 | int b; | ||
300 | |||
301 | 12855 | x = c->bprob[0][idx]; | |
302 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 12855 times.
|
12855 | if (x + c->bprob[1][idx] > 4096) { |
303 | ✗ | c->bprob[0][idx] = (x >> 1) + 1; | |
304 | ✗ | c->bprob[1][idx] = (c->bprob[1][idx] >> 1) + 1; | |
305 | } | ||
306 | |||
307 | 12855 | b = ac_decode_bool(ac, c->bprob[0][idx], c->bprob[1][idx]); | |
308 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 12855 times.
|
12855 | if (b < 0) |
309 | ✗ | return b; | |
310 | |||
311 | 12855 | c->bprob[b][idx]++; | |
312 | |||
313 | 12855 | return b; | |
314 | } | ||
315 | |||
316 | 923630 | static int ac_get_freq(ACoder *ac, unsigned freq, int *result) | |
317 | { | ||
318 | uint32_t new_high; | ||
319 | |||
320 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 923630 times.
|
923630 | if (freq == 0) |
321 | ✗ | return -1; | |
322 | |||
323 | 923630 | new_high = ac->high / freq; | |
324 | 923630 | ac->high = new_high; | |
325 | |||
326 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 923630 times.
|
923630 | if (new_high == 0) |
327 | ✗ | return -1; | |
328 | |||
329 | 923630 | *result = (ac->value - ac->low) / new_high; | |
330 | |||
331 | 923630 | return 0; | |
332 | } | ||
333 | |||
334 | 923630 | static int ac_update(ACoder *ac, int freq, int mul) | |
335 | { | ||
336 | uint32_t low, high; | ||
337 | |||
338 | 923630 | low = ac->low = ac->high * freq + ac->low; | |
339 | 923630 | high = ac->high = ac->high * mul; | |
340 | |||
341 | while (1) { | ||
342 |
2/2✓ Branch 0 taken 924278 times.
✓ Branch 1 taken 647483 times.
|
1571761 | if (((high + low) ^ low) > 0xffffff) { |
343 |
2/2✓ Branch 0 taken 923630 times.
✓ Branch 1 taken 648 times.
|
924278 | if (high > 0xffff) |
344 | 923630 | return 0; | |
345 | 648 | ac->high = (uint16_t)-(int16_t)low; | |
346 | } | ||
347 | |||
348 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 648131 times.
|
648131 | if (bytestream2_get_bytes_left(&ac->gb) <= 0) |
349 | ✗ | break; | |
350 | |||
351 | 648131 | ac->value = (ac->value << 8) | bytestream2_get_byteu(&ac->gb); | |
352 | 648131 | low = ac->low = ac->low << 8; | |
353 | 648131 | high = ac->high = ac->high << 8; | |
354 | } | ||
355 | |||
356 | ✗ | return -1; | |
357 | } | ||
358 | |||
359 | 20802 | static void amdl_update_prob(AdaptiveModel *am, int val, int diff) | |
360 | { | ||
361 | 20802 | am->aprob0 += diff; | |
362 |
2/2✓ Branch 0 taken 6283 times.
✓ Branch 1 taken 14519 times.
|
20802 | if (val <= 0) { |
363 | 6283 | am->prob[0][0] += diff; | |
364 | } else { | ||
365 | do { | ||
366 | 54753 | am->prob[0][val] += diff; | |
367 | 54753 | val += (val & -val); | |
368 |
2/2✓ Branch 0 taken 40234 times.
✓ Branch 1 taken 14519 times.
|
54753 | } while (val < am->buf_size); |
369 | } | ||
370 | 20802 | } | |
371 | |||
372 | ✗ | static void update_ch_subobj(AdaptiveModel *am) | |
373 | { | ||
374 | ✗ | int idx2, idx = am->buf_size - 1; | |
375 | |||
376 | ✗ | if (idx >= 0) { | |
377 | do { | ||
378 | ✗ | uint16_t *prob = am->prob[0]; | |
379 | ✗ | int diff, prob_idx = prob[idx]; | |
380 | |||
381 | ✗ | idx2 = idx - 1; | |
382 | ✗ | if (idx > 0) { | |
383 | ✗ | int idx3 = idx - 1; | |
384 | |||
385 | ✗ | if ((idx2 & idx) != idx2) { | |
386 | do { | ||
387 | ✗ | prob_idx -= prob[idx3]; | |
388 | ✗ | idx3 &= idx3 - 1; | |
389 | ✗ | } while ((idx2 & idx) != idx3); | |
390 | } | ||
391 | } | ||
392 | |||
393 | ✗ | diff = ((prob_idx > 0) - prob_idx) >> 1; | |
394 | ✗ | amdl_update_prob(am, idx, diff); | |
395 | ✗ | idx--; | |
396 | ✗ | } while (idx2 >= 0); | |
397 | } | ||
398 | |||
399 | ✗ | if (am->sum < 8000) | |
400 | ✗ | am->sum += 200; | |
401 | |||
402 | ✗ | am->aprob1 = (am->aprob1 + 1) >> 1; | |
403 | ✗ | } | |
404 | |||
405 | 20802 | static int amdl_decode_int(AdaptiveModel *am, ACoder *ac, unsigned *dst, unsigned size) | |
406 | { | ||
407 | unsigned freq, size2, val, mul; | ||
408 | int j; | ||
409 | |||
410 | 20802 | size = FFMIN(size, am->buf_size - 1); | |
411 | |||
412 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 20802 times.
|
20802 | if (am->aprob0 >= am->sum) |
413 | ✗ | update_ch_subobj(am); | |
414 | |||
415 |
5/6✓ Branch 0 taken 20581 times.
✓ Branch 1 taken 221 times.
✓ Branch 2 taken 20581 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 19042 times.
✓ Branch 5 taken 1539 times.
|
41383 | if (am->aprob1 && (am->total == am->buf_size || |
416 | 20581 | ac_decode_bool(ac, am->aprob0, am->aprob1) == 0)) { | |
417 |
2/2✓ Branch 0 taken 361 times.
✓ Branch 1 taken 18681 times.
|
19042 | if (am->total <= 1) { |
418 | 361 | dst[0] = am->last; | |
419 | 361 | amdl_update_prob(am, dst[0], 1); | |
420 | 361 | return 0; | |
421 | } | ||
422 |
2/2✓ Branch 0 taken 13086 times.
✓ Branch 1 taken 5595 times.
|
18681 | if (size == am->buf_size - 1) { |
423 | 13086 | freq = am->aprob0; | |
424 | } else { | ||
425 | 5595 | freq = am->prob[0][0]; | |
426 |
2/2✓ Branch 0 taken 11190 times.
✓ Branch 1 taken 5595 times.
|
16785 | for (int j = size; j > 0; j &= (j - 1) ) |
427 | 11190 | freq += am->prob[0][j]; | |
428 | } | ||
429 | 18681 | ac_get_freq(ac, freq, &freq); | |
430 | 18681 | size2 = am->buf_size >> 1; | |
431 | 18681 | val = am->prob[0][0]; | |
432 |
2/2✓ Branch 0 taken 12853 times.
✓ Branch 1 taken 5828 times.
|
18681 | if (freq >= val) { |
433 | 12853 | int sum = 0; | |
434 |
2/2✓ Branch 0 taken 63340 times.
✓ Branch 1 taken 12853 times.
|
76193 | for (j = freq - val; size2; size2 >>= 1) { |
435 | 63340 | unsigned v = am->prob[0][size2 + sum]; | |
436 |
2/2✓ Branch 0 taken 14414 times.
✓ Branch 1 taken 48926 times.
|
63340 | if (j >= v) { |
437 | 14414 | sum += size2; | |
438 | 14414 | j -= v; | |
439 | } | ||
440 | } | ||
441 | 12853 | freq -= j; | |
442 | 12853 | val = sum + 1; | |
443 | } else { | ||
444 | 5828 | freq = 0; | |
445 | 5828 | val = 0; | |
446 | } | ||
447 | 18681 | dst[0] = val; | |
448 | 18681 | mul = am->prob[0][val]; | |
449 |
2/2✓ Branch 0 taken 12853 times.
✓ Branch 1 taken 5828 times.
|
18681 | if (val > 0) { |
450 |
2/2✓ Branch 0 taken 8246 times.
✓ Branch 1 taken 12853 times.
|
21099 | for (int k = val - 1; (val & (val - 1)) != k; k &= k - 1) |
451 | 8246 | mul -= am->prob[0][k]; | |
452 | } | ||
453 | 18681 | ac_update(ac, freq, mul); | |
454 | 18681 | amdl_update_prob(am, dst[0], 1); | |
455 | 18681 | return 0; | |
456 | } | ||
457 | 1760 | am->aprob1++; | |
458 |
2/2✓ Branch 0 taken 1486 times.
✓ Branch 1 taken 274 times.
|
1760 | if (size == am->buf_size - 1) { |
459 | 1486 | ac_get_freq(ac, am->buf_size - am->total, &val); | |
460 | } else { | ||
461 | 274 | freq = 1; | |
462 |
2/2✓ Branch 0 taken 2480 times.
✓ Branch 1 taken 274 times.
|
2754 | for (dst[0] = 0; dst[0] < size; dst[0]++) { |
463 |
2/2✓ Branch 0 taken 2179 times.
✓ Branch 1 taken 301 times.
|
2480 | if (!am->prob[1][dst[0]]) |
464 | 2179 | freq++; | |
465 | } | ||
466 | 274 | ac_get_freq(ac, freq, &val); | |
467 | } | ||
468 | 1760 | freq = 0; | |
469 | 1760 | dst[0] = 0; | |
470 |
3/4✓ Branch 0 taken 1418 times.
✓ Branch 1 taken 342 times.
✓ Branch 2 taken 1418 times.
✗ Branch 3 not taken.
|
1760 | if (val > 0 && am->buf_size > 0) { |
471 |
2/2✓ Branch 0 taken 19788 times.
✓ Branch 1 taken 1418 times.
|
21206 | for (dst[0] = 0; dst[0] < size & freq < val; dst[0]++) { |
472 |
2/2✓ Branch 0 taken 15574 times.
✓ Branch 1 taken 4214 times.
|
19788 | if (!am->prob[1][dst[0]]) |
473 | 15574 | freq++; | |
474 | } | ||
475 | } | ||
476 |
2/2✓ Branch 0 taken 577 times.
✓ Branch 1 taken 1183 times.
|
1760 | if (am->prob[1][dst[0]]) { |
477 | do { | ||
478 | 1955 | val = dst[0]++; | |
479 |
3/4✓ Branch 0 taken 1955 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1378 times.
✓ Branch 3 taken 577 times.
|
1955 | } while (val + 1 < am->buf_size && am->prob[1][val + 1]); |
480 | } | ||
481 | 1760 | ac_update(ac, freq, 1); | |
482 | 1760 | am->prob[1][dst[0]]++; | |
483 | 1760 | am->total++; | |
484 | 1760 | amdl_update_prob(am, dst[0], 1); | |
485 | 1760 | am->last = dst[0]; | |
486 | |||
487 | 1760 | return 0; | |
488 | } | ||
489 | |||
490 | 338 | static int decode_filt_coeffs(RKAContext *s, ChContext *ctx, ACoder *ac, FiltCoeffs *dst) | |
491 | { | ||
492 | unsigned val, bits; | ||
493 | 338 | int idx = 0; | |
494 | |||
495 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 338 times.
|
338 | if (amdl_decode_int(ctx->filt_size, ac, &dst->size, 256) < 0) |
496 | ✗ | return -1; | |
497 | |||
498 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 338 times.
|
338 | if (dst->size == 0) |
499 | ✗ | return 0; | |
500 | |||
501 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 338 times.
|
338 | if (amdl_decode_int(ctx->filt_bits, ac, &bits, 10) < 0) |
502 | ✗ | return -1; | |
503 | |||
504 | do { | ||
505 |
6/6✓ Branch 0 taken 13963 times.
✓ Branch 1 taken 303 times.
✓ Branch 2 taken 200 times.
✓ Branch 3 taken 13763 times.
✓ Branch 4 taken 380 times.
✓ Branch 5 taken 123 times.
|
14266 | if (((idx == 8) || (idx == 20)) && (0 < bits)) |
506 | 380 | bits--; | |
507 | |||
508 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 14266 times.
|
14266 | if (bits > 10) |
509 | ✗ | return -1; | |
510 | |||
511 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 14266 times.
|
14266 | if (amdl_decode_int(&ctx->coeff_bits[bits], ac, &val, 31) < 0) |
512 | ✗ | return -1; | |
513 | |||
514 |
2/2✓ Branch 0 taken 8 times.
✓ Branch 1 taken 14258 times.
|
14266 | if (val == 31) { |
515 | 8 | ac_get_freq(ac, 65536, &val); | |
516 | 8 | ac_update(ac, val, 1); | |
517 | } | ||
518 | |||
519 |
2/2✓ Branch 0 taken 1411 times.
✓ Branch 1 taken 12855 times.
|
14266 | if (val == 0) { |
520 | 1411 | dst->coeffs[idx++] = 0; | |
521 | } else { | ||
522 | 12855 | unsigned freq = 0; | |
523 | int sign; | ||
524 | |||
525 |
2/2✓ Branch 0 taken 4081 times.
✓ Branch 1 taken 8774 times.
|
12855 | if (bits > 0) { |
526 | 4081 | ac_get_freq(ac, 1 << bits, &freq); | |
527 | 4081 | ac_update(ac, freq, 1); | |
528 | } | ||
529 | 12855 | dst->coeffs[idx] = freq + 1 + ((val - 1U) << bits); | |
530 | 12855 | sign = decode_bool(ac, ctx, idx); | |
531 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 12855 times.
|
12855 | if (sign < 0) |
532 | ✗ | return -1; | |
533 |
2/2✓ Branch 0 taken 6863 times.
✓ Branch 1 taken 5992 times.
|
12855 | if (sign == 1) |
534 | 6863 | dst->coeffs[idx] = -dst->coeffs[idx]; | |
535 | 12855 | idx++; | |
536 | } | ||
537 |
2/2✓ Branch 0 taken 13928 times.
✓ Branch 1 taken 338 times.
|
14266 | } while (idx < dst->size); |
538 | |||
539 | 338 | return 0; | |
540 | } | ||
541 | |||
542 | 1 | static int ac_dec_bit(ACoder *ac) | |
543 | { | ||
544 | uint32_t high, low; | ||
545 | |||
546 | 1 | low = ac->low; | |
547 | 1 | ac->high = high = ac->high >> 1; | |
548 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
|
1 | if (ac->value - low < high) { |
549 | do { | ||
550 | ✗ | if (((high + low) ^ low) > 0xffffff) { | |
551 | ✗ | if (high > 0xffff) | |
552 | ✗ | return 0; | |
553 | ✗ | ac->high = (uint16_t)-(int16_t)low; | |
554 | } | ||
555 | |||
556 | ✗ | if (bytestream2_get_bytes_left(&ac->gb) <= 0) | |
557 | ✗ | break; | |
558 | |||
559 | ✗ | ac->value = (ac->value << 8) | bytestream2_get_byteu(&ac->gb); | |
560 | ✗ | ac->high = high = ac->high << 8; | |
561 | ✗ | ac->low = low = ac->low << 8; | |
562 | } while (1); | ||
563 | |||
564 | ✗ | return -1; | |
565 | } | ||
566 | 1 | ac->low = low = low + high; | |
567 | do { | ||
568 |
1/2✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
|
1 | if (((high + low) ^ low) > 0xffffff) { |
569 |
1/2✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
|
1 | if (high > 0xffff) |
570 | 1 | return 1; | |
571 | ✗ | ac->high = (uint16_t)-(int16_t)low; | |
572 | } | ||
573 | |||
574 | ✗ | if (bytestream2_get_bytes_left(&ac->gb) <= 0) | |
575 | ✗ | break; | |
576 | |||
577 | ✗ | ac->value = (ac->value << 8) | bytestream2_get_byteu(&ac->gb); | |
578 | ✗ | ac->high = high = ac->high << 8; | |
579 | ✗ | ac->low = low = ac->low << 8; | |
580 | } while (1); | ||
581 | |||
582 | ✗ | return -1; | |
583 | } | ||
584 | |||
585 | 903440 | static int mdl64_decode(ACoder *ac, Model64 *ctx, int *dst) | |
586 | { | ||
587 | int sign, idx, bits; | ||
588 | 903440 | unsigned val = 0; | |
589 | |||
590 |
2/2✓ Branch 0 taken 614 times.
✓ Branch 1 taken 902826 times.
|
903440 | if (ctx->zero[0] + ctx->zero[1] > 4000U) { |
591 | 614 | ctx->zero[0] = (ctx->zero[0] >> 1) + 1; | |
592 | 614 | ctx->zero[1] = (ctx->zero[1] >> 1) + 1; | |
593 | } | ||
594 |
2/2✓ Branch 0 taken 229 times.
✓ Branch 1 taken 903211 times.
|
903440 | if (ctx->sign[0] + ctx->sign[1] > 4000U) { |
595 | 229 | ctx->sign[0] = (ctx->sign[0] >> 1) + 1; | |
596 | 229 | ctx->sign[1] = (ctx->sign[1] >> 1) + 1; | |
597 | } | ||
598 | 903440 | sign = ac_decode_bool(ac, ctx->zero[0], ctx->zero[1]); | |
599 |
2/2✓ Branch 0 taken 4343 times.
✓ Branch 1 taken 899097 times.
|
903440 | if (sign == 0) { |
600 | 4343 | ctx->zero[0] += 2; | |
601 | 4343 | dst[0] = 0; | |
602 | 4343 | return 0; | |
603 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 899097 times.
|
899097 | } else if (sign < 0) { |
604 | ✗ | return -1; | |
605 | } | ||
606 | |||
607 | 899097 | ctx->zero[1] += 2; | |
608 | 899097 | sign = ac_decode_bool(ac, ctx->sign[0], ctx->sign[1]); | |
609 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 899097 times.
|
899097 | if (sign < 0) |
610 | ✗ | return -1; | |
611 | 899097 | ctx->sign[sign]++; | |
612 | 899097 | bits = ctx->bits; | |
613 |
1/2✓ Branch 0 taken 899097 times.
✗ Branch 1 not taken.
|
899097 | if (bits > 0) { |
614 |
1/2✓ Branch 0 taken 899097 times.
✗ Branch 1 not taken.
|
899097 | if (bits < 13) { |
615 | 899097 | ac_get_freq(ac, 1 << bits, &val); | |
616 | 899097 | ac_update(ac, val, 1); | |
617 | } else { | ||
618 | ✗ | int hbits = bits / 2; | |
619 | ✗ | ac_get_freq(ac, 1 << hbits, &val); | |
620 | ✗ | ac_update(ac, val, 1); | |
621 | ✗ | ac_get_freq(ac, 1 << (ctx->bits - (hbits)), &bits); | |
622 | ✗ | ac_update(ac, val, 1); | |
623 | ✗ | val += (bits << hbits); | |
624 | } | ||
625 | } | ||
626 | 899097 | bits = ctx->size; | |
627 | 899097 | idx = 0; | |
628 |
1/2✓ Branch 0 taken 899097 times.
✗ Branch 1 not taken.
|
899097 | if (bits >= 0) { |
629 | do { | ||
630 | 2722902 | uint16_t *val4 = ctx->val4; | |
631 | int b; | ||
632 | |||
633 |
2/2✓ Branch 0 taken 8623 times.
✓ Branch 1 taken 2714279 times.
|
2722902 | if (val4[idx] + ctx->val1[idx] > 2000U) { |
634 | 8623 | val4[idx] = (val4[idx] >> 1) + 1; | |
635 | 8623 | ctx->val1[idx] = (ctx->val1[idx] >> 1) + 1; | |
636 | } | ||
637 | 2722902 | b = ac_decode_bool(ac, ctx->val4[idx], ctx->val1[idx]); | |
638 |
2/2✓ Branch 0 taken 899096 times.
✓ Branch 1 taken 1823806 times.
|
2722902 | if (b == 1) { |
639 | 899096 | ctx->val1[idx] += 4; | |
640 | 899096 | break; | |
641 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1823806 times.
|
1823806 | } else if (b < 0) { |
642 | ✗ | return -1; | |
643 | } | ||
644 | 1823806 | ctx->val4[idx] += 4; | |
645 | 1823806 | idx++; | |
646 |
2/2✓ Branch 0 taken 1823805 times.
✓ Branch 1 taken 1 times.
|
1823806 | } while (idx <= ctx->size); |
647 | 899097 | bits = ctx->size; | |
648 |
2/2✓ Branch 0 taken 899096 times.
✓ Branch 1 taken 1 times.
|
899097 | if (idx <= bits) { |
649 | 899096 | dst[0] = val + 1 + (idx << ctx->bits); | |
650 |
2/2✓ Branch 0 taken 449055 times.
✓ Branch 1 taken 450041 times.
|
899096 | if (sign) |
651 | 449055 | dst[0] = -dst[0]; | |
652 | 899096 | return 0; | |
653 | } | ||
654 | } | ||
655 | 1 | bits++; | |
656 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
|
1 | while (ac_dec_bit(ac) == 0) |
657 | ✗ | bits += 64; | |
658 | 1 | ac_get_freq(ac, 64, &idx); | |
659 | 1 | ac_update(ac, idx, 1); | |
660 | 1 | idx += bits; | |
661 | 1 | dst[0] = val + 1 + (idx << ctx->bits); | |
662 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
|
1 | if (sign) |
663 | ✗ | dst[0] = -dst[0]; | |
664 | |||
665 | 1 | return 0; | |
666 | } | ||
667 | |||
668 | static const uint8_t tab[16] = { | ||
669 | 0, 3, 3, 2, 2, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0 | ||
670 | }; | ||
671 | |||
672 | 338 | static int decode_filter(RKAContext *s, ChContext *ctx, ACoder *ac, int off, unsigned size) | |
673 | { | ||
674 | FiltCoeffs filt; | ||
675 | Model64 *mdl64; | ||
676 | 338 | int m = 0, split, val, last_val = 0, ret; | |
677 | 338 | unsigned idx = 3, bits = 0; | |
678 | |||
679 |
1/2✓ Branch 0 taken 338 times.
✗ Branch 1 not taken.
|
338 | if (ctx->cmode == 0) { |
680 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 338 times.
|
338 | if (amdl_decode_int(&ctx->fshift, ac, &bits, 15) < 0) |
681 | ✗ | return -1; | |
682 | 338 | bits &= 31U; | |
683 | } | ||
684 | |||
685 | 338 | ret = decode_filt_coeffs(s, ctx, ac, &filt); | |
686 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 338 times.
|
338 | if (ret < 0) |
687 | ✗ | return ret; | |
688 | |||
689 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 338 times.
|
338 | if (size < 512) |
690 | ✗ | split = size / 2; | |
691 | else | ||
692 | 338 | split = size >> 4; | |
693 | |||
694 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 338 times.
|
338 | if (size <= 1) |
695 | ✗ | return 0; | |
696 | |||
697 |
2/2✓ Branch 0 taken 5410 times.
✓ Branch 1 taken 338 times.
|
5748 | for (int x = 0; x < size;) { |
698 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 5410 times.
|
5410 | if (amdl_decode_int(&ctx->position, ac, &idx, 10) < 0) |
699 | ✗ | return -1; | |
700 | |||
701 | 5410 | idx = (ctx->pos_idx + idx) % 11; | |
702 | 5410 | ctx->pos_idx = idx; | |
703 | |||
704 |
2/2✓ Branch 0 taken 903440 times.
✓ Branch 1 taken 5410 times.
|
908850 | for (int y = 0; y < FFMIN(split, size - x); y++, off++) { |
705 | 903440 | int midx, shift = idx, *src, sum = 16; | |
706 | |||
707 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 903440 times.
|
903440 | if (off >= FF_ARRAY_ELEMS(ctx->buf0)) |
708 | ✗ | return -1; | |
709 | |||
710 | 903440 | midx = FFABS(last_val) >> shift; | |
711 |
2/2✓ Branch 0 taken 434 times.
✓ Branch 1 taken 903006 times.
|
903440 | if (midx >= 15) { |
712 | 434 | mdl64 = &ctx->mdl64[3][idx]; | |
713 |
2/2✓ Branch 0 taken 35765 times.
✓ Branch 1 taken 867241 times.
|
903006 | } else if (midx >= 7) { |
714 | 35765 | mdl64 = &ctx->mdl64[2][idx]; | |
715 |
2/2✓ Branch 0 taken 156303 times.
✓ Branch 1 taken 710938 times.
|
867241 | } else if (midx >= 4) { |
716 | 156303 | mdl64 = &ctx->mdl64[1][idx]; | |
717 | } else { | ||
718 | 710938 | mdl64 = &ctx->mdl64[0][idx]; | |
719 | } | ||
720 | 903440 | ret = mdl64_decode(ac, mdl64, &val); | |
721 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 903440 times.
|
903440 | if (ret < 0) |
722 | ✗ | return -1; | |
723 | 903440 | last_val = val; | |
724 | 903440 | src = &ctx->buf1[off + -1]; | |
725 |
4/4✓ Branch 0 taken 13328856 times.
✓ Branch 1 taken 180496 times.
✓ Branch 2 taken 12605912 times.
✓ Branch 3 taken 722944 times.
|
13509352 | for (int i = 0; i < filt.size && i < 15; i++) |
726 | 12605912 | sum += filt.coeffs[i] * (unsigned)src[-i]; | |
727 | 903440 | sum = sum * 2U; | |
728 |
2/2✓ Branch 0 taken 36546560 times.
✓ Branch 1 taken 903440 times.
|
37450000 | for (int i = 15; i < filt.size; i++) |
729 | 36546560 | sum += filt.coeffs[i] * (unsigned)src[-i]; | |
730 | 903440 | sum = sum >> 6; | |
731 |
1/2✓ Branch 0 taken 903440 times.
✗ Branch 1 not taken.
|
903440 | if (ctx->cmode == 0) { |
732 |
1/2✓ Branch 0 taken 903440 times.
✗ Branch 1 not taken.
|
903440 | if (bits == 0) { |
733 | 903440 | ctx->buf1[off] = sum + val; | |
734 | } else { | ||
735 | ✗ | ctx->buf1[off] = (val + (sum >> bits)) * (1U << bits) + | |
736 | ✗ | (((1U << bits) - 1U) & ctx->buf1[off + -1]); | |
737 | } | ||
738 | 903440 | ctx->buf0[off] = ctx->buf1[off] + (unsigned)ctx->buf0[off + -1]; | |
739 | } else { | ||
740 | ✗ | val *= 1U << ctx->cmode; | |
741 | ✗ | sum += ctx->buf0[off + -1] + (unsigned)val; | |
742 | ✗ | switch (s->bps) { | |
743 | ✗ | case 16: sum = av_clip_int16(sum); break; | |
744 | ✗ | case 8: sum = av_clip_int8(sum); break; | |
745 | } | ||
746 | ✗ | ctx->buf1[off] = sum - ctx->buf0[off + -1]; | |
747 | ✗ | ctx->buf0[off] = sum; | |
748 | ✗ | m += (unsigned)FFABS(ctx->buf1[off]); | |
749 | } | ||
750 | } | ||
751 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 5410 times.
|
5410 | if (ctx->cmode2 != 0) { |
752 | ✗ | int sum = 0; | |
753 | ✗ | for (int i = (signed)((unsigned)m << 6) / split; i > 0; i = i >> 1) | |
754 | ✗ | sum++; | |
755 | ✗ | sum = sum - (ctx->cmode2 + 7); | |
756 | ✗ | ctx->cmode = FFMAX(sum, tab[ctx->cmode2]); | |
757 | } | ||
758 | |||
759 | 5410 | x += split; | |
760 | } | ||
761 | |||
762 | 338 | return 0; | |
763 | } | ||
764 | |||
765 | 112 | static int decode_samples(AVCodecContext *avctx, ACoder *ac, ChContext *ctx, int offset) | |
766 | { | ||
767 | 112 | RKAContext *s = avctx->priv_data; | |
768 | int segment_size, offset2, mode, ret; | ||
769 | |||
770 | 112 | ret = amdl_decode_int(&ctx->nb_segments, ac, &mode, 5); | |
771 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 112 times.
|
112 | if (ret < 0) |
772 | ✗ | return ret; | |
773 | |||
774 |
2/2✓ Branch 0 taken 2 times.
✓ Branch 1 taken 110 times.
|
112 | if (mode == 5) { |
775 | 2 | ret = ac_get_freq(ac, ctx->srate_pad >> 2, &segment_size); | |
776 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
|
2 | if (ret < 0) |
777 | ✗ | return ret; | |
778 | 2 | ac_update(ac, segment_size, 1); | |
779 | 2 | segment_size *= 4; | |
780 | 2 | ret = decode_filter(s, ctx, ac, offset, segment_size); | |
781 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
|
2 | if (ret < 0) |
782 | ✗ | return ret; | |
783 | } else { | ||
784 | 110 | segment_size = ctx->srate_pad; | |
785 | |||
786 |
2/2✓ Branch 0 taken 99 times.
✓ Branch 1 taken 11 times.
|
110 | if (mode) { |
787 |
2/2✓ Branch 0 taken 59 times.
✓ Branch 1 taken 40 times.
|
99 | if (mode > 2) { |
788 | 59 | ret = decode_filter(s, ctx, ac, offset, segment_size / 4); | |
789 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 59 times.
|
59 | if (ret < 0) |
790 | ✗ | return ret; | |
791 | 59 | offset2 = segment_size / 4 + offset; | |
792 | 59 | ret = decode_filter(s, ctx, ac, offset2, segment_size / 4); | |
793 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 59 times.
|
59 | if (ret < 0) |
794 | ✗ | return ret; | |
795 | 59 | offset2 = segment_size / 4 + offset2; | |
796 | } else { | ||
797 | 40 | ret = decode_filter(s, ctx, ac, offset, segment_size / 2); | |
798 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 40 times.
|
40 | if (ret < 0) |
799 | ✗ | return ret; | |
800 | 40 | offset2 = segment_size / 2 + offset; | |
801 | } | ||
802 |
2/2✓ Branch 0 taken 31 times.
✓ Branch 1 taken 68 times.
|
99 | if (mode & 1) { |
803 | 31 | ret = decode_filter(s, ctx, ac, offset2, segment_size / 2); | |
804 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 31 times.
|
31 | if (ret < 0) |
805 | ✗ | return ret; | |
806 | } else { | ||
807 | 68 | ret = decode_filter(s, ctx, ac, offset2, segment_size / 4); | |
808 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 68 times.
|
68 | if (ret < 0) |
809 | ✗ | return ret; | |
810 | 68 | ret = decode_filter(s, ctx, ac, segment_size / 4 + offset2, segment_size / 4); | |
811 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 68 times.
|
68 | if (ret < 0) |
812 | ✗ | return ret; | |
813 | } | ||
814 | } else { | ||
815 | 11 | ret = decode_filter(s, ctx, ac, offset, ctx->srate_pad); | |
816 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 11 times.
|
11 | if (ret < 0) |
817 | ✗ | return ret; | |
818 | } | ||
819 | } | ||
820 | |||
821 | 112 | return segment_size; | |
822 | } | ||
823 | |||
824 | 113 | static int decode_ch_samples(AVCodecContext *avctx, ChContext *c) | |
825 | { | ||
826 | 113 | RKAContext *s = avctx->priv_data; | |
827 | 113 | ACoder *ac = &s->ac; | |
828 | 113 | int nb_decoded = 0; | |
829 | |||
830 |
2/2✓ Branch 1 taken 1 times.
✓ Branch 2 taken 112 times.
|
113 | if (bytestream2_get_bytes_left(&ac->gb) <= 0) |
831 | 1 | return 0; | |
832 | |||
833 | 112 | memmove(c->buf0, &c->buf0[c->last_nb_decoded], 2560 * sizeof(*c->buf0)); | |
834 | 112 | memmove(c->buf1, &c->buf1[c->last_nb_decoded], 2560 * sizeof(*c->buf1)); | |
835 | |||
836 | 112 | nb_decoded = decode_samples(avctx, ac, c, 2560); | |
837 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 112 times.
|
112 | if (nb_decoded < 0) |
838 | ✗ | return nb_decoded; | |
839 | 112 | c->last_nb_decoded = nb_decoded; | |
840 | |||
841 | 112 | return nb_decoded; | |
842 | } | ||
843 | |||
844 | 14 | static int rka_decode_frame(AVCodecContext *avctx, AVFrame *frame, | |
845 | int *got_frame_ptr, AVPacket *avpkt) | ||
846 | { | ||
847 | 14 | RKAContext *s = avctx->priv_data; | |
848 | 14 | ACoder *ac = &s->ac; | |
849 | int ret; | ||
850 | |||
851 | 14 | bytestream2_init(&ac->gb, avpkt->data, avpkt->size); | |
852 | 14 | init_acoder(ac); | |
853 | |||
854 |
2/2✓ Branch 0 taken 28 times.
✓ Branch 1 taken 14 times.
|
42 | for (int ch = 0; ch < s->channels; ch++) { |
855 | 28 | ret = chctx_init(s, &s->ch[ch], avctx->sample_rate, | |
856 | avctx->bits_per_raw_sample); | ||
857 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 28 times.
|
28 | if (ret < 0) |
858 | ✗ | return ret; | |
859 | } | ||
860 | |||
861 | 14 | frame->nb_samples = s->frame_samples; | |
862 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 14 times.
|
14 | if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) |
863 | ✗ | return ret; | |
864 | |||
865 |
2/4✓ Branch 0 taken 14 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 14 times.
✗ Branch 3 not taken.
|
28 | if (s->channels == 2 && s->correlated) { |
866 | 14 | int16_t *l16 = (int16_t *)frame->extended_data[0]; | |
867 | 14 | int16_t *r16 = (int16_t *)frame->extended_data[1]; | |
868 | 14 | uint8_t *l8 = frame->extended_data[0]; | |
869 | 14 | uint8_t *r8 = frame->extended_data[1]; | |
870 | |||
871 |
2/2✓ Branch 0 taken 57 times.
✓ Branch 1 taken 13 times.
|
70 | for (int n = 0; n < frame->nb_samples;) { |
872 | 57 | ret = decode_ch_samples(avctx, &s->ch[0]); | |
873 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 56 times.
|
57 | if (ret == 0) { |
874 | 1 | frame->nb_samples = n; | |
875 | 1 | break; | |
876 | } | ||
877 |
2/4✓ Branch 0 taken 56 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 56 times.
|
56 | if (ret < 0 || n + ret > frame->nb_samples) |
878 | ✗ | return AVERROR_INVALIDDATA; | |
879 | |||
880 | 56 | ret = decode_ch_samples(avctx, &s->ch[1]); | |
881 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 56 times.
|
56 | if (ret == 0) { |
882 | ✗ | frame->nb_samples = n; | |
883 | ✗ | break; | |
884 | } | ||
885 |
2/4✓ Branch 0 taken 56 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 56 times.
|
56 | if (ret < 0 || n + ret > frame->nb_samples) |
886 | ✗ | return AVERROR_INVALIDDATA; | |
887 | |||
888 |
1/3✓ Branch 0 taken 56 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
|
56 | switch (avctx->sample_fmt) { |
889 | 56 | case AV_SAMPLE_FMT_S16P: | |
890 |
2/2✓ Branch 0 taken 451720 times.
✓ Branch 1 taken 56 times.
|
451776 | for (int i = 0; i < ret; i++) { |
891 | 451720 | int l = s->ch[0].buf0[2560 + i]; | |
892 | 451720 | int r = s->ch[1].buf0[2560 + i]; | |
893 | |||
894 | 451720 | l16[n + i] = (l * 2 + r + 1) >> 1; | |
895 | 451720 | r16[n + i] = (l * 2 - r + 1) >> 1; | |
896 | } | ||
897 | 56 | break; | |
898 | ✗ | case AV_SAMPLE_FMT_U8P: | |
899 | ✗ | for (int i = 0; i < ret; i++) { | |
900 | ✗ | int l = s->ch[0].buf0[2560 + i]; | |
901 | ✗ | int r = s->ch[1].buf0[2560 + i]; | |
902 | |||
903 | ✗ | l8[n + i] = ((l * 2 + r + 1) >> 1) + 0x7f; | |
904 | ✗ | r8[n + i] = ((l * 2 - r + 1) >> 1) + 0x7f; | |
905 | } | ||
906 | ✗ | break; | |
907 | ✗ | default: | |
908 | ✗ | return AVERROR_INVALIDDATA; | |
909 | } | ||
910 | |||
911 | 56 | n += ret; | |
912 | } | ||
913 | } else { | ||
914 | ✗ | for (int n = 0; n < frame->nb_samples;) { | |
915 | ✗ | for (int ch = 0; ch < s->channels; ch++) { | |
916 | ✗ | int16_t *m16 = (int16_t *)frame->data[ch]; | |
917 | ✗ | uint8_t *m8 = frame->data[ch]; | |
918 | |||
919 | ✗ | ret = decode_ch_samples(avctx, &s->ch[ch]); | |
920 | ✗ | if (ret == 0) { | |
921 | ✗ | frame->nb_samples = n; | |
922 | ✗ | break; | |
923 | } | ||
924 | |||
925 | ✗ | if (ret < 0 || n + ret > frame->nb_samples) | |
926 | ✗ | return AVERROR_INVALIDDATA; | |
927 | |||
928 | ✗ | switch (avctx->sample_fmt) { | |
929 | ✗ | case AV_SAMPLE_FMT_S16P: | |
930 | ✗ | for (int i = 0; i < ret; i++) { | |
931 | ✗ | int m = s->ch[ch].buf0[2560 + i]; | |
932 | |||
933 | ✗ | m16[n + i] = m; | |
934 | } | ||
935 | ✗ | break; | |
936 | ✗ | case AV_SAMPLE_FMT_U8P: | |
937 | ✗ | for (int i = 0; i < ret; i++) { | |
938 | ✗ | int m = s->ch[ch].buf0[2560 + i]; | |
939 | |||
940 | ✗ | m8[n + i] = m + 0x7f; | |
941 | } | ||
942 | ✗ | break; | |
943 | ✗ | default: | |
944 | ✗ | return AVERROR_INVALIDDATA; | |
945 | } | ||
946 | } | ||
947 | |||
948 | ✗ | n += ret; | |
949 | } | ||
950 | } | ||
951 | |||
952 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 13 times.
|
14 | if (frame->nb_samples < s->frame_samples && |
953 |
1/2✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
|
1 | frame->nb_samples > s->last_nb_samples) |
954 | 1 | frame->nb_samples = s->last_nb_samples; | |
955 | |||
956 | 14 | *got_frame_ptr = 1; | |
957 | |||
958 | 14 | return avpkt->size; | |
959 | } | ||
960 | |||
961 | 2 | static av_cold int rka_decode_close(AVCodecContext *avctx) | |
962 | { | ||
963 | 2 | RKAContext *s = avctx->priv_data; | |
964 | |||
965 |
2/2✓ Branch 0 taken 4 times.
✓ Branch 1 taken 2 times.
|
6 | for (int ch = 0; ch < 2; ch++) { |
966 | 4 | ChContext *c = &s->ch[ch]; | |
967 | |||
968 |
2/2✓ Branch 0 taken 44 times.
✓ Branch 1 taken 4 times.
|
48 | for (int i = 0; i < 11; i++) |
969 | 44 | adaptive_model_free(&c->coeff_bits[i]); | |
970 | |||
971 | 4 | adaptive_model_free(&c->position); | |
972 | 4 | adaptive_model_free(&c->nb_segments); | |
973 | 4 | adaptive_model_free(&c->fshift); | |
974 | } | ||
975 | |||
976 | 2 | adaptive_model_free(&s->filt_size); | |
977 | 2 | adaptive_model_free(&s->filt_bits); | |
978 | |||
979 | 2 | return 0; | |
980 | } | ||
981 | |||
982 | const FFCodec ff_rka_decoder = { | ||
983 | .p.name = "rka", | ||
984 | CODEC_LONG_NAME("RKA (RK Audio)"), | ||
985 | .p.type = AVMEDIA_TYPE_AUDIO, | ||
986 | .p.id = AV_CODEC_ID_RKA, | ||
987 | .priv_data_size = sizeof(RKAContext), | ||
988 | .init = rka_decode_init, | ||
989 | .close = rka_decode_close, | ||
990 | FF_CODEC_DECODE_CB(rka_decode_frame), | ||
991 | .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_CHANNEL_CONF, | ||
992 | .caps_internal = FF_CODEC_CAP_INIT_CLEANUP, | ||
993 | }; | ||
994 |