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 for (i = 0; i < k - p; i++)
242 memcpy(m, &n, sizeof(n));
247 static void calc_sum(PixelModel3 *m)
253 a = 256 - m->size << (m->fshift > 0 ? m->fshift - 1 : 0);
254 for (int c = 0; c < len; c++)
259 static void rescale_dec(PixelModel3 *m)
261 uint16_t cnts[256] = {0};
262 uint16_t freqs[512] = {0};
266 for (a = 1 << (0 < m->fshift ? m->fshift - 1 : 0), b = 0; b < 256; b++)
269 for (a = 0, b = m->size; a < b; a++)
270 cnts[m->symbols[a]] = m->cnts[a];
272 for (b = a = 0; b < 256; b++) {
273 freqs[2 * b] = cnts[b];
274 freqs[2 * b + 1] = a;
281 a = 256 - m->size << (0 < m->fshift ? m->fshift - 1 : 0);
282 for (b = 0, c = m->size; b < c; b++) {
283 m->cnts[b] -= m->cnts[b] >> 1;
286 g = freqs[2 * e + 1];
287 m->freqs[2 * b] = freqs[2 * e];
288 m->freqs[2 * b + 1] = g;
290 m->cnts[m->length] = a;
293 static int update_model5_to_6(PixelModel3 *m, uint8_t value)
296 int c, d, e, f, g, k, q, p;
301 for (c = m->size, d = 256 - c, e = 0; e < c; e++)
304 for (e = 0; d <= 2048; e++)
307 for (q = d = 0, g = q = 0; g < c; g++) {
313 n.freqs[2 * g + 1] = d << e;
314 n.cnts[g] = k - (k >> 1);
325 for (p = f = g = 0; p < c; p++) {
327 if (k > d && k < value) {
330 f = n.freqs[2 * p + 1];
333 d = 0 < g ? f + g + (value - d - 1 << n.fshift) : value << n.fshift;
336 n.freqs[2 * c + 1] = d;
337 n.cnts[c] = e - (e >> 1);
338 n.symbols[c] = value;
343 if (n.cnts[32] + e > 4096)
347 for (c = 0, e = n.size - 1; c < e; c++) {
348 for (g = c + 1, f = n.size; g < f; g++) {
349 if (q = n.freqs[2 * g], k = n.freqs[2 * c], q > k) {
350 int l = n.freqs[2 * c + 1];
351 int h = n.freqs[2 * g + 1];
353 n.freqs[2 * c + 1] = h;
355 n.freqs[2 * g + 1] = l;
356 FFSWAP(uint16_t, n.cnts[c], n.cnts[g]);
357 FFSWAP(uint8_t, n.symbols[c], n.symbols[g]);
362 memcpy(m, &n, sizeof(n));
367 static void grow_dec(PixelModel3 *m)
372 m->cnts[2 * m->length] = m->cnts[m->length];
376 static int add_dec(PixelModel3 *m, int sym, int f1, int f2)
380 if (m->size >= 40 || m->size >= m->length)
384 m->symbols[size] = sym;
385 m->freqs[2 * size] = f1;
386 m->freqs[2 * size + 1] = f2;
387 m->cnts[size] = f1 - (f1 >> 1);
393 static void incr_cntdec(PixelModel3 *m, int a)
401 if (a > 0 && m->cnts[a] > m->cnts[a - 1]) {
402 FFSWAP(uint16_t, m->cnts[a], m->cnts[a - 1]);
404 e = m->freqs[2 * a + 1];
405 g = m->freqs[2 * (a - 1) + 1];
406 m->freqs[2 * a] = m->freqs[2 * (a - 1)];
407 m->freqs[2 * a + 1] = g;
410 m->freqs[2 * g + 1] = e;
411 FFSWAP(uint8_t, m->symbols[a], m->symbols[a - 1]);
414 if (m->cnts[len] + b > 4096)
418 static int decode_adaptive6(PixelModel3 *m, uint32_t code, uint32_t *value,
419 uint16_t *a, uint16_t *b)
421 int c, d, e, f, g, q;
423 for (c = 0, d = 0, e = 0, f = 0, g = 0, q = m->size; g < q; g++) {
424 uint32_t p = m->freqs[2 * g + 1];
427 uint32_t k = m->freqs[2 * g];
430 *value = m->symbols[g];
449 f = code - (d + c) >> m->fshift;
451 f = d + c + (f << m->fshift);
453 q = code >> m->fshift;
461 c = add_dec(m, q, g, f);
466 c = add_dec(m, q, g, f);
473 static int cmpbytes(const void *p1, const void *p2)
475 int left = *(const uint8_t *)p1;
476 int right = *(const uint8_t *)p2;
477 return FFDIFFSIGN(left, right);
480 static int update_model1_to_2(PixelModel3 *m, uint32_t val)
486 n.size = m->size + 1;
488 for (i = 0; i < b; i++)
489 n.symbols[i] = m->symbols[i];
492 memcpy(m, &n, sizeof(n));
497 static int update_model1_to_4(PixelModel3 *m, uint32_t val)
505 for (i = 0; i < n.size; i++) {
506 n.symbols[i] = m->symbols[i];
508 AV_QSORT(n.symbols, size, uint8_t, cmpbytes);
509 for (i = 0; i < n.size; i++) {
510 if (val == n.symbols[i]) {
518 memcpy(m, &n, sizeof(n));
523 static int update_model1_to_5(PixelModel3 *m, uint32_t val)
531 for (i = 0; i < size; i++) {
532 n.symbols[i] = m->symbols[i];
534 AV_QSORT(n.symbols, size, uint8_t, cmpbytes);
536 for (i = 0; i < size; i++) {
537 if (val == n.symbols[i]) {
545 for (i = 0; i < size; i++, a += freqs)
550 memcpy(m, &n, sizeof(n));
555 static int decode_static1(PixelModel3 *m, uint32_t val)
560 for (int i = 0; i < size; i++) {
561 if (val == m->symbols[i]) {
563 return update_model1_to_4(m, val);
565 return update_model1_to_5(m, val);
570 return update_model1_to_2(m, val);
572 m->symbols[size] = val;
577 static int update_model2_to_6(PixelModel3 *m, uint8_t value, int a4)
580 int c, d, e, f, g, q;
585 memset(n.symbols, 1u, a4);
588 d = 256 - c + (64 * c + 64);
589 for (e = 0; d <= 2048; e++) {
594 AV_QSORT(m->symbols, c, uint8_t, cmpbytes);
595 for (f = d = 0; f < c; f++) {
597 int k = m->symbols[p];
609 n.freqs[2 * p + 1] = g << e;
611 n.cnts[p] = l - (l >> 1);
622 g = n.freqs[2 * d + 1];
623 n.freqs[0] = n.freqs[2 * d];
626 n.freqs[2 * d + 1] = e;
627 FFSWAP(uint16_t, n.cnts[0], n.cnts[d]);
628 FFSWAP(uint8_t, n.symbols[0], n.symbols[d]);
631 memcpy(m, &n, sizeof(n));
636 static int update_model2_to_3(PixelModel3 *m, uint32_t val)
642 n.size = m->size + 1;
645 for (int i = 0; i < size; i++)
646 n.symbols[i] = m->symbols[i];
647 n.symbols[size] = val;
649 memcpy(m, &n, sizeof(n));
654 static int decode_static2(PixelModel3 *m, uint32_t val)
659 for (int i = 0; i < size; i++) {
660 if (val == m->symbols[i]) {
667 return update_model2_to_6(m, val, a);
672 return update_model2_to_3(m, val);
674 m->symbols[size] = val;
680 static int update_model3_to_7(PixelModel3 *m, uint8_t value)
683 int c, d, e, f, g, q;
687 for (c = 0; c < 256; c++) {
693 for (c = m->size, d = (4096 - (256 - c)) / (c + 1) | 0, e = d - (d >> 1), g = 0; g < c;) {
701 for (d = c = n.cntsum = 0; 256 > d; d++) {
703 n.cntsum += n.cnts[e];
705 for (g = n.freqs[e], q = c + 128 - 1 >> 7, f = (c + g - 1 >> 7) + 1; q < f; q++) {
711 memcpy(m, &n, sizeof(n));
716 static int decode_static3(PixelModel3 *m, uint32_t val)
718 uint32_t size = m->size;
720 for (int i = 0; i < size; i++) {
721 if (val == m->symbols[i])
722 return update_model3_to_7(m, val);
728 m->symbols[size] = val;
733 static void sync_code3(GetByteContext *gb, RangeCoder *rc)
736 if (rc->code1 == 0x20000) {
737 rc->code = bytestream2_get_le32(gb);
742 static int decode_value3(SCPRContext *s, uint32_t max, uint32_t *cntsum,
743 uint16_t *freqs1, uint16_t *freqs2,
744 uint16_t *cnts, uint8_t *dectable,
747 GetByteContext *gb = &s->gb;
748 RangeCoder *rc = &s->rc;
749 uint32_t r, y, a, b, e, g, q;
751 r = dectable[(rc->code & 0xFFFu) >> 7];
753 while (freqs2[r + 1] <= (rc->code & 0xFFF)) {
760 return AVERROR_INVALIDDATA;
766 if (*cntsum + 16 > 4096) {
768 for (int c = 0, i = 0; i < max + 1; i++) {
774 q = ((c - 1) >> 7) + 1;
776 for (int j = 0; j < q - g; j++)
785 decode3(gb, rc, a, b);
793 static void calc_sum5(PixelModel3 *m)
798 for (int b = 0; b < m->size; b++)
803 static int update_model4_to_5(PixelModel3 *m, uint32_t value)
810 for (c = 0, e = 0; c < m->size && m->symbols[c] < value; c++) {
811 n.symbols[c] = m->symbols[c];
812 e += n.freqs[c] = m->freqs[c];
816 n.symbols[g] = value;
817 e += n.freqs[g++] = 50;
818 for (; c < m->size; g++, c++) {
819 n.symbols[g] = m->symbols[c];
820 e += n.freqs[g] = m->freqs[c];
822 n.size = m->size + 1;
828 memcpy(m, &n, sizeof(n));
833 static int decode_unit3(SCPRContext *s, PixelModel3 *m, uint32_t code, uint32_t *value)
835 GetByteContext *gb = &s->gb;
836 RangeCoder *rc = &s->rc;
837 uint16_t a = 0, b = 0;
844 *value = bytestream2_get_byte(&s->gb);
847 m->symbols[0] = *value;
851 *value = bytestream2_get_byte(&s->gb);
852 decode_static1(m, *value);
856 *value = bytestream2_get_byte(&s->gb);
857 decode_static2(m, *value);
861 *value = bytestream2_get_byte(&s->gb);
862 decode_static3(m, *value);
866 param = m->freqs[0] + m->freqs[1] + m->freqs[2] + m->freqs[3] + 256 - m->size;
867 if (!decode_adaptive45(m, code, value, &a, &b, ¶m, 4))
868 update_model4_to_5(m, *value);
869 decode3(gb, rc, a, b);
873 if (!decode_adaptive45(m, code, value, &a, &b, &m->cntsum, 16))
874 update_model5_to_6(m, *value);
875 decode3(gb, rc, a, b);
879 if (!decode_adaptive6(m, code, value, &a, &b)) {
880 update_model6_to_7(m);
882 decode3(gb, rc, a, b);
886 return decode_value3(s, 255, &m->cntsum,
888 m->cnts, m->dectab, value);
892 return AVERROR_INVALIDDATA;
897 static int decode_units3(SCPRContext * s, uint32_t *red,
898 uint32_t *green, uint32_t *blue,
901 RangeCoder *rc = &s->rc;
904 ret = decode_unit3(s, &s->pixel_model3[0][*cx + *cx1], rc->code & 0xFFF, red);
908 *cx1 = (*cx << 6) & 0xFC0;
911 ret = decode_unit3(s, &s->pixel_model3[1][*cx + *cx1], rc->code & 0xFFF, green);
915 *cx1 = (*cx << 6) & 0xFC0;
918 ret = decode_unit3(s, &s->pixel_model3[2][*cx + *cx1], rc->code & 0xFFF, blue);
922 *cx1 = (*cx << 6) & 0xFC0;
928 static void init_rangecoder3(RangeCoder *rc, GetByteContext *gb)
930 rc->code = bytestream2_get_le32(gb);
934 static int decompress_i3(AVCodecContext *avctx, uint32_t *dst, int linesize)
936 SCPRContext *s = avctx->priv_data;
937 GetByteContext *gb = &s->gb;
938 RangeCoder *rc = &s->rc;
939 int cx = 0, cx1 = 0, k = 0;
940 int run, off, y = 0, x = 0, ret;
941 uint32_t backstep = linesize - avctx->width;
942 uint32_t clr = 0, lx, ly, ptype, r, g, b;
944 bytestream2_skip(gb, 1);
945 init_rangecoder3(rc, gb);
948 while (k < avctx->width + 1) {
949 ret = decode_units3(s, &r, &g, &b, &cx, &cx1);
952 ret = decode_value3(s, 255, &s->run_model3[0].cntsum,
953 s->run_model3[0].freqs[0],
954 s->run_model3[0].freqs[1],
955 s->run_model3[0].cnts,
956 s->run_model3[0].dectab, &run);
960 return AVERROR_INVALIDDATA;
962 clr = (b << 16) + (g << 8) + r;
965 if (y >= avctx->height)
966 return AVERROR_INVALIDDATA;
968 dst[y * linesize + x] = clr;
972 if (x >= avctx->width) {
981 while (x < avctx->width && y < avctx->height) {
982 ret = decode_value3(s, 5, &s->op_model3[ptype].cntsum,
983 s->op_model3[ptype].freqs[0],
984 s->op_model3[ptype].freqs[1],
985 s->op_model3[ptype].cnts,
986 s->op_model3[ptype].dectab, &ptype);
990 ret = decode_units3(s, &r, &g, &b, &cx, &cx1);
993 clr = (b << 16) + (g << 8) + r;
996 return AVERROR_INVALIDDATA;
997 ret = decode_value3(s, 255, &s->run_model3[ptype].cntsum,
998 s->run_model3[ptype].freqs[0],
999 s->run_model3[ptype].freqs[1],
1000 s->run_model3[ptype].cnts,
1001 s->run_model3[ptype].dectab, &run);
1005 return AVERROR_INVALIDDATA;
1007 ret = decode_run_i(avctx, ptype, run, &x, &y, clr,
1008 dst, linesize, &lx, &ly,
1009 backstep, off, &cx, &cx1);
1017 static int decompress_p3(AVCodecContext *avctx,
1018 uint32_t *dst, int linesize,
1019 uint32_t *prev, int plinesize)
1021 SCPRContext *s = avctx->priv_data;
1022 GetByteContext *gb = &s->gb;
1023 int ret, temp, min, max, x, y, cx = 0, cx1 = 0;
1024 int backstep = linesize - avctx->width;
1025 int mvx = 0, mvy = 0;
1027 if (bytestream2_get_byte(gb) == 0)
1029 init_rangecoder3(&s->rc, gb);
1031 ret = decode_value3(s, 255, &s->range_model3.cntsum,
1032 s->range_model3.freqs[0],
1033 s->range_model3.freqs[1],
1034 s->range_model3.cnts,
1035 s->range_model3.dectab, &min);
1036 ret |= decode_value3(s, 255, &s->range_model3.cntsum,
1037 s->range_model3.freqs[0],
1038 s->range_model3.freqs[1],
1039 s->range_model3.cnts,
1040 s->range_model3.dectab, &temp);
1045 ret |= decode_value3(s, 255, &s->range_model3.cntsum,
1046 s->range_model3.freqs[0],
1047 s->range_model3.freqs[1],
1048 s->range_model3.cnts,
1049 s->range_model3.dectab, &max);
1050 ret |= decode_value3(s, 255, &s->range_model3.cntsum,
1051 s->range_model3.freqs[0],
1052 s->range_model3.freqs[1],
1053 s->range_model3.cnts,
1054 s->range_model3.dectab, &temp);
1059 if (min > max || min >= s->nbcount)
1060 return AVERROR_INVALIDDATA;
1062 memset(s->blocks, 0, sizeof(*s->blocks) * s->nbcount);
1064 while (min <= max) {
1067 ret = decode_value3(s, 4, &s->fill_model3.cntsum,
1068 s->fill_model3.freqs[0],
1069 s->fill_model3.freqs[1],
1070 s->fill_model3.cnts,
1071 s->fill_model3.dectab, &fill);
1072 ret |= decode_value3(s, 255, &s->count_model3.cntsum,
1073 s->count_model3.freqs[0],
1074 s->count_model3.freqs[1],
1075 s->count_model3.cnts,
1076 s->count_model3.dectab, &count);
1080 return AVERROR_INVALIDDATA;
1082 while (min < s->nbcount && count-- > 0) {
1083 s->blocks[min++] = fill;
1087 ret = av_frame_copy(s->current_frame, s->last_frame);
1091 for (y = 0; y < s->nby; y++) {
1092 for (x = 0; x < s->nbx; x++) {
1093 int sy1 = 0, sy2 = 16, sx1 = 0, sx2 = 16;
1095 if (s->blocks[y * s->nbx + x] == 0)
1098 if (((s->blocks[y * s->nbx + x] + 1) & 1) > 0) {
1099 ret = decode_value3(s, 15, &s->sxy_model3[0].cntsum,
1100 s->sxy_model3[0].freqs[0],
1101 s->sxy_model3[0].freqs[1],
1102 s->sxy_model3[0].cnts,
1103 s->sxy_model3[0].dectab, &sx1);
1104 ret |= decode_value3(s, 15, &s->sxy_model3[1].cntsum,
1105 s->sxy_model3[1].freqs[0],
1106 s->sxy_model3[1].freqs[1],
1107 s->sxy_model3[1].cnts,
1108 s->sxy_model3[1].dectab, &sy1);
1109 ret |= decode_value3(s, 15, &s->sxy_model3[2].cntsum,
1110 s->sxy_model3[2].freqs[0],
1111 s->sxy_model3[2].freqs[1],
1112 s->sxy_model3[2].cnts,
1113 s->sxy_model3[2].dectab, &sx2);
1114 ret |= decode_value3(s, 15, &s->sxy_model3[3].cntsum,
1115 s->sxy_model3[3].freqs[0],
1116 s->sxy_model3[3].freqs[1],
1117 s->sxy_model3[3].cnts,
1118 s->sxy_model3[3].dectab, &sy2);
1125 if (((s->blocks[y * s->nbx + x] + 3) & 2) > 0) {
1126 int i, a, b, c, j, by = y * 16, bx = x * 16;
1129 a = s->rc.code & 0xFFF;
1138 code = a + ((s->rc.code >> 1) & 0xFFFFF800) - b;
1139 while (code < 0x800000 && bytestream2_get_bytes_left(gb) > 0)
1140 code = bytestream2_get_byteu(gb) | (code << 8);
1143 sync_code3(gb, &s->rc);
1146 ret = decode_value3(s, 511, &s->mv_model3[0].cntsum,
1147 s->mv_model3[0].freqs[0],
1148 s->mv_model3[0].freqs[1],
1149 s->mv_model3[0].cnts,
1150 s->mv_model3[0].dectab, &mvx);
1151 ret |= decode_value3(s, 511, &s->mv_model3[1].cntsum,
1152 s->mv_model3[1].freqs[0],
1153 s->mv_model3[1].freqs[1],
1154 s->mv_model3[1].cnts,
1155 s->mv_model3[1].dectab, &mvy);
1163 if (by + mvy + sy1 < 0 || bx + mvx + sx1 < 0 ||
1164 by + mvy + sy1 >= avctx->height || bx + mvx + sx1 >= avctx->width)
1165 return AVERROR_INVALIDDATA;
1167 for (i = 0; i < sy2 - sy1 && (by + sy1 + i) < avctx->height && (by + mvy + sy1 + i) < avctx->height; i++) {
1168 for (j = 0; j < sx2 - sx1 && (bx + sx1 + j) < avctx->width && (bx + mvx + sx1 + j) < avctx->width; j++) {
1169 dst[(by + i + sy1) * linesize + bx + sx1 + j] = prev[(by + mvy + sy1 + i) * plinesize + bx + sx1 + mvx + j];
1173 int run, bx = x * 16 + sx1, by = y * 16 + sy1;
1174 uint32_t clr, ptype = 0, r, g, b;
1176 for (; by < y * 16 + sy2 && by < avctx->height;) {
1177 ret = decode_value3(s, 5, &s->op_model3[ptype].cntsum,
1178 s->op_model3[ptype].freqs[0],
1179 s->op_model3[ptype].freqs[1],
1180 s->op_model3[ptype].cnts,
1181 s->op_model3[ptype].dectab, &ptype);
1185 ret = decode_units3(s, &r, &g, &b, &cx, &cx1);
1189 clr = (b << 16) + (g << 8) + r;
1192 return AVERROR_INVALIDDATA;
1193 ret = decode_value3(s, 255, &s->run_model3[ptype].cntsum,
1194 s->run_model3[ptype].freqs[0],
1195 s->run_model3[ptype].freqs[1],
1196 s->run_model3[ptype].cnts,
1197 s->run_model3[ptype].dectab, &run);
1201 return AVERROR_INVALIDDATA;
1203 ret = decode_run_p(avctx, ptype, run, x, y, clr,
1204 dst, prev, linesize, plinesize, &bx, &by,
1205 backstep, sx1, sx2, &cx, &cx1);