FFmpeg coverage


Directory: ../../../ffmpeg/
File: src/libavcodec/scpr3.c
Date: 2024-07-14 13:34:57
Exec Total Coverage
Lines: 0 817 0.0%
Functions: 0 33 0.0%
Branches: 0 437 0.0%

Line Branch Exec Source
1 /*
2 * ScreenPressor version 3 decoder
3 *
4 * Copyright (c) 2017 Paul B Mahol
5 *
6 * This file is part of FFmpeg.
7 *
8 * FFmpeg is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
12 *
13 * FFmpeg is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with FFmpeg; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21 */
22
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26
27 #include "libavutil/qsort.h"
28
29 #include "avcodec.h"
30 #include "bytestream.h"
31 #include "scpr.h"
32
33 static void renew_table3(uint32_t nsym, uint32_t *cntsum,
34 uint16_t *freqs, uint16_t *freqs1,
35 uint16_t *cnts, uint8_t *dectab)
36 {
37 uint32_t a = 0, b = 4096 / nsym, c = b - (b >> 1);
38
39 *cntsum = c * nsym;
40
41 for (int d = 0; d < nsym; d++) {
42 freqs[d] = b;
43 freqs1[d] = a;
44 cnts[d] = c;
45 for (int q = a + 128 - 1 >> 7, f = (a + b - 1 >> 7) + 1; q < f; q++)
46 dectab[q] = d;
47
48 a += b;
49 }
50 }
51
52 static void reinit_tables3(SCPRContext * s)
53 {
54 for (int i = 0; i < 3; i++) {
55 for (int j = 0; j < 4096; j++) {
56 PixelModel3 *m = &s->pixel_model3[i][j];
57 m->type = 0;
58 }
59 }
60
61 for (int i = 0; i < 6; i++) {
62 renew_table3(256, &s->run_model3[i].cntsum,
63 s->run_model3[i].freqs[0], s->run_model3[i].freqs[1],
64 s->run_model3[i].cnts, s->run_model3[i].dectab);
65 }
66
67 renew_table3(256, &s->range_model3.cntsum,
68 s->range_model3.freqs[0], s->range_model3.freqs[1],
69 s->range_model3.cnts, s->range_model3.dectab);
70
71 renew_table3(5, &s->fill_model3.cntsum,
72 s->fill_model3.freqs[0], s->fill_model3.freqs[1],
73 s->fill_model3.cnts, s->fill_model3.dectab);
74
75 renew_table3(256, &s->count_model3.cntsum,
76 s->count_model3.freqs[0], s->count_model3.freqs[1],
77 s->count_model3.cnts, s->count_model3.dectab);
78
79 for (int i = 0; i < 4; i++) {
80 renew_table3(16, &s->sxy_model3[i].cntsum,
81 s->sxy_model3[i].freqs[0], s->sxy_model3[i].freqs[1],
82 s->sxy_model3[i].cnts, s->sxy_model3[i].dectab);
83 }
84
85 for (int i = 0; i < 2; i++) {
86 renew_table3(512, &s->mv_model3[i].cntsum,
87 s->mv_model3[i].freqs[0], s->mv_model3[i].freqs[1],
88 s->mv_model3[i].cnts, s->mv_model3[i].dectab);
89 }
90
91 for (int i = 0; i < 6; i++) {
92 renew_table3(6, &s->op_model3[i].cntsum,
93 s->op_model3[i].freqs[0], s->op_model3[i].freqs[1],
94 s->op_model3[i].cnts, s->op_model3[i].dectab);
95 }
96 }
97
98 static int decode3(GetByteContext *gb, RangeCoder *rc, uint32_t a, uint32_t b)
99 {
100 uint32_t code = a * (rc->code >> 12) + (rc->code & 0xFFF) - b;
101
102 while (code < 0x800000 && bytestream2_get_bytes_left(gb) > 0)
103 code = bytestream2_get_byteu(gb) | (code << 8);
104 rc->code = code;
105
106 return 0;
107 }
108
109 static void rescale(PixelModel3 *m, int *totfr)
110 {
111 uint32_t a;
112
113 a = 256 - m->size;
114 for (int b = 0; b < m->size; b++) {
115 m->freqs[b] -= m->freqs[b] >> 1;
116 a += m->freqs[b];
117 }
118
119 *totfr = a;
120 }
121
122 static int add_symbol(PixelModel3 *m, int index, uint32_t symbol, int *totfr, int max)
123 {
124 if (m->size == max)
125 return 0;
126
127 for (int c = m->size - 1; c >= index; c--) {
128 m->symbols[c + 1] = m->symbols[c];
129 m->freqs[c + 1] = m->freqs[c];
130 }
131
132 m->symbols[index] = symbol;
133 m->freqs[index] = 50;
134 m->size++;
135
136 if (m->maxpos >= index)
137 m->maxpos++;
138
139 *totfr += 50;
140 if (*totfr + 50 > 4096)
141 rescale(m, totfr);
142
143 return 1;
144 }
145
146 static int decode_adaptive45(PixelModel3 *m, int rccode, uint32_t *value,
147 uint16_t *a, uint16_t *b, uint32_t *c, int max)
148 {
149 uint32_t q, g, maxpos, d, e = *c, totfr = *c;
150 int ret;
151
152 for (d = 0; e <= 2048; d++)
153 e <<= 1;
154 maxpos = m->maxpos;
155 rccode >>= d;
156 *c = m->freqs[maxpos];
157 m->freqs[maxpos] += 4096 - e >> d;
158
159 for (q = 0, g = 0, e = 0; q < m->size; q++) {
160 uint32_t f = m->symbols[q];
161 uint32_t p = e + f - g;
162 uint32_t k = m->freqs[q];
163
164 if (rccode < p) {
165 *value = rccode - e + g;
166 *b = rccode << d;
167 *a = 1 << d;
168 m->freqs[maxpos] = *c;
169 ret = add_symbol(m, q, *value, &totfr, max);
170 *c = totfr;
171 return ret;
172 }
173
174 if (p + k > rccode) {
175 *value = f;
176 e += *value - g;
177 *b = e << d;
178 *a = k << d;
179 m->freqs[maxpos] = *c;
180 m->freqs[q] += 50;
181 totfr += 50;
182 if ((q != maxpos) && (m->freqs[q] > m->freqs[maxpos]))
183 m->maxpos = q;
184 if (totfr + 50 > 4096)
185 rescale(m, &totfr);
186 *c = totfr;
187 return 1;
188 }
189
190 e += f - g + k;
191 g = f + 1;
192 }
193
194 m->freqs[maxpos] = *c;
195 *value = g + rccode - e;
196 *b = rccode << d;
197 *a = 1 << d;
198 ret = add_symbol(m, q, *value, &totfr, max);
199 *c = totfr;
200 return ret;
201 }
202
203 static int update_model6_to_7(PixelModel3 *m)
204 {
205 PixelModel3 n = {0};
206 int c, d, e, f, k, p, length, i, j, index;
207 uint16_t *freqs, *freqs1, *cnts;
208
209 n.type = 7;
210
211 length = m->length;
212 freqs = n.freqs;
213 freqs1 = n.freqs1;
214 cnts = n.cnts;
215 n.cntsum = m->cnts[length];
216 for (i = 0; i < length; i++) {
217 if (!m->cnts[i])
218 continue;
219 index = m->symbols[i];
220 freqs[index] = m->freqs[2 * i];
221 freqs1[index] = m->freqs[2 * i + 1];
222 cnts[index] = m->cnts[i];
223 }
224 c = 1 << m->fshift;
225 d = c - (c >> 1);
226 for (j = 0, e = 0; j < 256; j++) {
227 f = freqs[j];
228 if (!f) {
229 f = c;
230 freqs[j] = c;
231 freqs1[j] = e;
232 cnts[j] = d;
233 }
234 p = (e + 127) >> 7;
235 k = ((f + e - 1) >> 7) + 1;
236 if (k > FF_ARRAY_ELEMS(n.dectab))
237 return AVERROR_INVALIDDATA;
238 for (i = 0; i < k - p; i++)
239 n.dectab[p + i] = j;
240 e += f;
241 }
242
243 memcpy(m, &n, sizeof(n));
244
245 return 0;
246 }
247
248 static void calc_sum(PixelModel3 *m)
249 {
250 uint32_t a;
251 int len;
252
253 len = m->length;
254 a = 256 - m->size << (m->fshift > 0 ? m->fshift - 1 : 0);
255 for (int c = 0; c < len; c++)
256 a += m->cnts[c];
257 m->cnts[len] = a;
258 }
259
260 static void rescale_dec(PixelModel3 *m)
261 {
262 uint16_t cnts[256] = {0};
263 uint16_t freqs[512] = {0};
264 int b, c, e, g;
265 uint32_t a;
266
267 for (a = 1 << (0 < m->fshift ? m->fshift - 1 : 0), b = 0; b < 256; b++)
268 cnts[b] = a;
269
270 for (a = 0, b = m->size; a < b; a++)
271 cnts[m->symbols[a]] = m->cnts[a];
272
273 for (b = a = 0; b < 256; b++) {
274 freqs[2 * b] = cnts[b];
275 freqs[2 * b + 1] = a;
276 a += cnts[b];
277 }
278
279 if (m->fshift > 0)
280 m->fshift--;
281
282 a = 256 - m->size << (0 < m->fshift ? m->fshift - 1 : 0);
283 for (b = 0, c = m->size; b < c; b++) {
284 m->cnts[b] -= m->cnts[b] >> 1;
285 a = a + m->cnts[b];
286 e = m->symbols[b];
287 g = freqs[2 * e + 1];
288 m->freqs[2 * b] = freqs[2 * e];
289 m->freqs[2 * b + 1] = g;
290 }
291 m->cnts[m->length] = a;
292 }
293
294 static int update_model5_to_6(PixelModel3 *m, uint8_t value)
295 {
296 PixelModel3 n = {0};
297 int c, d, e, f, g, k, q, p;
298
299 n.type = 6;
300 n.length = 32;
301
302 for (c = m->size, d = 256 - c, e = 0; e < c; e++)
303 d = d + m->freqs[e];
304
305 for (e = 0; d <= 2048; e++)
306 d <<= 1;
307
308 for (q = d = 0, g = q = 0; g < c; g++) {
309 p = m->symbols[g];
310 d = d + (p - q);
311 q = m->freqs[g];
312 k = q << e;
313 n.freqs[2 * g] = k;
314 n.freqs[2 * g + 1] = d << e;
315 n.cnts[g] = k - (k >> 1);
316 n.symbols[g] = p;
317 d += q;
318 q = p + 1;
319 }
320
321 n.fshift = e;
322 e = 1 << n.fshift;
323 d = 0;
324 if (value > 0) {
325 d = -1;
326 for (p = f = g = 0; p < c; p++) {
327 k = n.symbols[p];
328 if (k > d && k < value) {
329 d = k;
330 g = n.freqs[2 * p];
331 f = n.freqs[2 * p + 1];
332 }
333 }
334 d = 0 < g ? f + g + (value - d - 1 << n.fshift) : value << n.fshift;
335 }
336 n.freqs[2 * c] = e;
337 n.freqs[2 * c + 1] = d;
338 n.cnts[c] = e - (e >> 1);
339 n.symbols[c] = value;
340 n.size = c + 1;
341 e = 25 << n.fshift;
342 n.cnts[c] += e;
343 n.cnts[32] += e;
344 if (n.cnts[32] + e > 4096)
345 rescale_dec(&n);
346
347 calc_sum(&n);
348 for (c = 0, e = n.size - 1; c < e; c++) {
349 for (g = c + 1, f = n.size; g < f; g++) {
350 if (q = n.freqs[2 * g], k = n.freqs[2 * c], q > k) {
351 int l = n.freqs[2 * c + 1];
352 int h = n.freqs[2 * g + 1];
353 n.freqs[2 * c] = q;
354 n.freqs[2 * c + 1] = h;
355 n.freqs[2 * g] = k;
356 n.freqs[2 * g + 1] = l;
357 FFSWAP(uint16_t, n.cnts[c], n.cnts[g]);
358 FFSWAP(uint8_t, n.symbols[c], n.symbols[g]);
359 }
360 }
361 }
362
363 memcpy(m, &n, sizeof(n));
364
365 return 0;
366 }
367
368 static void grow_dec(PixelModel3 *m)
369 {
370 int a;
371
372 a = 2 * m->length;
373 m->cnts[2 * m->length] = m->cnts[m->length];
374 m->length = a;
375 }
376
377 static int add_dec(PixelModel3 *m, int sym, int f1, int f2)
378 {
379 int size;
380
381 if (m->size >= 40 || m->size >= m->length)
382 return -1;
383
384 size = m->size;
385 m->symbols[size] = sym;
386 m->freqs[2 * size] = f1;
387 m->freqs[2 * size + 1] = f2;
388 m->cnts[size] = f1 - (f1 >> 1);
389 m->size++;
390
391 return size;
392 }
393
394 static void incr_cntdec(PixelModel3 *m, int a)
395 {
396 int b, len, d, e, g;
397
398 b = 25 << m->fshift;
399 len = m->length;
400 m->cnts[a] += b;
401 m->cnts[len] += b;
402 if (a > 0 && m->cnts[a] > m->cnts[a - 1]) {
403 FFSWAP(uint16_t, m->cnts[a], m->cnts[a - 1]);
404 d = m->freqs[2 * a];
405 e = m->freqs[2 * a + 1];
406 g = m->freqs[2 * (a - 1) + 1];
407 m->freqs[2 * a] = m->freqs[2 * (a - 1)];
408 m->freqs[2 * a + 1] = g;
409 g = a - 1;
410 m->freqs[2 * g] = d;
411 m->freqs[2 * g + 1] = e;
412 FFSWAP(uint8_t, m->symbols[a], m->symbols[a - 1]);
413 }
414
415 if (m->cnts[len] + b > 4096)
416 rescale_dec(m);
417 }
418
419 static int decode_adaptive6(PixelModel3 *m, uint32_t code, uint32_t *value,
420 uint16_t *a, uint16_t *b)
421 {
422 int c, d, e, f, g, q;
423
424 for (c = 0, d = 0, e = 0, f = 0, g = 0, q = m->size; g < q; g++) {
425 uint32_t p = m->freqs[2 * g + 1];
426
427 if (p <= code) {
428 uint32_t k = m->freqs[2 * g];
429
430 if (p + k > code) {
431 *value = m->symbols[g];
432 *a = k;
433 *b = p;
434 incr_cntdec(m, g);
435 return 1;
436 }
437
438 if (p >= d) {
439 c = k;
440 d = p;
441 e = m->symbols[g];
442 }
443 }
444 }
445
446 g = 1 << m->fshift;
447 q = f = 0;
448
449 if (c > 0) {
450 f = code - (d + c) >> m->fshift;
451 q = f + e + 1;
452 f = d + c + (f << m->fshift);
453 } else {
454 q = code >> m->fshift;
455 f = q << m->fshift;
456 }
457
458 *a = g;
459 *b = f;
460 *value = q;
461
462 c = add_dec(m, q, g, f);
463 if (c < 0) {
464 if (m->length == 64)
465 return 0;
466 grow_dec(m);
467 c = add_dec(m, q, g, f);
468 if (c < 0)
469 return AVERROR_INVALIDDATA;
470 }
471
472 incr_cntdec(m, c);
473 return 1;
474 }
475
476 static int cmpbytes(const void *p1, const void *p2)
477 {
478 int left = *(const uint8_t *)p1;
479 int right = *(const uint8_t *)p2;
480 return FFDIFFSIGN(left, right);
481 }
482
483 static int update_model1_to_2(PixelModel3 *m, uint32_t val)
484 {
485 PixelModel3 n = {0};
486 int i, b;
487
488 n.type = 2;
489 n.size = m->size + 1;
490 b = m->size;
491 for (i = 0; i < b; i++)
492 n.symbols[i] = m->symbols[i];
493 n.symbols[b] = val;
494
495 memcpy(m, &n, sizeof(n));
496
497 return 0;
498 }
499
500 static int update_model1_to_4(PixelModel3 *m, uint32_t val)
501 {
502 PixelModel3 n = {0};
503 int size, i;
504
505 size = m->size;
506 n.type = 4;
507 n.size = size;
508 for (i = 0; i < n.size; i++) {
509 n.symbols[i] = m->symbols[i];
510 }
511 AV_QSORT(n.symbols, size, uint8_t, cmpbytes);
512 for (i = 0; i < n.size; i++) {
513 if (val == n.symbols[i]) {
514 n.freqs[i] = 100;
515 n.maxpos = i;
516 } else {
517 n.freqs[i] = 50;
518 }
519 }
520
521 memcpy(m, &n, sizeof(n));
522
523 return 0;
524 }
525
526 static int update_model1_to_5(PixelModel3 *m, uint32_t val)
527 {
528 int i, size, freqs;
529 uint32_t a;
530
531 update_model1_to_4(m, val);
532 size = m->size;
533 a = 256 - size;
534 for (i = 0; i < size; i++, a += freqs)
535 freqs = m->freqs[i];
536 m->type = 5;
537 m->cntsum = a;
538
539 return 0;
540 }
541
542 static int decode_static1(PixelModel3 *m, uint32_t val)
543 {
544 uint32_t size;
545
546 size = m->size;
547 for (int i = 0; i < size; i++) {
548 if (val == m->symbols[i]) {
549 if (size <= 4)
550 return update_model1_to_4(m, val);
551 else
552 return update_model1_to_5(m, val);
553 }
554 }
555
556 if (size >= 14)
557 return update_model1_to_2(m, val);
558
559 m->symbols[size] = val;
560 m->size++;
561 return 0;
562 }
563
564 static int update_model2_to_6(PixelModel3 *m, uint8_t value, int a4)
565 {
566 PixelModel3 n = {0};
567 int c, d, e, f, g, q;
568
569 n.type = 6;
570 n.length = a4;
571
572 memset(n.symbols, 1u, a4);
573
574 c = m->size;
575 d = 256 - c + (64 * c + 64);
576 for (e = 0; d <= 2048; e++) {
577 d <<= 1;
578 }
579
580 g = q = 0;
581 AV_QSORT(m->symbols, c, uint8_t, cmpbytes);
582 for (f = d = 0; f < c; f++) {
583 int p = f;
584 int k = m->symbols[p];
585 int l;
586 g = g + (k - q);
587
588 if (k == value) {
589 d = p;
590 q = 128;
591 } else {
592 q = 64;
593 }
594 l = q << e;
595 n.freqs[2 * p] = l;
596 n.freqs[2 * p + 1] = g << e;
597 n.symbols[p] = k;
598 n.cnts[p] = l - (l >> 1);
599 g += q;
600 q = k + 1;
601 }
602 n.size = c;
603 n.fshift = e;
604 calc_sum(&n);
605
606 if (d > 0) {
607 c = n.freqs[0];
608 e = n.freqs[1];
609 g = n.freqs[2 * d + 1];
610 n.freqs[0] = n.freqs[2 * d];
611 n.freqs[1] = g;
612 n.freqs[2 * d] = c;
613 n.freqs[2 * d + 1] = e;
614 FFSWAP(uint16_t, n.cnts[0], n.cnts[d]);
615 FFSWAP(uint8_t, n.symbols[0], n.symbols[d]);
616 }
617
618 memcpy(m, &n, sizeof(n));
619
620 return 0;
621 }
622
623 static int update_model2_to_3(PixelModel3 *m, uint32_t val)
624 {
625 PixelModel3 n = {0};
626 uint32_t size;
627
628 n.type = 3;
629 n.size = m->size + 1;
630
631 size = m->size;
632 for (int i = 0; i < size; i++)
633 n.symbols[i] = m->symbols[i];
634 n.symbols[size] = val;
635
636 memcpy(m, &n, sizeof(n));
637
638 return 0;
639 }
640
641 static int decode_static2(PixelModel3 *m, uint32_t val)
642 {
643 uint32_t size;
644
645 size = m->size;
646 for (int i = 0; i < size; i++) {
647 if (val == m->symbols[i]) {
648 int a;
649
650 if (m->size <= 32)
651 a = 32;
652 else
653 a = 64;
654 return update_model2_to_6(m, val, a);
655 }
656 }
657
658 if (size >= 64)
659 return update_model2_to_3(m, val);
660
661 m->symbols[size] = val;
662 m->size++;
663
664 return 0;
665 }
666
667 static int update_model3_to_7(PixelModel3 *m, uint8_t value)
668 {
669 PixelModel3 n = {0};
670 int c, d, e, f, g, q;
671
672 n.type = 7;
673
674 for (c = 0; c < 256; c++) {
675 d = c;
676 n.freqs[d] = 1;
677 n.cnts[d] = 1;
678 }
679
680 for (c = m->size, d = (4096 - (256 - c)) / (c + 1) | 0, e = d - (d >> 1), g = 0; g < c;) {
681 q = g++;
682 q = m->symbols[q];
683 n.freqs[q] = d;
684 n.cnts[q] = e;
685 }
686 n.freqs[value] += d;
687 n.cnts[value] += 16;
688 for (d = c = n.cntsum = 0; 256 > d; d++) {
689 e = d;
690 n.cntsum += n.cnts[e];
691 n.freqs1[e] = c;
692 g = n.freqs[e];
693 f = (c + g - 1 >> 7) + 1;
694 if (f > FF_ARRAY_ELEMS(n.dectab))
695 return AVERROR_INVALIDDATA;
696 for (q = c + 128 - 1 >> 7; q < f; q++) {
697 n.dectab[q] = e;
698 }
699 c += g;
700 }
701
702 memcpy(m, &n, sizeof(n));
703
704 return 0;
705 }
706
707 static int decode_static3(PixelModel3 *m, uint32_t val)
708 {
709 uint32_t size = m->size;
710
711 for (int i = 0; i < size; i++) {
712 if (val == m->symbols[i])
713 return update_model3_to_7(m, val);
714 }
715
716 if (size >= 256)
717 return 0;
718
719 m->symbols[size] = val;
720 m->size++;
721 return 0;
722 }
723
724 static void sync_code3(GetByteContext *gb, RangeCoder *rc)
725 {
726 rc->code1++;
727 if (rc->code1 == 0x20000) {
728 rc->code = bytestream2_get_le32(gb);
729 rc->code1 = 0;
730 }
731 }
732
733 static int decode_value3(SCPRContext *s, uint32_t max, uint32_t *cntsum,
734 uint16_t *freqs1, uint16_t *freqs2,
735 uint16_t *cnts, uint8_t *dectable,
736 uint32_t *value)
737 {
738 GetByteContext *gb = &s->gb;
739 RangeCoder *rc = &s->rc;
740 uint32_t r, y, a, b, e, g, q;
741
742 r = dectable[(rc->code & 0xFFFu) >> 7];
743 if (r < max) {
744 while (freqs2[r + 1] <= (rc->code & 0xFFF)) {
745 if (++r >= max)
746 break;
747 }
748 }
749
750 if (r > max)
751 return AVERROR_INVALIDDATA;
752
753 cnts[r] += 16;
754 a = freqs1[r];
755 b = freqs2[r];
756 *cntsum += 16;
757 if (*cntsum + 16 > 4096) {
758 *cntsum = 0;
759 for (int c = 0, i = 0; i < max + 1; i++) {
760 e = cnts[i];
761 freqs2[i] = c;
762 freqs1[i] = e;
763 g = (c + 127) >> 7;
764 c += e;
765 q = ((c - 1) >> 7) + 1;
766 if (q > g) {
767 for (int j = 0; j < q - g; j++)
768 dectable[j + g] = i;
769 }
770 y = e - (e >> 1);
771 cnts[i] = y;
772 *cntsum += y;
773 }
774 }
775
776 decode3(gb, rc, a, b);
777 sync_code3(gb, rc);
778
779 *value = r;
780
781 return 0;
782 }
783
784 static void calc_sum5(PixelModel3 *m)
785 {
786 uint32_t a;
787
788 a = 256 - m->size;
789 for (int b = 0; b < m->size; b++)
790 a += m->freqs[b];
791 m->cntsum = a;
792 }
793
794 static int update_model4_to_5(PixelModel3 *m, uint32_t value)
795 {
796 PixelModel3 n = {0};
797 int c, e, g, totfr;
798
799 n.type = 5;
800
801 for (c = 0, e = 0; c < m->size && m->symbols[c] < value; c++) {
802 n.symbols[c] = m->symbols[c];
803 e += n.freqs[c] = m->freqs[c];
804 }
805
806 g = c;
807 n.symbols[g] = value;
808 e += n.freqs[g++] = 50;
809 for (; c < m->size; g++, c++) {
810 n.symbols[g] = m->symbols[c];
811 e += n.freqs[g] = m->freqs[c];
812 }
813 n.size = m->size + 1;
814 if (e > 4096)
815 rescale(&n, &totfr);
816
817 calc_sum5(&n);
818
819 memcpy(m, &n, sizeof(n));
820
821 return 0;
822 }
823
824 static int decode_unit3(SCPRContext *s, PixelModel3 *m, uint32_t code, uint32_t *value)
825 {
826 GetByteContext *gb = &s->gb;
827 RangeCoder *rc = &s->rc;
828 uint16_t a = 0, b = 0;
829 uint32_t param;
830 int type;
831 int ret;
832
833 type = m->type;
834 switch (type) {
835 case 0:
836 *value = bytestream2_get_byte(&s->gb);
837 m->type = 1;
838 m->size = 1;
839 m->symbols[0] = *value;
840 sync_code3(gb, rc);
841 break;
842 case 1:
843 *value = bytestream2_get_byte(&s->gb);
844 decode_static1(m, *value);
845 sync_code3(gb, rc);
846 break;
847 case 2:
848 *value = bytestream2_get_byte(&s->gb);
849 decode_static2(m, *value);
850 sync_code3(gb, rc);
851 break;
852 case 3:
853 *value = bytestream2_get_byte(&s->gb);
854 ret = decode_static3(m, *value);
855 if (ret < 0)
856 return AVERROR_INVALIDDATA;
857 sync_code3(gb, rc);
858 break;
859 case 4:
860 param = m->freqs[0] + m->freqs[1] + m->freqs[2] + m->freqs[3] + 256 - m->size;
861 if (!decode_adaptive45(m, code, value, &a, &b, &param, 4))
862 update_model4_to_5(m, *value);
863 decode3(gb, rc, a, b);
864 sync_code3(gb, rc);
865 break;
866 case 5:
867 if (!decode_adaptive45(m, code, value, &a, &b, &m->cntsum, 16))
868 update_model5_to_6(m, *value);
869 decode3(gb, rc, a, b);
870 sync_code3(gb, rc);
871 break;
872 case 6:
873 ret = decode_adaptive6(m, code, value, &a, &b);
874 if (!ret)
875 ret = update_model6_to_7(m);
876 if (ret < 0)
877 return ret;
878 decode3(gb, rc, a, b);
879 sync_code3(gb, rc);
880 break;
881 case 7:
882 return decode_value3(s, 255, &m->cntsum,
883 m->freqs, m->freqs1,
884 m->cnts, m->dectab, value);
885 }
886
887 if (*value > 255)
888 return AVERROR_INVALIDDATA;
889
890 return 0;
891 }
892
893 static int decode_units3(SCPRContext * s, uint32_t *red,
894 uint32_t *green, uint32_t *blue,
895 int *cx, int *cx1)
896 {
897 RangeCoder *rc = &s->rc;
898 int ret;
899
900 ret = decode_unit3(s, &s->pixel_model3[0][*cx + *cx1], rc->code & 0xFFF, red);
901 if (ret < 0)
902 return ret;
903
904 *cx1 = (*cx << 6) & 0xFC0;
905 *cx = *red >> 2;
906
907 ret = decode_unit3(s, &s->pixel_model3[1][*cx + *cx1], rc->code & 0xFFF, green);
908 if (ret < 0)
909 return ret;
910
911 *cx1 = (*cx << 6) & 0xFC0;
912 *cx = *green >> 2;
913
914 ret = decode_unit3(s, &s->pixel_model3[2][*cx + *cx1], rc->code & 0xFFF, blue);
915 if (ret < 0)
916 return ret;
917
918 *cx1 = (*cx << 6) & 0xFC0;
919 *cx = *blue >> 2;
920
921 return 0;
922 }
923
924 static void init_rangecoder3(RangeCoder *rc, GetByteContext *gb)
925 {
926 rc->code = bytestream2_get_le32(gb);
927 rc->code1 = 0;
928 }
929
930 static int decompress_i3(AVCodecContext *avctx, uint32_t *dst, int linesize)
931 {
932 SCPRContext *s = avctx->priv_data;
933 GetByteContext *gb = &s->gb;
934 RangeCoder *rc = &s->rc;
935 int cx = 0, cx1 = 0, k = 0;
936 int run, off, y = 0, x = 0, ret;
937 uint32_t backstep = linesize - avctx->width;
938 uint32_t clr = 0, lx, ly, ptype, r, g, b;
939
940 bytestream2_skip(gb, 1);
941 init_rangecoder3(rc, gb);
942 reinit_tables3(s);
943
944 while (k < avctx->width + 1) {
945 ret = decode_units3(s, &r, &g, &b, &cx, &cx1);
946 if (ret < 0)
947 return ret;
948 ret = decode_value3(s, 255, &s->run_model3[0].cntsum,
949 s->run_model3[0].freqs[0],
950 s->run_model3[0].freqs[1],
951 s->run_model3[0].cnts,
952 s->run_model3[0].dectab, &run);
953 if (ret < 0)
954 return ret;
955 if (run <= 0)
956 return AVERROR_INVALIDDATA;
957
958 clr = (b << 16) + (g << 8) + r;
959 k += run;
960 while (run-- > 0) {
961 if (y >= avctx->height)
962 return AVERROR_INVALIDDATA;
963
964 dst[y * linesize + x] = clr;
965 lx = x;
966 ly = y;
967 x++;
968 if (x >= avctx->width) {
969 x = 0;
970 y++;
971 }
972 }
973 }
974 off = -linesize - 1;
975 ptype = 0;
976
977 while (x < avctx->width && y < avctx->height) {
978 ret = decode_value3(s, 5, &s->op_model3[ptype].cntsum,
979 s->op_model3[ptype].freqs[0],
980 s->op_model3[ptype].freqs[1],
981 s->op_model3[ptype].cnts,
982 s->op_model3[ptype].dectab, &ptype);
983 if (ret < 0)
984 return ret;
985 if (ptype == 0) {
986 ret = decode_units3(s, &r, &g, &b, &cx, &cx1);
987 if (ret < 0)
988 return ret;
989 clr = (b << 16) + (g << 8) + r;
990 }
991 if (ptype > 5)
992 return AVERROR_INVALIDDATA;
993 ret = decode_value3(s, 255, &s->run_model3[ptype].cntsum,
994 s->run_model3[ptype].freqs[0],
995 s->run_model3[ptype].freqs[1],
996 s->run_model3[ptype].cnts,
997 s->run_model3[ptype].dectab, &run);
998 if (ret < 0)
999 return ret;
1000 if (run <= 0)
1001 return AVERROR_INVALIDDATA;
1002
1003 ret = decode_run_i(avctx, ptype, run, &x, &y, clr,
1004 dst, linesize, &lx, &ly,
1005 backstep, off, &cx, &cx1);
1006 if (ret < 0)
1007 return ret;
1008 }
1009
1010 return 0;
1011 }
1012
1013 static int decompress_p3(AVCodecContext *avctx,
1014 uint32_t *dst, int linesize,
1015 uint32_t *prev, int plinesize)
1016 {
1017 SCPRContext *s = avctx->priv_data;
1018 GetByteContext *gb = &s->gb;
1019 int ret, temp, min, max, x, y, cx = 0, cx1 = 0;
1020 int backstep = linesize - avctx->width;
1021 int mvx = 0, mvy = 0;
1022
1023 if (bytestream2_get_byte(gb) == 0)
1024 return 1;
1025 init_rangecoder3(&s->rc, gb);
1026
1027 ret = decode_value3(s, 255, &s->range_model3.cntsum,
1028 s->range_model3.freqs[0],
1029 s->range_model3.freqs[1],
1030 s->range_model3.cnts,
1031 s->range_model3.dectab, &min);
1032 ret |= decode_value3(s, 255, &s->range_model3.cntsum,
1033 s->range_model3.freqs[0],
1034 s->range_model3.freqs[1],
1035 s->range_model3.cnts,
1036 s->range_model3.dectab, &temp);
1037 if (ret < 0)
1038 return ret;
1039
1040 min += temp << 8;
1041 ret |= decode_value3(s, 255, &s->range_model3.cntsum,
1042 s->range_model3.freqs[0],
1043 s->range_model3.freqs[1],
1044 s->range_model3.cnts,
1045 s->range_model3.dectab, &max);
1046 ret |= decode_value3(s, 255, &s->range_model3.cntsum,
1047 s->range_model3.freqs[0],
1048 s->range_model3.freqs[1],
1049 s->range_model3.cnts,
1050 s->range_model3.dectab, &temp);
1051 if (ret < 0)
1052 return ret;
1053
1054 max += temp << 8;
1055 if (min > max || min >= s->nbcount)
1056 return AVERROR_INVALIDDATA;
1057
1058 memset(s->blocks, 0, sizeof(*s->blocks) * s->nbcount);
1059
1060 while (min <= max) {
1061 int fill, count;
1062
1063 ret = decode_value3(s, 4, &s->fill_model3.cntsum,
1064 s->fill_model3.freqs[0],
1065 s->fill_model3.freqs[1],
1066 s->fill_model3.cnts,
1067 s->fill_model3.dectab, &fill);
1068 ret |= decode_value3(s, 255, &s->count_model3.cntsum,
1069 s->count_model3.freqs[0],
1070 s->count_model3.freqs[1],
1071 s->count_model3.cnts,
1072 s->count_model3.dectab, &count);
1073 if (ret < 0)
1074 return ret;
1075 if (count <= 0)
1076 return AVERROR_INVALIDDATA;
1077
1078 while (min < s->nbcount && count-- > 0) {
1079 s->blocks[min++] = fill;
1080 }
1081 }
1082
1083 ret = av_frame_copy(s->current_frame, s->last_frame);
1084 if (ret < 0)
1085 return ret;
1086
1087 for (y = 0; y < s->nby; y++) {
1088 for (x = 0; x < s->nbx; x++) {
1089 int sy1 = 0, sy2 = 16, sx1 = 0, sx2 = 16;
1090
1091 if (s->blocks[y * s->nbx + x] == 0)
1092 continue;
1093
1094 if (((s->blocks[y * s->nbx + x] + 1) & 1) > 0) {
1095 ret = decode_value3(s, 15, &s->sxy_model3[0].cntsum,
1096 s->sxy_model3[0].freqs[0],
1097 s->sxy_model3[0].freqs[1],
1098 s->sxy_model3[0].cnts,
1099 s->sxy_model3[0].dectab, &sx1);
1100 ret |= decode_value3(s, 15, &s->sxy_model3[1].cntsum,
1101 s->sxy_model3[1].freqs[0],
1102 s->sxy_model3[1].freqs[1],
1103 s->sxy_model3[1].cnts,
1104 s->sxy_model3[1].dectab, &sy1);
1105 ret |= decode_value3(s, 15, &s->sxy_model3[2].cntsum,
1106 s->sxy_model3[2].freqs[0],
1107 s->sxy_model3[2].freqs[1],
1108 s->sxy_model3[2].cnts,
1109 s->sxy_model3[2].dectab, &sx2);
1110 ret |= decode_value3(s, 15, &s->sxy_model3[3].cntsum,
1111 s->sxy_model3[3].freqs[0],
1112 s->sxy_model3[3].freqs[1],
1113 s->sxy_model3[3].cnts,
1114 s->sxy_model3[3].dectab, &sy2);
1115 if (ret < 0)
1116 return ret;
1117
1118 sx2++;
1119 sy2++;
1120 }
1121 if (((s->blocks[y * s->nbx + x] + 3) & 2) > 0) {
1122 int i, a, b, c, j, by = y * 16, bx = x * 16;
1123 uint32_t code;
1124
1125 a = s->rc.code & 0xFFF;
1126 c = 1;
1127
1128 if (a < 0x800)
1129 c = 0;
1130 b = 2048;
1131 if (!c)
1132 b = 0;
1133
1134 code = a + ((s->rc.code >> 1) & 0xFFFFF800) - b;
1135 while (code < 0x800000 && bytestream2_get_bytes_left(gb) > 0)
1136 code = bytestream2_get_byteu(gb) | (code << 8);
1137 s->rc.code = code;
1138
1139 sync_code3(gb, &s->rc);
1140
1141 if (!c) {
1142 ret = decode_value3(s, 511, &s->mv_model3[0].cntsum,
1143 s->mv_model3[0].freqs[0],
1144 s->mv_model3[0].freqs[1],
1145 s->mv_model3[0].cnts,
1146 s->mv_model3[0].dectab, &mvx);
1147 ret |= decode_value3(s, 511, &s->mv_model3[1].cntsum,
1148 s->mv_model3[1].freqs[0],
1149 s->mv_model3[1].freqs[1],
1150 s->mv_model3[1].cnts,
1151 s->mv_model3[1].dectab, &mvy);
1152 if (ret < 0)
1153 return ret;
1154
1155 mvx -= 256;
1156 mvy -= 256;
1157 }
1158
1159 if (by + mvy + sy1 < 0 || bx + mvx + sx1 < 0 ||
1160 by + mvy + sy1 >= avctx->height || bx + mvx + sx1 >= avctx->width)
1161 return AVERROR_INVALIDDATA;
1162
1163 for (i = 0; i < sy2 - sy1 && (by + sy1 + i) < avctx->height && (by + mvy + sy1 + i) < avctx->height; i++) {
1164 for (j = 0; j < sx2 - sx1 && (bx + sx1 + j) < avctx->width && (bx + mvx + sx1 + j) < avctx->width; j++) {
1165 dst[(by + i + sy1) * linesize + bx + sx1 + j] = prev[(by + mvy + sy1 + i) * plinesize + bx + sx1 + mvx + j];
1166 }
1167 }
1168 } else {
1169 int run, bx = x * 16 + sx1, by = y * 16 + sy1;
1170 uint32_t clr, ptype = 0, r, g, b;
1171
1172 if (bx >= avctx->width)
1173 return AVERROR_INVALIDDATA;
1174
1175 for (; by < y * 16 + sy2 && by < avctx->height;) {
1176 ret = decode_value3(s, 5, &s->op_model3[ptype].cntsum,
1177 s->op_model3[ptype].freqs[0],
1178 s->op_model3[ptype].freqs[1],
1179 s->op_model3[ptype].cnts,
1180 s->op_model3[ptype].dectab, &ptype);
1181 if (ret < 0)
1182 return ret;
1183 if (ptype == 0) {
1184 ret = decode_units3(s, &r, &g, &b, &cx, &cx1);
1185 if (ret < 0)
1186 return ret;
1187
1188 clr = (b << 16) + (g << 8) + r;
1189 }
1190 if (ptype > 5)
1191 return AVERROR_INVALIDDATA;
1192 ret = decode_value3(s, 255, &s->run_model3[ptype].cntsum,
1193 s->run_model3[ptype].freqs[0],
1194 s->run_model3[ptype].freqs[1],
1195 s->run_model3[ptype].cnts,
1196 s->run_model3[ptype].dectab, &run);
1197 if (ret < 0)
1198 return ret;
1199 if (run <= 0)
1200 return AVERROR_INVALIDDATA;
1201
1202 ret = decode_run_p(avctx, ptype, run, x, y, clr,
1203 dst, prev, linesize, plinesize, &bx, &by,
1204 backstep, sx1, sx2, &cx, &cx1);
1205 if (ret < 0)
1206 return ret;
1207 }
1208 }
1209 }
1210 }
1211
1212 return 0;
1213 }
1214