FFmpeg coverage

Directory: ../../../ffmpeg/
File: src/libavcodec/rka.c
Date: 2023-09-24 13:02:57
Exec Total Coverage
Lines: 428 580 73.8%
Functions: 20 21 95.2%
Branches: 212 334 63.5%
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