2 * ScreenPressor version 3 decoder
4 * Copyright (c) 2017 Paul B Mahol
6 * This file is part of FFmpeg.
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.
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.
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
27 #include "libavutil/qsort.h"
30 #include "bytestream.h"
34 static void renew_table3(uint32_t nsym, uint32_t *cntsum,
35 uint16_t *freqs, uint16_t *freqs1,
36 uint16_t *cnts, uint8_t *dectab)
38 uint32_t a = 0, b = 4096 / nsym, c = b - (b >> 1);
42 for (int d = 0; d < nsym; d++) {
46 for (int q = a + 128 - 1 >> 7, f = (a + b - 1 >> 7) + 1; q < f; q++)
53 static void reinit_tables3(SCPRContext * s)
55 for (int i = 0; i < 3; i++) {
56 for (int j = 0; j < 4096; j++) {
57 PixelModel3 *m = &s->pixel_model3[i][j];
62 for (int i = 0; i < 6; i++) {
63 renew_table3(256, &s->run_model3[i].cntsum,
64 s->run_model3[i].freqs[0], s->run_model3[i].freqs[1],
65 s->run_model3[i].cnts, s->run_model3[i].dectab);
68 renew_table3(256, &s->range_model3.cntsum,
69 s->range_model3.freqs[0], s->range_model3.freqs[1],
70 s->range_model3.cnts, s->range_model3.dectab);
72 renew_table3(5, &s->fill_model3.cntsum,
73 s->fill_model3.freqs[0], s->fill_model3.freqs[1],
74 s->fill_model3.cnts, s->fill_model3.dectab);
76 renew_table3(256, &s->count_model3.cntsum,
77 s->count_model3.freqs[0], s->count_model3.freqs[1],
78 s->count_model3.cnts, s->count_model3.dectab);
80 for (int i = 0; i < 4; i++) {
81 renew_table3(16, &s->sxy_model3[i].cntsum,
82 s->sxy_model3[i].freqs[0], s->sxy_model3[i].freqs[1],
83 s->sxy_model3[i].cnts, s->sxy_model3[i].dectab);
86 for (int i = 0; i < 2; i++) {
87 renew_table3(512, &s->mv_model3[i].cntsum,
88 s->mv_model3[i].freqs[0], s->mv_model3[i].freqs[1],
89 s->mv_model3[i].cnts, s->mv_model3[i].dectab);
92 for (int i = 0; i < 6; i++) {
93 renew_table3(6, &s->op_model3[i].cntsum,
94 s->op_model3[i].freqs[0], s->op_model3[i].freqs[1],
95 s->op_model3[i].cnts, s->op_model3[i].dectab);
99 static int decode3(GetByteContext *gb, RangeCoder *rc, uint32_t a, uint32_t b)
101 uint32_t code = a * (rc->code >> 12) + (rc->code & 0xFFF) - b;
103 while (code < 0x800000 && bytestream2_get_bytes_left(gb) > 0)
104 code = bytestream2_get_byteu(gb) | (code << 8);
110 static void rescale(PixelModel3 *m, int *totfr)
115 for (int b = 0; b < m->size; b++) {
116 m->freqs[b] -= m->freqs[b] >> 1;
123 static int add_symbol(PixelModel3 *m, int index, uint32_t symbol, int *totfr, int max)
128 for (int c = m->size - 1; c >= index; c--) {
129 m->symbols[c + 1] = m->symbols[c];
130 m->freqs[c + 1] = m->freqs[c];
133 m->symbols[index] = symbol;
134 m->freqs[index] = 50;
137 if (m->maxpos >= index)
141 if (*totfr + 50 > 4096)
147 static int decode_adaptive45(PixelModel3 *m, int rccode, uint32_t *value,
148 uint16_t *a, uint16_t *b, uint32_t *c, int max)
150 uint32_t q, g, maxpos, d, e = *c, totfr = *c;
153 for (d = 0; e <= 2048; d++)
157 *c = m->freqs[maxpos];
158 m->freqs[maxpos] += 4096 - e >> d;
160 for (q = 0, g = 0, e = 0; q < m->size; q++) {
161 uint32_t f = m->symbols[q];
162 uint32_t p = e + f - g;
163 uint32_t k = m->freqs[q];
166 *value = rccode - e + g;
169 m->freqs[maxpos] = *c;
170 ret = add_symbol(m, q, *value, &totfr, max);
175 if (p + k > rccode) {
180 m->freqs[maxpos] = *c;
183 if ((q != maxpos) && (m->freqs[q] > m->freqs[maxpos]))
185 if (totfr + 50 > 4096)
195 m->freqs[maxpos] = *c;
196 *value = g + rccode - e;
199 ret = add_symbol(m, q, *value, &totfr, max);
204 static int update_model6_to_7(PixelModel3 *m)
207 int c, d, e, f, k, p, length, i, j, index;
208 uint16_t *freqs, *freqs1, *cnts;
216 n.cntsum = m->cnts[length];
217 for (i = 0; i < length; i++) {
220 index = m->symbols[i];
221 freqs[index] = m->freqs[2 * i];
222 freqs1[index] = m->freqs[2 * i + 1];
223 cnts[index] = m->cnts[i];
227 for (j = 0, e = 0; j < 256; j++) {
236 k = ((f + e - 1) >> 7) + 1;
237 if (k > FF_ARRAY_ELEMS(n.dectab))
238 return AVERROR_INVALIDDATA;
239 for (i = 0; i < k - p; i++)
244 memcpy(m, &n, sizeof(n));
249 static void calc_sum(PixelModel3 *m)
255 a = 256 - m->size << (m->fshift > 0 ? m->fshift - 1 : 0);
256 for (int c = 0; c < len; c++)
261 static void rescale_dec(PixelModel3 *m)
263 uint16_t cnts[256] = {0};
264 uint16_t freqs[512] = {0};
268 for (a = 1 << (0 < m->fshift ? m->fshift - 1 : 0), b = 0; b < 256; b++)
271 for (a = 0, b = m->size; a < b; a++)
272 cnts[m->symbols[a]] = m->cnts[a];
274 for (b = a = 0; b < 256; b++) {
275 freqs[2 * b] = cnts[b];
276 freqs[2 * b + 1] = a;
283 a = 256 - m->size << (0 < m->fshift ? m->fshift - 1 : 0);
284 for (b = 0, c = m->size; b < c; b++) {
285 m->cnts[b] -= m->cnts[b] >> 1;
288 g = freqs[2 * e + 1];
289 m->freqs[2 * b] = freqs[2 * e];
290 m->freqs[2 * b + 1] = g;
292 m->cnts[m->length] = a;
295 static int update_model5_to_6(PixelModel3 *m, uint8_t value)
298 int c, d, e, f, g, k, q, p;
303 for (c = m->size, d = 256 - c, e = 0; e < c; e++)
306 for (e = 0; d <= 2048; e++)
309 for (q = d = 0, g = q = 0; g < c; g++) {
315 n.freqs[2 * g + 1] = d << e;
316 n.cnts[g] = k - (k >> 1);
327 for (p = f = g = 0; p < c; p++) {
329 if (k > d && k < value) {
332 f = n.freqs[2 * p + 1];
335 d = 0 < g ? f + g + (value - d - 1 << n.fshift) : value << n.fshift;
338 n.freqs[2 * c + 1] = d;
339 n.cnts[c] = e - (e >> 1);
340 n.symbols[c] = value;
345 if (n.cnts[32] + e > 4096)
349 for (c = 0, e = n.size - 1; c < e; c++) {
350 for (g = c + 1, f = n.size; g < f; g++) {
351 if (q = n.freqs[2 * g], k = n.freqs[2 * c], q > k) {
352 int l = n.freqs[2 * c + 1];
353 int h = n.freqs[2 * g + 1];
355 n.freqs[2 * c + 1] = h;
357 n.freqs[2 * g + 1] = l;
358 FFSWAP(uint16_t, n.cnts[c], n.cnts[g]);
359 FFSWAP(uint8_t, n.symbols[c], n.symbols[g]);
364 memcpy(m, &n, sizeof(n));
369 static void grow_dec(PixelModel3 *m)
374 m->cnts[2 * m->length] = m->cnts[m->length];
378 static int add_dec(PixelModel3 *m, int sym, int f1, int f2)
382 if (m->size >= 40 || m->size >= m->length)
386 m->symbols[size] = sym;
387 m->freqs[2 * size] = f1;
388 m->freqs[2 * size + 1] = f2;
389 m->cnts[size] = f1 - (f1 >> 1);
395 static void incr_cntdec(PixelModel3 *m, int a)
403 if (a > 0 && m->cnts[a] > m->cnts[a - 1]) {
404 FFSWAP(uint16_t, m->cnts[a], m->cnts[a - 1]);
406 e = m->freqs[2 * a + 1];
407 g = m->freqs[2 * (a - 1) + 1];
408 m->freqs[2 * a] = m->freqs[2 * (a - 1)];
409 m->freqs[2 * a + 1] = g;
412 m->freqs[2 * g + 1] = e;
413 FFSWAP(uint8_t, m->symbols[a], m->symbols[a - 1]);
416 if (m->cnts[len] + b > 4096)
420 static int decode_adaptive6(PixelModel3 *m, uint32_t code, uint32_t *value,
421 uint16_t *a, uint16_t *b)
423 int c, d, e, f, g, q;
425 for (c = 0, d = 0, e = 0, f = 0, g = 0, q = m->size; g < q; g++) {
426 uint32_t p = m->freqs[2 * g + 1];
429 uint32_t k = m->freqs[2 * g];
432 *value = m->symbols[g];
451 f = code - (d + c) >> m->fshift;
453 f = d + c + (f << m->fshift);
455 q = code >> m->fshift;
463 c = add_dec(m, q, g, f);
468 c = add_dec(m, q, g, f);
475 static int cmpbytes(const void *p1, const void *p2)
477 int left = *(const uint8_t *)p1;
478 int right = *(const uint8_t *)p2;
479 return FFDIFFSIGN(left, right);
482 static int update_model1_to_2(PixelModel3 *m, uint32_t val)
488 n.size = m->size + 1;
490 for (i = 0; i < b; i++)
491 n.symbols[i] = m->symbols[i];
494 memcpy(m, &n, sizeof(n));
499 static int update_model1_to_4(PixelModel3 *m, uint32_t val)
507 for (i = 0; i < n.size; i++) {
508 n.symbols[i] = m->symbols[i];
510 AV_QSORT(n.symbols, size, uint8_t, cmpbytes);
511 for (i = 0; i < n.size; i++) {
512 if (val == n.symbols[i]) {
520 memcpy(m, &n, sizeof(n));
525 static int update_model1_to_5(PixelModel3 *m, uint32_t val)
533 for (i = 0; i < size; i++) {
534 n.symbols[i] = m->symbols[i];
536 AV_QSORT(n.symbols, size, uint8_t, cmpbytes);
538 for (i = 0; i < size; i++) {
539 if (val == n.symbols[i]) {
547 for (i = 0; i < size; i++, a += freqs)
552 memcpy(m, &n, sizeof(n));
557 static int decode_static1(PixelModel3 *m, uint32_t val)
562 for (int i = 0; i < size; i++) {
563 if (val == m->symbols[i]) {
565 return update_model1_to_4(m, val);
567 return update_model1_to_5(m, val);
572 return update_model1_to_2(m, val);
574 m->symbols[size] = val;
579 static int update_model2_to_6(PixelModel3 *m, uint8_t value, int a4)
582 int c, d, e, f, g, q;
587 memset(n.symbols, 1u, a4);
590 d = 256 - c + (64 * c + 64);
591 for (e = 0; d <= 2048; e++) {
596 AV_QSORT(m->symbols, c, uint8_t, cmpbytes);
597 for (f = d = 0; f < c; f++) {
599 int k = m->symbols[p];
611 n.freqs[2 * p + 1] = g << e;
613 n.cnts[p] = l - (l >> 1);
624 g = n.freqs[2 * d + 1];
625 n.freqs[0] = n.freqs[2 * d];
628 n.freqs[2 * d + 1] = e;
629 FFSWAP(uint16_t, n.cnts[0], n.cnts[d]);
630 FFSWAP(uint8_t, n.symbols[0], n.symbols[d]);
633 memcpy(m, &n, sizeof(n));
638 static int update_model2_to_3(PixelModel3 *m, uint32_t val)
644 n.size = m->size + 1;
647 for (int i = 0; i < size; i++)
648 n.symbols[i] = m->symbols[i];
649 n.symbols[size] = val;
651 memcpy(m, &n, sizeof(n));
656 static int decode_static2(PixelModel3 *m, uint32_t val)
661 for (int i = 0; i < size; i++) {
662 if (val == m->symbols[i]) {
669 return update_model2_to_6(m, val, a);
674 return update_model2_to_3(m, val);
676 m->symbols[size] = val;
682 static int update_model3_to_7(PixelModel3 *m, uint8_t value)
685 int c, d, e, f, g, q;
689 for (c = 0; c < 256; c++) {
695 for (c = m->size, d = (4096 - (256 - c)) / (c + 1) | 0, e = d - (d >> 1), g = 0; g < c;) {
703 for (d = c = n.cntsum = 0; 256 > d; d++) {
705 n.cntsum += n.cnts[e];
708 f = (c + g - 1 >> 7) + 1;
709 if (f > FF_ARRAY_ELEMS(n.dectab))
710 return AVERROR_INVALIDDATA;
711 for (q = c + 128 - 1 >> 7; q < f; q++) {
717 memcpy(m, &n, sizeof(n));
722 static int decode_static3(PixelModel3 *m, uint32_t val)
724 uint32_t size = m->size;
726 for (int i = 0; i < size; i++) {
727 if (val == m->symbols[i])
728 return update_model3_to_7(m, val);
734 m->symbols[size] = val;
739 static void sync_code3(GetByteContext *gb, RangeCoder *rc)
742 if (rc->code1 == 0x20000) {
743 rc->code = bytestream2_get_le32(gb);
748 static int decode_value3(SCPRContext *s, uint32_t max, uint32_t *cntsum,
749 uint16_t *freqs1, uint16_t *freqs2,
750 uint16_t *cnts, uint8_t *dectable,
753 GetByteContext *gb = &s->gb;
754 RangeCoder *rc = &s->rc;
755 uint32_t r, y, a, b, e, g, q;
757 r = dectable[(rc->code & 0xFFFu) >> 7];
759 while (freqs2[r + 1] <= (rc->code & 0xFFF)) {
766 return AVERROR_INVALIDDATA;
772 if (*cntsum + 16 > 4096) {
774 for (int c = 0, i = 0; i < max + 1; i++) {
780 q = ((c - 1) >> 7) + 1;
782 for (int j = 0; j < q - g; j++)
791 decode3(gb, rc, a, b);
799 static void calc_sum5(PixelModel3 *m)
804 for (int b = 0; b < m->size; b++)
809 static int update_model4_to_5(PixelModel3 *m, uint32_t value)
816 for (c = 0, e = 0; c < m->size && m->symbols[c] < value; c++) {
817 n.symbols[c] = m->symbols[c];
818 e += n.freqs[c] = m->freqs[c];
822 n.symbols[g] = value;
823 e += n.freqs[g++] = 50;
824 for (; c < m->size; g++, c++) {
825 n.symbols[g] = m->symbols[c];
826 e += n.freqs[g] = m->freqs[c];
828 n.size = m->size + 1;
834 memcpy(m, &n, sizeof(n));
839 static int decode_unit3(SCPRContext *s, PixelModel3 *m, uint32_t code, uint32_t *value)
841 GetByteContext *gb = &s->gb;
842 RangeCoder *rc = &s->rc;
843 uint16_t a = 0, b = 0;
851 *value = bytestream2_get_byte(&s->gb);
854 m->symbols[0] = *value;
858 *value = bytestream2_get_byte(&s->gb);
859 decode_static1(m, *value);
863 *value = bytestream2_get_byte(&s->gb);
864 decode_static2(m, *value);
868 *value = bytestream2_get_byte(&s->gb);
869 ret = decode_static3(m, *value);
871 return AVERROR_INVALIDDATA;
875 param = m->freqs[0] + m->freqs[1] + m->freqs[2] + m->freqs[3] + 256 - m->size;
876 if (!decode_adaptive45(m, code, value, &a, &b, ¶m, 4))
877 update_model4_to_5(m, *value);
878 decode3(gb, rc, a, b);
882 if (!decode_adaptive45(m, code, value, &a, &b, &m->cntsum, 16))
883 update_model5_to_6(m, *value);
884 decode3(gb, rc, a, b);
888 if (!decode_adaptive6(m, code, value, &a, &b)) {
889 ret = update_model6_to_7(m);
891 return AVERROR_INVALIDDATA;
893 decode3(gb, rc, a, b);
897 return decode_value3(s, 255, &m->cntsum,
899 m->cnts, m->dectab, value);
903 return AVERROR_INVALIDDATA;
908 static int decode_units3(SCPRContext * s, uint32_t *red,
909 uint32_t *green, uint32_t *blue,
912 RangeCoder *rc = &s->rc;
915 ret = decode_unit3(s, &s->pixel_model3[0][*cx + *cx1], rc->code & 0xFFF, red);
919 *cx1 = (*cx << 6) & 0xFC0;
922 ret = decode_unit3(s, &s->pixel_model3[1][*cx + *cx1], rc->code & 0xFFF, green);
926 *cx1 = (*cx << 6) & 0xFC0;
929 ret = decode_unit3(s, &s->pixel_model3[2][*cx + *cx1], rc->code & 0xFFF, blue);
933 *cx1 = (*cx << 6) & 0xFC0;
939 static void init_rangecoder3(RangeCoder *rc, GetByteContext *gb)
941 rc->code = bytestream2_get_le32(gb);
945 static int decompress_i3(AVCodecContext *avctx, uint32_t *dst, int linesize)
947 SCPRContext *s = avctx->priv_data;
948 GetByteContext *gb = &s->gb;
949 RangeCoder *rc = &s->rc;
950 int cx = 0, cx1 = 0, k = 0;
951 int run, off, y = 0, x = 0, ret;
952 uint32_t backstep = linesize - avctx->width;
953 uint32_t clr = 0, lx, ly, ptype, r, g, b;
955 bytestream2_skip(gb, 1);
956 init_rangecoder3(rc, gb);
959 while (k < avctx->width + 1) {
960 ret = decode_units3(s, &r, &g, &b, &cx, &cx1);
963 ret = decode_value3(s, 255, &s->run_model3[0].cntsum,
964 s->run_model3[0].freqs[0],
965 s->run_model3[0].freqs[1],
966 s->run_model3[0].cnts,
967 s->run_model3[0].dectab, &run);
971 return AVERROR_INVALIDDATA;
973 clr = (b << 16) + (g << 8) + r;
976 if (y >= avctx->height)
977 return AVERROR_INVALIDDATA;
979 dst[y * linesize + x] = clr;
983 if (x >= avctx->width) {
992 while (x < avctx->width && y < avctx->height) {
993 ret = decode_value3(s, 5, &s->op_model3[ptype].cntsum,
994 s->op_model3[ptype].freqs[0],
995 s->op_model3[ptype].freqs[1],
996 s->op_model3[ptype].cnts,
997 s->op_model3[ptype].dectab, &ptype);
1001 ret = decode_units3(s, &r, &g, &b, &cx, &cx1);
1004 clr = (b << 16) + (g << 8) + r;
1007 return AVERROR_INVALIDDATA;
1008 ret = decode_value3(s, 255, &s->run_model3[ptype].cntsum,
1009 s->run_model3[ptype].freqs[0],
1010 s->run_model3[ptype].freqs[1],
1011 s->run_model3[ptype].cnts,
1012 s->run_model3[ptype].dectab, &run);
1016 return AVERROR_INVALIDDATA;
1018 ret = decode_run_i(avctx, ptype, run, &x, &y, clr,
1019 dst, linesize, &lx, &ly,
1020 backstep, off, &cx, &cx1);
1028 static int decompress_p3(AVCodecContext *avctx,
1029 uint32_t *dst, int linesize,
1030 uint32_t *prev, int plinesize)
1032 SCPRContext *s = avctx->priv_data;
1033 GetByteContext *gb = &s->gb;
1034 int ret, temp, min, max, x, y, cx = 0, cx1 = 0;
1035 int backstep = linesize - avctx->width;
1036 int mvx = 0, mvy = 0;
1038 if (bytestream2_get_byte(gb) == 0)
1040 init_rangecoder3(&s->rc, gb);
1042 ret = decode_value3(s, 255, &s->range_model3.cntsum,
1043 s->range_model3.freqs[0],
1044 s->range_model3.freqs[1],
1045 s->range_model3.cnts,
1046 s->range_model3.dectab, &min);
1047 ret |= decode_value3(s, 255, &s->range_model3.cntsum,
1048 s->range_model3.freqs[0],
1049 s->range_model3.freqs[1],
1050 s->range_model3.cnts,
1051 s->range_model3.dectab, &temp);
1056 ret |= decode_value3(s, 255, &s->range_model3.cntsum,
1057 s->range_model3.freqs[0],
1058 s->range_model3.freqs[1],
1059 s->range_model3.cnts,
1060 s->range_model3.dectab, &max);
1061 ret |= decode_value3(s, 255, &s->range_model3.cntsum,
1062 s->range_model3.freqs[0],
1063 s->range_model3.freqs[1],
1064 s->range_model3.cnts,
1065 s->range_model3.dectab, &temp);
1070 if (min > max || min >= s->nbcount)
1071 return AVERROR_INVALIDDATA;
1073 memset(s->blocks, 0, sizeof(*s->blocks) * s->nbcount);
1075 while (min <= max) {
1078 ret = decode_value3(s, 4, &s->fill_model3.cntsum,
1079 s->fill_model3.freqs[0],
1080 s->fill_model3.freqs[1],
1081 s->fill_model3.cnts,
1082 s->fill_model3.dectab, &fill);
1083 ret |= decode_value3(s, 255, &s->count_model3.cntsum,
1084 s->count_model3.freqs[0],
1085 s->count_model3.freqs[1],
1086 s->count_model3.cnts,
1087 s->count_model3.dectab, &count);
1091 return AVERROR_INVALIDDATA;
1093 while (min < s->nbcount && count-- > 0) {
1094 s->blocks[min++] = fill;
1098 ret = av_frame_copy(s->current_frame, s->last_frame);
1102 for (y = 0; y < s->nby; y++) {
1103 for (x = 0; x < s->nbx; x++) {
1104 int sy1 = 0, sy2 = 16, sx1 = 0, sx2 = 16;
1106 if (s->blocks[y * s->nbx + x] == 0)
1109 if (((s->blocks[y * s->nbx + x] + 1) & 1) > 0) {
1110 ret = decode_value3(s, 15, &s->sxy_model3[0].cntsum,
1111 s->sxy_model3[0].freqs[0],
1112 s->sxy_model3[0].freqs[1],
1113 s->sxy_model3[0].cnts,
1114 s->sxy_model3[0].dectab, &sx1);
1115 ret |= decode_value3(s, 15, &s->sxy_model3[1].cntsum,
1116 s->sxy_model3[1].freqs[0],
1117 s->sxy_model3[1].freqs[1],
1118 s->sxy_model3[1].cnts,
1119 s->sxy_model3[1].dectab, &sy1);
1120 ret |= decode_value3(s, 15, &s->sxy_model3[2].cntsum,
1121 s->sxy_model3[2].freqs[0],
1122 s->sxy_model3[2].freqs[1],
1123 s->sxy_model3[2].cnts,
1124 s->sxy_model3[2].dectab, &sx2);
1125 ret |= decode_value3(s, 15, &s->sxy_model3[3].cntsum,
1126 s->sxy_model3[3].freqs[0],
1127 s->sxy_model3[3].freqs[1],
1128 s->sxy_model3[3].cnts,
1129 s->sxy_model3[3].dectab, &sy2);
1136 if (((s->blocks[y * s->nbx + x] + 3) & 2) > 0) {
1137 int i, a, b, c, j, by = y * 16, bx = x * 16;
1140 a = s->rc.code & 0xFFF;
1149 code = a + ((s->rc.code >> 1) & 0xFFFFF800) - b;
1150 while (code < 0x800000 && bytestream2_get_bytes_left(gb) > 0)
1151 code = bytestream2_get_byteu(gb) | (code << 8);
1154 sync_code3(gb, &s->rc);
1157 ret = decode_value3(s, 511, &s->mv_model3[0].cntsum,
1158 s->mv_model3[0].freqs[0],
1159 s->mv_model3[0].freqs[1],
1160 s->mv_model3[0].cnts,
1161 s->mv_model3[0].dectab, &mvx);
1162 ret |= decode_value3(s, 511, &s->mv_model3[1].cntsum,
1163 s->mv_model3[1].freqs[0],
1164 s->mv_model3[1].freqs[1],
1165 s->mv_model3[1].cnts,
1166 s->mv_model3[1].dectab, &mvy);
1174 if (by + mvy + sy1 < 0 || bx + mvx + sx1 < 0 ||
1175 by + mvy + sy1 >= avctx->height || bx + mvx + sx1 >= avctx->width)
1176 return AVERROR_INVALIDDATA;
1178 for (i = 0; i < sy2 - sy1 && (by + sy1 + i) < avctx->height && (by + mvy + sy1 + i) < avctx->height; i++) {
1179 for (j = 0; j < sx2 - sx1 && (bx + sx1 + j) < avctx->width && (bx + mvx + sx1 + j) < avctx->width; j++) {
1180 dst[(by + i + sy1) * linesize + bx + sx1 + j] = prev[(by + mvy + sy1 + i) * plinesize + bx + sx1 + mvx + j];
1184 int run, bx = x * 16 + sx1, by = y * 16 + sy1;
1185 uint32_t clr, ptype = 0, r, g, b;
1187 for (; by < y * 16 + sy2 && by < avctx->height;) {
1188 ret = decode_value3(s, 5, &s->op_model3[ptype].cntsum,
1189 s->op_model3[ptype].freqs[0],
1190 s->op_model3[ptype].freqs[1],
1191 s->op_model3[ptype].cnts,
1192 s->op_model3[ptype].dectab, &ptype);
1196 ret = decode_units3(s, &r, &g, &b, &cx, &cx1);
1200 clr = (b << 16) + (g << 8) + r;
1203 return AVERROR_INVALIDDATA;
1204 ret = decode_value3(s, 255, &s->run_model3[ptype].cntsum,
1205 s->run_model3[ptype].freqs[0],
1206 s->run_model3[ptype].freqs[1],
1207 s->run_model3[ptype].cnts,
1208 s->run_model3[ptype].dectab, &run);
1212 return AVERROR_INVALIDDATA;
1214 ret = decode_run_p(avctx, ptype, run, x, y, clr,
1215 dst, prev, linesize, plinesize, &bx, &by,
1216 backstep, sx1, sx2, &cx, &cx1);