FFmpeg
rka.c
Go to the documentation of this file.
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 
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 {
32  uint32_t low, high;
33  uint32_t value;
34 } ACoder;
35 
36 typedef struct FiltCoeffs {
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];
60 
61 typedef struct ChContext {
62  int qfactor;
63  int vrq;
65  unsigned srate_pad;
66  unsigned pos_idx;
67 
70 
71  uint32_t *bprob[2];
72 
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 
89 
90  int bps;
91  int align;
92  int channels;
96  uint32_t total_nb_samples;
97  uint32_t samples_left;
98 
99  uint32_t bprob[2][257];
100 
103 } RKAContext;
104 
105 static int adaptive_model_init(AdaptiveModel *am, int buf_size)
106 {
107  am->buf_size = buf_size;
108  am->sum = 2000;
109  am->aprob0 = 0;
110  am->aprob1 = 0;
111  am->total = 0;
112 
113  if (!am->prob[0])
114  am->prob[0] = av_malloc_array(buf_size + 5, sizeof(*am->prob[0]));
115  if (!am->prob[1])
116  am->prob[1] = av_malloc_array(buf_size + 5, sizeof(*am->prob[1]));
117 
118  if (!am->prob[0] || !am->prob[1])
119  return AVERROR(ENOMEM);
120  memset(am->prob[0], 0, (buf_size + 5) * sizeof(*am->prob[0]));
121  memset(am->prob[1], 0, (buf_size + 5) * sizeof(*am->prob[1]));
122  return 0;
123 }
124 
126 {
127  av_freep(&am->prob[0]);
128  av_freep(&am->prob[1]);
129 }
130 
132 {
133  RKAContext *s = avctx->priv_data;
134  int qfactor;
135 
136  if (avctx->extradata_size < 16)
137  return AVERROR_INVALIDDATA;
138 
139  s->bps = avctx->bits_per_raw_sample = avctx->extradata[13];
140 
141  switch (s->bps) {
142  case 8:
143  avctx->sample_fmt = AV_SAMPLE_FMT_U8P;
144  break;
145  case 16:
147  break;
148  default:
149  return AVERROR_INVALIDDATA;
150  }
151 
153  s->channels = avctx->ch_layout.nb_channels = avctx->extradata[12];
154  if (s->channels < 1 || s->channels > 2)
155  return AVERROR_INVALIDDATA;
156 
157  s->align = (s->channels * (avctx->bits_per_raw_sample >> 3));
158  s->samples_left = s->total_nb_samples = (AV_RL32(avctx->extradata + 4)) / s->align;
159  s->frame_samples = 131072 / s->align;
160  s->last_nb_samples = s->total_nb_samples % s->frame_samples;
161  s->correlated = avctx->extradata[15] & 1;
162 
163  qfactor = avctx->extradata[14] & 0xf;
164  if ((avctx->extradata[15] & 4) != 0)
165  qfactor = -qfactor;
166 
167  s->ch[0].qfactor = s->ch[1].qfactor = qfactor < 0 ? 2 : qfactor;
168  s->ch[0].vrq = qfactor < 0 ? -qfactor : 0;
169  s->ch[1].vrq = qfactor < 0 ? -qfactor : 0;
170  if (qfactor < 0) {
171  s->ch[0].vrq = av_clip(s->ch[0].vrq, 1, 8);
172  s->ch[1].vrq = av_clip(s->ch[1].vrq, 1, 8);
173  }
174  av_log(avctx, AV_LOG_DEBUG, "qfactor: %d\n", qfactor);
175 
176  return 0;
177 }
178 
179 static void model64_init(Model64 *m, unsigned bits)
180 {
181  unsigned x;
182 
183  m->bits = bits;
184  m->size = 64;
185  m->zero[0] = 1;
186 
187  x = (1 << (bits >> 1)) + 3;
188  x = FFMIN(x, 20);
189 
190  m->zero[1] = x;
191  m->sign[0] = 1;
192  m->sign[1] = 1;
193 
194  for (int i = 0; i < FF_ARRAY_ELEMS(m->val4); i++) {
195  m->val4[i] = 4;
196  m->val1[i] = 1;
197  }
198 }
199 
201  int sample_rate, int bps)
202 {
203  int ret;
204 
205  memset(c->buf0, 0, sizeof(c->buf0));
206  memset(c->buf1, 0, sizeof(c->buf1));
207 
208  c->filt_size = &s->filt_size;
209  c->filt_bits = &s->filt_bits;
210 
211  c->bprob[0] = s->bprob[0];
212  c->bprob[1] = s->bprob[1];
213 
214  c->srate_pad = ((int64_t)sample_rate << 13) / 44100 & 0xFFFFFFFCU;
215  c->pos_idx = 1;
216 
217  for (int i = 0; i < FF_ARRAY_ELEMS(s->bprob[0]); i++)
218  c->bprob[0][i] = c->bprob[1][i] = 1;
219 
220  for (int i = 0; i < 11; i++) {
221  ret = adaptive_model_init(&c->coeff_bits[i], 32);
222  if (ret < 0)
223  return ret;
224 
225  model64_init(&c->mdl64[0][i], i);
226  model64_init(&c->mdl64[1][i], i);
227  model64_init(&c->mdl64[2][i], i+1);
228  model64_init(&c->mdl64[3][i], i+1);
229  }
230 
231  ret = adaptive_model_init(c->filt_size, 256);
232  if (ret < 0)
233  return ret;
234  ret = adaptive_model_init(c->filt_bits, 16);
235  if (ret < 0)
236  return ret;
237  ret = adaptive_model_init(&c->position, 16);
238  if (ret < 0)
239  return ret;
240  ret = adaptive_model_init(&c->nb_segments, 8);
241  if (ret < 0)
242  return ret;
243  return adaptive_model_init(&c->fshift, 32);
244 }
245 
246 static void init_acoder(ACoder *ac)
247 {
248  ac->low = 0x0;
249  ac->high = 0xffffffff;
250  ac->value = bytestream2_get_be32(&ac->gb);
251 }
252 
253 static int ac_decode_bool(ACoder *ac, int freq1, int freq2)
254 {
255  unsigned help, add, high, value;
256  int low;
257 
258  low = ac->low;
259  help = ac->high / (unsigned)(freq2 + freq1);
260  value = ac->value;
261  add = freq1 * help;
262  ac->high = help;
263 
264  if (value - low >= add) {
265  ac->low = low = add + low;
266  ac->high = high = freq2 * help;
267  while (1) {
268  if ((low ^ (high + low)) > 0xFFFFFF) {
269  if (high > 0xFFFF)
270  return 1;
271  ac->high = (uint16_t)-(int16_t)low;
272  }
273 
274  if (bytestream2_get_bytes_left(&ac->gb) <= 0)
275  break;
276  ac->value = bytestream2_get_byteu(&ac->gb) | (ac->value << 8);
277  ac->high = high = ac->high << 8;
278  low = ac->low = ac->low << 8;
279  }
280  return -1;
281  }
282 
283  ac->high = add;
284  while (1) {
285  if ((low ^ (add + low)) > 0xFFFFFF) {
286  if (add > 0xFFFF)
287  return 0;
288  ac->high = (uint16_t)-(int16_t)low;
289  }
290 
291  if (bytestream2_get_bytes_left(&ac->gb) <= 0)
292  break;
293  ac->value = bytestream2_get_byteu(&ac->gb) | (ac->value << 8);
294  ac->high = add = ac->high << 8;
295  low = ac->low = ac->low << 8;
296  }
297  return -1;
298 }
299 
300 static int decode_bool(ACoder *ac, ChContext *c, int idx)
301 {
302  uint32_t x;
303  int b;
304 
305  x = c->bprob[0][idx];
306  if (x + c->bprob[1][idx] > 4096) {
307  c->bprob[0][idx] = (x >> 1) + 1;
308  c->bprob[1][idx] = (c->bprob[1][idx] >> 1) + 1;
309  }
310 
311  b = ac_decode_bool(ac, c->bprob[0][idx], c->bprob[1][idx]);
312  if (b < 0)
313  return b;
314 
315  c->bprob[b][idx]++;
316 
317  return b;
318 }
319 
320 static int ac_get_freq(ACoder *ac, unsigned freq, int *result)
321 {
322  uint32_t new_high;
323 
324  if (freq == 0)
325  return -1;
326 
327  new_high = ac->high / freq;
328  ac->high = new_high;
329 
330  if (new_high == 0)
331  return -1;
332 
333  *result = (ac->value - ac->low) / new_high;
334 
335  return 0;
336 }
337 
338 static int ac_update(ACoder *ac, int freq, int mul)
339 {
340  uint32_t low, high;
341 
342  low = ac->low = ac->high * freq + ac->low;
343  high = ac->high = ac->high * mul;
344 
345  while (1) {
346  if (((high + low) ^ low) > 0xffffff) {
347  if (high > 0xffff)
348  return 0;
349  ac->high = (uint16_t)-(int16_t)low;
350  }
351 
352  if (bytestream2_get_bytes_left(&ac->gb) <= 0)
353  break;
354 
355  ac->value = (ac->value << 8) | bytestream2_get_byteu(&ac->gb);
356  low = ac->low = ac->low << 8;
357  high = ac->high = ac->high << 8;
358  }
359 
360  return -1;
361 }
362 
363 static void amdl_update_prob(AdaptiveModel *am, int val, int diff)
364 {
365  am->aprob0 += diff;
366  if (val <= 0) {
367  am->prob[0][0] += diff;
368  } else {
369  do {
370  am->prob[0][val] += diff;
371  val += (val & -val);
372  } while (val < am->buf_size);
373  }
374 }
375 
377 {
378  int idx2, idx = am->buf_size - 1;
379 
380  if (idx >= 0) {
381  do {
382  uint16_t *prob = am->prob[0];
383  int diff, prob_idx = prob[idx];
384 
385  idx2 = idx - 1;
386  if (idx > 0) {
387  int idx3 = idx - 1;
388 
389  if ((idx2 & idx) != idx2) {
390  do {
391  prob_idx -= prob[idx3];
392  idx3 &= idx3 - 1;
393  } while ((idx2 & idx) != idx3);
394  }
395  }
396 
397  diff = ((prob_idx > 0) - prob_idx) >> 1;
398  amdl_update_prob(am, idx, diff);
399  idx--;
400  } while (idx2 >= 0);
401  }
402 
403  if (am->sum < 8000)
404  am->sum += 200;
405 
406  am->aprob1 = (am->aprob1 + 1) >> 1;
407 }
408 
409 static int amdl_decode_int(AdaptiveModel *am, ACoder *ac, unsigned *dst, unsigned size)
410 {
411  unsigned freq, size2, val, mul;
412  int j;
413 
414  size = FFMIN(size, am->buf_size - 1);
415 
416  if (am->aprob0 >= am->sum)
417  update_ch_subobj(am);
418 
419  if (am->aprob1 && (am->total == am->buf_size ||
420  ac_decode_bool(ac, am->aprob0, am->aprob1) == 0)) {
421  if (am->total <= 1) {
422  dst[0] = am->last;
423  amdl_update_prob(am, dst[0], 1);
424  return 0;
425  }
426  if (size == am->buf_size - 1) {
427  freq = am->aprob0;
428  } else {
429  freq = am->prob[0][0];
430  for (int j = size; j > 0; j &= (j - 1) )
431  freq += am->prob[0][j];
432  }
433  ac_get_freq(ac, freq, &freq);
434  size2 = am->buf_size >> 1;
435  val = am->prob[0][0];
436  if (freq >= val) {
437  int sum = 0;
438  for (j = freq - val; size2; size2 >>= 1) {
439  unsigned v = am->prob[0][size2 + sum];
440  if (j >= v) {
441  sum += size2;
442  j -= v;
443  }
444  }
445  freq -= j;
446  val = sum + 1;
447  } else {
448  freq = 0;
449  val = 0;
450  }
451  dst[0] = val;
452  mul = am->prob[0][val];
453  if (val > 0) {
454  for (int k = val - 1; (val & (val - 1)) != k; k &= k - 1)
455  mul -= am->prob[0][k];
456  }
457  ac_update(ac, freq, mul);
458  amdl_update_prob(am, dst[0], 1);
459  return 0;
460  }
461  am->aprob1++;
462  if (size == am->buf_size - 1) {
463  ac_get_freq(ac, am->buf_size - am->total, &val);
464  } else {
465  freq = 1;
466  for (dst[0] = 0; dst[0] < size; dst[0]++) {
467  if (!am->prob[1][dst[0]])
468  freq++;
469  }
470  ac_get_freq(ac, freq, &val);
471  }
472  freq = 0;
473  dst[0] = 0;
474  if (val > 0 && am->buf_size > 0) {
475  for (dst[0] = 0; dst[0] < size & freq < val; dst[0]++) {
476  if (!am->prob[1][dst[0]])
477  freq++;
478  }
479  }
480  if (am->prob[1][dst[0]]) {
481  do {
482  val = dst[0]++;
483  } while (val + 1 < am->buf_size && am->prob[1][val + 1]);
484  }
485  ac_update(ac, freq, 1);
486  am->prob[1][dst[0]]++;
487  am->total++;
488  amdl_update_prob(am, dst[0], 1);
489  am->last = dst[0];
490 
491  return 0;
492 }
493 
495 {
496  unsigned val, bits;
497  int idx = 0;
498 
499  if (amdl_decode_int(ctx->filt_size, ac, &dst->size, 256) < 0)
500  return -1;
501 
502  if (dst->size == 0)
503  return 0;
504 
505  if (amdl_decode_int(ctx->filt_bits, ac, &bits, 10) < 0)
506  return -1;
507 
508  do {
509  if (((idx == 8) || (idx == 20)) && (0 < bits))
510  bits--;
511 
512  if (bits > 10)
513  return -1;
514 
515  if (amdl_decode_int(&ctx->coeff_bits[bits], ac, &val, 31) < 0)
516  return -1;
517 
518  if (val == 31) {
519  ac_get_freq(ac, 65536, &val);
520  ac_update(ac, val, 1);
521  }
522 
523  if (val == 0) {
524  dst->coeffs[idx++] = 0;
525  } else {
526  unsigned freq = 0;
527  int sign;
528 
529  if (bits > 0) {
530  ac_get_freq(ac, 1 << bits, &freq);
531  ac_update(ac, freq, 1);
532  }
533  dst->coeffs[idx] = freq + 1 + ((val - 1U) << bits);
534  sign = decode_bool(ac, ctx, idx);
535  if (sign < 0)
536  return -1;
537  if (sign == 1)
538  dst->coeffs[idx] = -dst->coeffs[idx];
539  idx++;
540  }
541  } while (idx < dst->size);
542 
543  return 0;
544 }
545 
546 static int ac_dec_bit(ACoder *ac)
547 {
548  uint32_t high, low;
549 
550  low = ac->low;
551  ac->high = high = ac->high >> 1;
552  if (ac->value - low < high) {
553  do {
554  if (((high + low) ^ low) > 0xffffff) {
555  if (high > 0xffff)
556  return 0;
557  ac->high = (uint16_t)-(int16_t)low;
558  }
559 
560  if (bytestream2_get_bytes_left(&ac->gb) <= 0)
561  break;
562 
563  ac->value = (ac->value << 8) | bytestream2_get_byteu(&ac->gb);
564  ac->high = high = ac->high << 8;
565  ac->low = low = ac->low << 8;
566  } while (1);
567 
568  return -1;
569  }
570  ac->low = low = low + high;
571  do {
572  if (((high + low) ^ low) > 0xffffff) {
573  if (high > 0xffff)
574  return 1;
575  ac->high = (uint16_t)-(int16_t)low;
576  }
577 
578  if (bytestream2_get_bytes_left(&ac->gb) <= 0)
579  break;
580 
581  ac->value = (ac->value << 8) | bytestream2_get_byteu(&ac->gb);
582  ac->high = high = ac->high << 8;
583  ac->low = low = ac->low << 8;
584  } while (1);
585 
586  return -1;
587 }
588 
589 static int mdl64_decode(ACoder *ac, Model64 *ctx, int *dst)
590 {
591  int sign, idx, bits;
592  unsigned val = 0;
593 
594  if (ctx->zero[0] + ctx->zero[1] > 4000U) {
595  ctx->zero[0] = (ctx->zero[0] >> 1) + 1;
596  ctx->zero[1] = (ctx->zero[1] >> 1) + 1;
597  }
598  if (ctx->sign[0] + ctx->sign[1] > 4000U) {
599  ctx->sign[0] = (ctx->sign[0] >> 1) + 1;
600  ctx->sign[1] = (ctx->sign[1] >> 1) + 1;
601  }
602  sign = ac_decode_bool(ac, ctx->zero[0], ctx->zero[1]);
603  if (sign == 0) {
604  ctx->zero[0] += 2;
605  dst[0] = 0;
606  return 0;
607  } else if (sign < 0) {
608  return -1;
609  }
610 
611  ctx->zero[1] += 2;
612  sign = ac_decode_bool(ac, ctx->sign[0], ctx->sign[1]);
613  if (sign < 0)
614  return -1;
615  ctx->sign[sign]++;
616  bits = ctx->bits;
617  if (bits > 0) {
618  if (bits < 13) {
619  ac_get_freq(ac, 1 << bits, &val);
620  ac_update(ac, val, 1);
621  } else {
622  int hbits = bits / 2;
623  ac_get_freq(ac, 1 << hbits, &val);
624  ac_update(ac, val, 1);
625  ac_get_freq(ac, 1 << (ctx->bits - (hbits)), &bits);
626  ac_update(ac, val, 1);
627  val += (bits << hbits);
628  }
629  }
630  bits = ctx->size;
631  idx = 0;
632  if (bits >= 0) {
633  do {
634  uint16_t *val4 = ctx->val4;
635  int b;
636 
637  if (val4[idx] + ctx->val1[idx] > 2000U) {
638  val4[idx] = (val4[idx] >> 1) + 1;
639  ctx->val1[idx] = (ctx->val1[idx] >> 1) + 1;
640  }
641  b = ac_decode_bool(ac, ctx->val4[idx], ctx->val1[idx]);
642  if (b == 1) {
643  ctx->val1[idx] += 4;
644  break;
645  } else if (b < 0) {
646  return -1;
647  }
648  ctx->val4[idx] += 4;
649  idx++;
650  } while (idx <= ctx->size);
651  bits = ctx->size;
652  if (idx <= bits) {
653  dst[0] = val + 1 + (idx << ctx->bits);
654  if (sign)
655  dst[0] = -dst[0];
656  return 0;
657  }
658  }
659  bits++;
660  while (ac_dec_bit(ac) == 0)
661  bits += 64;
662  ac_get_freq(ac, 64, &idx);
663  ac_update(ac, idx, 1);
664  idx += bits;
665  dst[0] = val + 1 + (idx << ctx->bits);
666  if (sign)
667  dst[0] = -dst[0];
668 
669  return 0;
670 }
671 
672 static const uint8_t vrq_qfactors[8] = { 3, 3, 2, 2, 1, 1, 1, 1 };
673 
674 static int decode_filter(RKAContext *s, ChContext *ctx, ACoder *ac, int off, unsigned size)
675 {
677  Model64 *mdl64;
678  int split, val, last_val = 0, ret;
679  unsigned rsize, idx = 3, bits = 0, m = 0;
680 
681  if (ctx->qfactor == 0) {
682  if (amdl_decode_int(&ctx->fshift, ac, &bits, 15) < 0)
683  return -1;
684  bits &= 31U;
685  }
686 
687  ret = decode_filt_coeffs(s, ctx, ac, &filt);
688  if (ret < 0)
689  return ret;
690 
691  if (size < 512)
692  split = size / 2;
693  else
694  split = size >> 4;
695 
696  if (size <= 1)
697  return 0;
698 
699  for (int x = 0; x < size;) {
700  if (amdl_decode_int(&ctx->position, ac, &idx, 10) < 0)
701  return -1;
702 
703  m = 0;
704  idx = (ctx->pos_idx + idx) % 11;
705  ctx->pos_idx = idx;
706 
707  rsize = FFMIN(split, size - x);
708  for (int y = 0; y < rsize; y++, off++) {
709  int midx, shift = idx, *src, sum = 16;
710 
711  if (off >= FF_ARRAY_ELEMS(ctx->buf0))
712  return -1;
713 
714  midx = FFABS(last_val) >> shift;
715  if (midx >= 15) {
716  mdl64 = &ctx->mdl64[3][idx];
717  } else if (midx >= 7) {
718  mdl64 = &ctx->mdl64[2][idx];
719  } else if (midx >= 4) {
720  mdl64 = &ctx->mdl64[1][idx];
721  } else {
722  mdl64 = &ctx->mdl64[0][idx];
723  }
724  ret = mdl64_decode(ac, mdl64, &val);
725  if (ret < 0)
726  return -1;
727  last_val = val;
728  src = &ctx->buf1[off + -1];
729  for (int i = 0; i < filt.size && i < 15; i++)
730  sum += filt.coeffs[i] * (unsigned)src[-i];
731  sum = sum * 2U;
732  for (int i = 15; i < filt.size; i++)
733  sum += filt.coeffs[i] * (unsigned)src[-i];
734  sum = sum >> 6;
735  if (ctx->qfactor == 0) {
736  if (bits == 0) {
737  ctx->buf1[off] = sum + val;
738  } else {
739  ctx->buf1[off] = (val + (sum >> bits)) * (1U << bits) +
740  (((1U << bits) - 1U) & ctx->buf1[off + -1]);
741  }
742  ctx->buf0[off] = ctx->buf1[off] + (unsigned)ctx->buf0[off + -1];
743  } else {
744  val *= 1U << ctx->qfactor;
745  sum += ctx->buf0[off + -1] + (unsigned)val;
746  switch (s->bps) {
747  case 16: sum = av_clip_int16(sum); break;
748  case 8: sum = av_clip_int8(sum); break;
749  }
750  ctx->buf1[off] = sum - ctx->buf0[off + -1];
751  ctx->buf0[off] = sum;
752  m += (unsigned)FFABS(ctx->buf1[off]);
753  }
754  }
755  if (ctx->vrq != 0) {
756  int sum = 0;
757  for (unsigned i = (m << 6) / rsize; i > 0; i = i >> 1)
758  sum++;
759  sum -= (ctx->vrq + 7);
760  ctx->qfactor = FFMAX(sum, vrq_qfactors[ctx->vrq - 1]);
761  }
762 
763  x += split;
764  }
765 
766  return 0;
767 }
768 
769 static int decode_samples(AVCodecContext *avctx, ACoder *ac, ChContext *ctx, int offset)
770 {
771  RKAContext *s = avctx->priv_data;
772  int segment_size, offset2, mode, ret;
773 
774  ret = amdl_decode_int(&ctx->nb_segments, ac, &mode, 5);
775  if (ret < 0)
776  return ret;
777 
778  if (mode == 5) {
779  ret = ac_get_freq(ac, ctx->srate_pad >> 2, &segment_size);
780  if (ret < 0)
781  return ret;
782  ac_update(ac, segment_size, 1);
783  segment_size *= 4;
784  ret = decode_filter(s, ctx, ac, offset, segment_size);
785  if (ret < 0)
786  return ret;
787  } else {
788  segment_size = ctx->srate_pad;
789 
790  if (mode) {
791  if (mode > 2) {
792  ret = decode_filter(s, ctx, ac, offset, segment_size / 4);
793  if (ret < 0)
794  return ret;
795  offset2 = segment_size / 4 + offset;
796  ret = decode_filter(s, ctx, ac, offset2, segment_size / 4);
797  if (ret < 0)
798  return ret;
799  offset2 = segment_size / 4 + offset2;
800  } else {
801  ret = decode_filter(s, ctx, ac, offset, segment_size / 2);
802  if (ret < 0)
803  return ret;
804  offset2 = segment_size / 2 + offset;
805  }
806  if (mode & 1) {
807  ret = decode_filter(s, ctx, ac, offset2, segment_size / 2);
808  if (ret < 0)
809  return ret;
810  } else {
811  ret = decode_filter(s, ctx, ac, offset2, segment_size / 4);
812  if (ret < 0)
813  return ret;
814  ret = decode_filter(s, ctx, ac, segment_size / 4 + offset2, segment_size / 4);
815  if (ret < 0)
816  return ret;
817  }
818  } else {
819  ret = decode_filter(s, ctx, ac, offset, ctx->srate_pad);
820  if (ret < 0)
821  return ret;
822  }
823  }
824 
825  return segment_size;
826 }
827 
829 {
830  RKAContext *s = avctx->priv_data;
831  ACoder *ac = &s->ac;
832  int nb_decoded = 0;
833 
834  if (bytestream2_get_bytes_left(&ac->gb) <= 0)
835  return 0;
836 
837  memmove(c->buf0, &c->buf0[c->last_nb_decoded], 2560 * sizeof(*c->buf0));
838  memmove(c->buf1, &c->buf1[c->last_nb_decoded], 2560 * sizeof(*c->buf1));
839 
840  nb_decoded = decode_samples(avctx, ac, c, 2560);
841  if (nb_decoded < 0)
842  return nb_decoded;
843  c->last_nb_decoded = nb_decoded;
844 
845  return nb_decoded;
846 }
847 
849  int *got_frame_ptr, AVPacket *avpkt)
850 {
851  RKAContext *s = avctx->priv_data;
852  ACoder *ac = &s->ac;
853  int ret;
854 
855  bytestream2_init(&ac->gb, avpkt->data, avpkt->size);
856  init_acoder(ac);
857 
858  for (int ch = 0; ch < s->channels; ch++) {
859  ret = chctx_init(s, &s->ch[ch], avctx->sample_rate,
860  avctx->bits_per_raw_sample);
861  if (ret < 0)
862  return ret;
863  }
864 
865  frame->nb_samples = s->frame_samples;
866  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
867  return ret;
868 
869  if (s->channels == 2 && s->correlated) {
870  int16_t *l16 = (int16_t *)frame->extended_data[0];
871  int16_t *r16 = (int16_t *)frame->extended_data[1];
872  uint8_t *l8 = frame->extended_data[0];
873  uint8_t *r8 = frame->extended_data[1];
874 
875  for (int n = 0; n < frame->nb_samples;) {
876  ret = decode_ch_samples(avctx, &s->ch[0]);
877  if (ret == 0) {
878  frame->nb_samples = n;
879  break;
880  }
881  if (ret < 0 || n + ret > frame->nb_samples)
882  return AVERROR_INVALIDDATA;
883 
884  ret = decode_ch_samples(avctx, &s->ch[1]);
885  if (ret == 0) {
886  frame->nb_samples = n;
887  break;
888  }
889  if (ret < 0 || n + ret > frame->nb_samples)
890  return AVERROR_INVALIDDATA;
891 
892  switch (avctx->sample_fmt) {
893  case AV_SAMPLE_FMT_S16P:
894  for (int i = 0; i < ret; i++) {
895  int l = s->ch[0].buf0[2560 + i];
896  int r = s->ch[1].buf0[2560 + i];
897 
898  l16[n + i] = (l * 2 + r + 1) >> 1;
899  r16[n + i] = (l * 2 - r + 1) >> 1;
900  }
901  break;
902  case AV_SAMPLE_FMT_U8P:
903  for (int i = 0; i < ret; i++) {
904  int l = s->ch[0].buf0[2560 + i];
905  int r = s->ch[1].buf0[2560 + i];
906 
907  l8[n + i] = ((l * 2 + r + 1) >> 1) + 0x7f;
908  r8[n + i] = ((l * 2 - r + 1) >> 1) + 0x7f;
909  }
910  break;
911  default:
912  return AVERROR_INVALIDDATA;
913  }
914 
915  n += ret;
916  }
917  } else {
918  for (int n = 0; n < frame->nb_samples;) {
919  for (int ch = 0; ch < s->channels; ch++) {
920  int16_t *m16 = (int16_t *)frame->data[ch];
921  uint8_t *m8 = frame->data[ch];
922 
923  ret = decode_ch_samples(avctx, &s->ch[ch]);
924  if (ret == 0) {
925  frame->nb_samples = n;
926  break;
927  }
928 
929  if (ret < 0 || n + ret > frame->nb_samples)
930  return AVERROR_INVALIDDATA;
931 
932  switch (avctx->sample_fmt) {
933  case AV_SAMPLE_FMT_S16P:
934  for (int i = 0; i < ret; i++) {
935  int m = s->ch[ch].buf0[2560 + i];
936 
937  m16[n + i] = m;
938  }
939  break;
940  case AV_SAMPLE_FMT_U8P:
941  for (int i = 0; i < ret; i++) {
942  int m = s->ch[ch].buf0[2560 + i];
943 
944  m8[n + i] = m + 0x7f;
945  }
946  break;
947  default:
948  return AVERROR_INVALIDDATA;
949  }
950  }
951 
952  n += ret;
953  }
954  }
955 
956  if (frame->nb_samples < s->frame_samples &&
957  frame->nb_samples > s->last_nb_samples)
958  frame->nb_samples = s->last_nb_samples;
959 
960  *got_frame_ptr = 1;
961 
962  return avpkt->size;
963 }
964 
966 {
967  RKAContext *s = avctx->priv_data;
968 
969  for (int ch = 0; ch < 2; ch++) {
970  ChContext *c = &s->ch[ch];
971 
972  for (int i = 0; i < 11; i++)
973  adaptive_model_free(&c->coeff_bits[i]);
974 
975  adaptive_model_free(&c->position);
976  adaptive_model_free(&c->nb_segments);
977  adaptive_model_free(&c->fshift);
978  }
979 
980  adaptive_model_free(&s->filt_size);
981  adaptive_model_free(&s->filt_bits);
982 
983  return 0;
984 }
985 
987  .p.name = "rka",
988  CODEC_LONG_NAME("RKA (RK Audio)"),
989  .p.type = AVMEDIA_TYPE_AUDIO,
990  .p.id = AV_CODEC_ID_RKA,
991  .priv_data_size = sizeof(RKAContext),
993  .close = rka_decode_close,
995  .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_CHANNEL_CONF,
996  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
997 };
av_clip
#define av_clip
Definition: common.h:98
FF_CODEC_CAP_INIT_CLEANUP
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: codec_internal.h:42
AdaptiveModel::aprob0
uint16_t aprob0
Definition: rka.c:56
r
const char * r
Definition: vf_curves.c:126
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
ChContext::buf1
int32_t buf1[131072+2560]
Definition: rka.c:81
AVCodecContext::sample_rate
int sample_rate
samples per second
Definition: avcodec.h:1068
GetByteContext
Definition: bytestream.h:33
av_clip_int8
#define av_clip_int8
Definition: common.h:107
RKAContext::bprob
uint32_t bprob[2][257]
Definition: rka.c:99
ac_update
static int ac_update(ACoder *ac, int freq, int mul)
Definition: rka.c:338
Model64::zero
uint32_t zero[2]
Definition: rka.c:42
ACoder::low
uint32_t low
Definition: rka.c:32
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:340
AdaptiveModel::prob
uint16_t * prob[2]
Definition: rka.c:58
AVPacket::data
uint8_t * data
Definition: packet.h:522
b
#define b
Definition: input.c:41
adaptive_model_free
static void adaptive_model_free(AdaptiveModel *am)
Definition: rka.c:125
FFCodec
Definition: codec_internal.h:127
Model64::bits
int bits
Definition: rka.c:45
RKAContext::align
int align
Definition: rka.c:91
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
Model64::val4
uint16_t val4[65]
Definition: rka.c:47
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:323
sample_rate
sample_rate
Definition: ffmpeg_filter.c:424
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:361
FiltCoeffs
Definition: rka.c:36
Model64::size
unsigned size
Definition: rka.c:44
RKAContext::ch
ChContext ch[2]
Definition: rka.c:88
AdaptiveModel::last
int last
Definition: rka.c:52
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:131
ACoder::value
uint32_t value
Definition: rka.c:33
RKAContext::channels
int channels
Definition: rka.c:92
AVCodecContext::ch_layout
AVChannelLayout ch_layout
Audio channel layout.
Definition: avcodec.h:2111
ChContext::vrq
int vrq
Definition: rka.c:63
ACoder::high
uint32_t high
Definition: rka.c:32
decode_filt_coeffs
static int decode_filt_coeffs(RKAContext *s, ChContext *ctx, ACoder *ac, FiltCoeffs *dst)
Definition: rka.c:494
RKAContext::total_nb_samples
uint32_t total_nb_samples
Definition: rka.c:96
val
static double val(void *priv, double ch)
Definition: aeval.c:78
AV_CODEC_ID_RKA
@ AV_CODEC_ID_RKA
Definition: codec_id.h:545
Model64::val1
uint16_t val1[65]
Definition: rka.c:48
FiltCoeffs::size
unsigned size
Definition: rka.c:38
help
static void help(void)
Definition: dct.c:454
ChContext::position
AdaptiveModel position
Definition: rka.c:73
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
av_cold
#define av_cold
Definition: attributes.h:90
RKAContext::ac
ACoder ac
Definition: rka.c:87
AdaptiveModel::total
int total
Definition: rka.c:53
ChContext::fshift
AdaptiveModel fshift
Definition: rka.c:74
decode_filter
static int decode_filter(RKAContext *s, ChContext *ctx, ACoder *ac, int off, unsigned size)
Definition: rka.c:674
Model64::sign
uint32_t sign[2]
Definition: rka.c:43
ChContext::bprob
uint32_t * bprob[2]
Definition: rka.c:71
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:547
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:306
intreadwrite.h
s
#define s(width, name)
Definition: cbs_vp9.c:198
RKAContext::correlated
int correlated
Definition: rka.c:93
RKAContext
Definition: rka.c:84
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
bits
uint8_t bits
Definition: vp3data.h:128
ChContext::qfactor
int qfactor
Definition: rka.c:62
RKAContext::last_nb_samples
int last_nb_samples
Definition: rka.c:95
AVCodecContext::bits_per_raw_sample
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:1521
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
ctx
AVFormatContext * ctx
Definition: movenc.c:48
decode.h
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:272
frame
static AVFrame * frame
Definition: demux_decode.c:54
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:72
if
if(ret)
Definition: filter_design.txt:179
ChContext
Definition: apac.c:29
ac_dec_bit
static int ac_dec_bit(ACoder *ac)
Definition: rka.c:546
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
result
and forward the result(frame or status change) to the corresponding input. If nothing is possible
av_clip_int16
#define av_clip_int16
Definition: common.h:113
update_ch_subobj
static void update_ch_subobj(AdaptiveModel *am)
Definition: rka.c:376
init_acoder
static void init_acoder(ACoder *ac)
Definition: rka.c:246
ChContext::buf0
int32_t buf0[131072+2560]
Definition: rka.c:80
adaptive_model_init
static int adaptive_model_init(AdaptiveModel *am, int buf_size)
Definition: rka.c:105
RKAContext::filt_size
AdaptiveModel filt_size
Definition: rka.c:101
amdl_update_prob
static void amdl_update_prob(AdaptiveModel *am, int val, int diff)
Definition: rka.c:363
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
bytestream2_get_bytes_left
static av_always_inline int bytestream2_get_bytes_left(GetByteContext *g)
Definition: bytestream.h:158
AV_CODEC_CAP_CHANNEL_CONF
#define AV_CODEC_CAP_CHANNEL_CONF
Codec should fill in channel configuration and samplerate instead of container.
Definition: codec.h:106
decode_bool
static int decode_bool(ACoder *ac, ChContext *c, int idx)
Definition: rka.c:300
ChContext::filt_size
AdaptiveModel * filt_size
Definition: rka.c:68
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1618
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:365
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
ff_rka_decoder
const FFCodec ff_rka_decoder
Definition: rka.c:986
AVPacket::size
int size
Definition: packet.h:523
AV_SAMPLE_FMT_U8P
@ AV_SAMPLE_FMT_U8P
unsigned 8 bits, planar
Definition: samplefmt.h:63
codec_internal.h
shift
static int shift(int a, int b)
Definition: bonk.c:262
for
for(k=2;k<=8;++k)
Definition: h264pred_template.c:425
bps
unsigned bps
Definition: movenc.c:1787
AVCodecContext::sample_fmt
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1084
size
int size
Definition: twinvq_data.h:10344
AdaptiveModel::sum
int16_t sum
Definition: rka.c:55
diff
static av_always_inline int diff(const struct color_info *a, const struct color_info *b, const int trans_thresh)
Definition: vf_paletteuse.c:164
split
static char * split(char *message, char delim)
Definition: af_channelmap.c:80
offset
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
Definition: writing_filters.txt:86
ac_decode_bool
static int ac_decode_bool(ACoder *ac, int freq1, int freq2)
Definition: rka.c:253
ChContext::filt_bits
AdaptiveModel * filt_bits
Definition: rka.c:69
AV_SAMPLE_FMT_S16P
@ AV_SAMPLE_FMT_S16P
signed 16 bits, planar
Definition: samplefmt.h:64
ChContext::last_nb_decoded
int last_nb_decoded
Definition: rka.c:64
model64_init
static void model64_init(Model64 *m, unsigned bits)
Definition: rka.c:179
AVFrame::nb_samples
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:420
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:245
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:546
amdl_decode_int
static int amdl_decode_int(AdaptiveModel *am, ACoder *ac, unsigned *dst, unsigned size)
Definition: rka.c:409
chctx_init
static int chctx_init(RKAContext *s, ChContext *c, int sample_rate, int bps)
Definition: rka.c:200
AVFrame::extended_data
uint8_t ** extended_data
pointers to the data planes/channels.
Definition: frame.h:401
ChContext::pos_idx
unsigned pos_idx
Definition: rka.c:66
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:31
xf
#define xf(width, name, var, range_min, range_max, subs,...)
Definition: cbs_av1.c:590
value
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default value
Definition: writing_filters.txt:86
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:194
ChContext::nb_segments
AdaptiveModel nb_segments
Definition: rka.c:75
filt
static const int8_t filt[NUMTAPS *2]
Definition: af_earwax.c:39
RKAContext::filt_bits
AdaptiveModel filt_bits
Definition: rka.c:102
ChContext::coeff_bits
AdaptiveModel coeff_bits[11]
Definition: rka.c:76
avcodec.h
Model64
Definition: rka.c:41
ret
ret
Definition: filter_design.txt:187
AdaptiveModel::buf_size
int buf_size
Definition: rka.c:54
prob
#define prob(name, subs,...)
Definition: cbs_vp9.c:325
AdaptiveModel::aprob1
uint16_t aprob1
Definition: rka.c:57
AV_RL32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:92
U
#define U(x)
Definition: vpx_arith.h:37
RKAContext::bps
int bps
Definition: rka.c:90
AVCodecContext
main external API structure.
Definition: avcodec.h:445
RKAContext::samples_left
uint32_t samples_left
Definition: rka.c:97
channel_layout.h
RKAContext::frame_samples
int frame_samples
Definition: rka.c:94
mode
mode
Definition: ebur128.h:83
ChContext::srate_pad
unsigned srate_pad
Definition: rka.c:65
FiltCoeffs::coeffs
int32_t coeffs[257]
Definition: rka.c:37
av_channel_layout_uninit
void av_channel_layout_uninit(AVChannelLayout *channel_layout)
Free any allocated data in the channel layout and reset the channel count to 0.
Definition: channel_layout.c:662
vrq_qfactors
static const uint8_t vrq_qfactors[8]
Definition: rka.c:672
ac_get_freq
static int ac_get_freq(ACoder *ac, unsigned freq, int *result)
Definition: rka.c:320
ACoder
Definition: rka.c:30
rka_decode_frame
static int rka_decode_frame(AVCodecContext *avctx, AVFrame *frame, int *got_frame_ptr, AVPacket *avpkt)
Definition: rka.c:848
mdl64_decode
static int mdl64_decode(ACoder *ac, Model64 *ctx, int *dst)
Definition: rka.c:589
rka_decode_init
static av_cold int rka_decode_init(AVCodecContext *avctx)
Definition: rka.c:131
rka_decode_close
static av_cold int rka_decode_close(AVCodecContext *avctx)
Definition: rka.c:965
AVPacket
This structure stores compressed data.
Definition: packet.h:499
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:472
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
int32_t
int32_t
Definition: audioconvert.c:56
bytestream.h
bytestream2_init
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:137
decode_ch_samples
static int decode_ch_samples(AVCodecContext *avctx, ChContext *c)
Definition: rka.c:828
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
ACoder::gb
GetByteContext gb
Definition: rka.c:31
decode_samples
static int decode_samples(AVCodecContext *avctx, ACoder *ac, ChContext *ctx, int offset)
Definition: rka.c:769
AdaptiveModel
Definition: rka.c:51
ChContext::mdl64
Model64 mdl64[4][11]
Definition: rka.c:78