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++)
55 for (
int i = 0;
i < 3;
i++) {
56 for (
int j = 0; j < 4096; j++) {
62 for (
int i = 0;
i < 6;
i++) {
64 s->run_model3[
i].freqs[0],
s->run_model3[
i].freqs[1],
65 s->run_model3[
i].cnts,
s->run_model3[
i].dectab);
69 s->range_model3.freqs[0],
s->range_model3.freqs[1],
70 s->range_model3.cnts,
s->range_model3.dectab);
73 s->fill_model3.freqs[0],
s->fill_model3.freqs[1],
74 s->fill_model3.cnts,
s->fill_model3.dectab);
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++) {
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++) {
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++) {
94 s->op_model3[
i].freqs[0],
s->op_model3[
i].freqs[1],
95 s->op_model3[
i].cnts,
s->op_model3[
i].dectab);
104 code = bytestream2_get_byteu(gb) | (
code << 8);
115 for (
int b = 0;
b < m->
size;
b++) {
141 if (*totfr + 50 > 4096)
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++)
158 m->
freqs[maxpos] += 4096 - e >> d;
160 for (q = 0,
g = 0, e = 0; q < m->
size; q++) {
162 uint32_t p = e +
f -
g;
163 uint32_t k = m->
freqs[q];
175 if (p + k > rccode) {
183 if ((q != maxpos) && (m->
freqs[q] > m->
freqs[maxpos]))
185 if (totfr + 50 > 4096)
207 int c, d, e,
f, k, p, length,
i, j,
index;
208 uint16_t *freqs, *freqs1, *cnts;
217 for (
i = 0;
i < length;
i++) {
227 for (j = 0, e = 0; j < 256; j++) {
236 k = ((
f + e - 1) >> 7) + 1;
239 for (
i = 0;
i < k - p;
i++)
244 memcpy(m, &n,
sizeof(n));
256 for (
int c = 0;
c <
len;
c++)
263 uint16_t cnts[256] = {0};
264 uint16_t freqs[512] = {0};
274 for (
b =
a = 0;
b < 256;
b++) {
275 freqs[2 *
b] = cnts[
b];
276 freqs[2 *
b + 1] =
a;
288 g = freqs[2 * e + 1];
289 m->
freqs[2 *
b] = freqs[2 * e];
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) {
339 n.
cnts[
c] = e - (e >> 1);
345 if (n.
cnts[32] + e > 4096)
349 for (
c = 0, e = n.
size - 1;
c < e;
c++) {
352 int l = n.
freqs[2 *
c + 1];
364 memcpy(m, &n,
sizeof(n));
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];
475 static int cmpbytes(
const void *p1,
const void *p2)
477 int left = *(
const uint8_t *)p1;
478 int right = *(
const uint8_t *)p2;
490 for (
i = 0;
i <
b;
i++)
494 memcpy(m, &n,
sizeof(n));
520 memcpy(m, &n,
sizeof(n));
533 for (
i = 0;
i <
size;
i++,
a += freqs)
546 for (
int i = 0;
i <
size;
i++) {
566 int c, d, e,
f,
g, q;
574 d = 256 -
c + (64 *
c + 64);
575 for (e = 0; d <= 2048; e++) {
581 for (
f = d = 0;
f <
c;
f++) {
595 n.
freqs[2 * p + 1] =
g << e;
597 n.
cnts[p] = l - (l >> 1);
612 n.
freqs[2 * d + 1] = e;
617 memcpy(m, &n,
sizeof(n));
635 memcpy(m, &n,
sizeof(n));
645 for (
int i = 0;
i <
size;
i++) {
669 int c, d, e,
f,
g, q;
673 for (
c = 0;
c < 256;
c++) {
679 for (
c = m->
size, d = (4096 - (256 -
c)) / (
c + 1) | 0, e = d - (d >> 1),
g = 0;
g <
c;) {
687 for (d =
c = n.
cntsum = 0; 256 > d; d++) {
692 f = (
c +
g - 1 >> 7) + 1;
695 for (q =
c + 128 - 1 >> 7; q <
f; q++) {
701 memcpy(m, &n,
sizeof(n));
710 for (
int i = 0;
i <
size;
i++) {
726 if (rc->
code1 == 0x20000) {
727 rc->
code = bytestream2_get_le32(gb);
733 uint16_t *freqs1, uint16_t *freqs2,
734 uint16_t *cnts,
uint8_t *dectable,
739 uint32_t
r, y,
a,
b, e,
g, q;
741 r = dectable[(rc->
code & 0xFFFu) >> 7];
743 while (freqs2[
r + 1] <= (rc->
code & 0xFFF)) {
756 if (*cntsum + 16 > 4096) {
758 for (
int c = 0,
i = 0;
i <
max + 1;
i++) {
764 q = ((
c - 1) >> 7) + 1;
766 for (
int j = 0; j < q -
g; j++)
788 for (
int b = 0;
b < m->
size;
b++)
808 for (;
c < m->
size;
g++,
c++) {
818 memcpy(m, &n,
sizeof(n));
827 uint16_t
a = 0,
b = 0;
835 *
value = bytestream2_get_byte(&
s->gb);
842 *
value = bytestream2_get_byte(&
s->gb);
847 *
value = bytestream2_get_byte(&
s->gb);
852 *
value = bytestream2_get_byte(&
s->gb);
893 uint32_t *green, uint32_t *blue,
903 *cx1 = (*cx << 6) & 0xFC0;
910 *cx1 = (*cx << 6) & 0xFC0;
917 *cx1 = (*cx << 6) & 0xFC0;
925 rc->
code = bytestream2_get_le32(gb);
934 int cx = 0, cx1 = 0, k = 0;
935 int run, off, y = 0, x = 0, ret;
936 uint32_t backstep = linesize - avctx->
width;
937 uint32_t clr = 0, lx, ly, ptype,
r,
g,
b;
943 while (k < avctx->
width + 1) {
948 s->run_model3[0].freqs[0],
949 s->run_model3[0].freqs[1],
950 s->run_model3[0].cnts,
951 s->run_model3[0].dectab, &
run);
957 clr = (
b << 16) + (
g << 8) +
r;
963 dst[y * linesize + x] = clr;
967 if (x >= avctx->
width) {
978 s->op_model3[ptype].freqs[0],
979 s->op_model3[ptype].freqs[1],
980 s->op_model3[ptype].cnts,
981 s->op_model3[ptype].dectab, &ptype);
988 clr = (
b << 16) + (
g << 8) +
r;
993 s->run_model3[ptype].freqs[0],
994 s->run_model3[ptype].freqs[1],
995 s->run_model3[ptype].cnts,
996 s->run_model3[ptype].dectab, &
run);
1003 dst, linesize, &lx, &ly,
1004 backstep, off, &cx, &cx1);
1013 uint32_t *dst,
int linesize,
1014 uint32_t *prev,
int plinesize)
1018 int ret,
temp,
min,
max, x, y, cx = 0, cx1 = 0;
1019 int backstep = linesize - avctx->
width;
1020 int mvx = 0, mvy = 0;
1022 if (bytestream2_get_byte(gb) == 0)
1027 s->range_model3.freqs[0],
1028 s->range_model3.freqs[1],
1029 s->range_model3.cnts,
1030 s->range_model3.dectab, &
min);
1032 s->range_model3.freqs[0],
1033 s->range_model3.freqs[1],
1034 s->range_model3.cnts,
1035 s->range_model3.dectab, &
temp);
1041 s->range_model3.freqs[0],
1042 s->range_model3.freqs[1],
1043 s->range_model3.cnts,
1044 s->range_model3.dectab, &
max);
1046 s->range_model3.freqs[0],
1047 s->range_model3.freqs[1],
1048 s->range_model3.cnts,
1049 s->range_model3.dectab, &
temp);
1057 memset(
s->blocks, 0,
sizeof(*
s->blocks) *
s->nbcount);
1063 s->fill_model3.freqs[0],
1064 s->fill_model3.freqs[1],
1065 s->fill_model3.cnts,
1066 s->fill_model3.dectab, &fill);
1068 s->count_model3.freqs[0],
1069 s->count_model3.freqs[1],
1070 s->count_model3.cnts,
1071 s->count_model3.dectab, &count);
1077 while (min < s->nbcount && count-- > 0) {
1078 s->blocks[
min++] = fill;
1086 for (y = 0; y <
s->nby; y++) {
1087 for (x = 0; x <
s->nbx; x++) {
1088 int sy1 = 0, sy2 = 16, sx1 = 0, sx2 = 16;
1090 if (
s->blocks[y *
s->nbx + x] == 0)
1093 if (((
s->blocks[y *
s->nbx + x] + 1) & 1) > 0) {
1095 s->sxy_model3[0].freqs[0],
1096 s->sxy_model3[0].freqs[1],
1097 s->sxy_model3[0].cnts,
1098 s->sxy_model3[0].dectab, &sx1);
1100 s->sxy_model3[1].freqs[0],
1101 s->sxy_model3[1].freqs[1],
1102 s->sxy_model3[1].cnts,
1103 s->sxy_model3[1].dectab, &sy1);
1105 s->sxy_model3[2].freqs[0],
1106 s->sxy_model3[2].freqs[1],
1107 s->sxy_model3[2].cnts,
1108 s->sxy_model3[2].dectab, &sx2);
1110 s->sxy_model3[3].freqs[0],
1111 s->sxy_model3[3].freqs[1],
1112 s->sxy_model3[3].cnts,
1113 s->sxy_model3[3].dectab, &sy2);
1120 if (((
s->blocks[y *
s->nbx + x] + 3) & 2) > 0) {
1121 int i,
a,
b,
c, j, by = y * 16, bx = x * 16;
1124 a =
s->rc.code & 0xFFF;
1133 code =
a + ((
s->rc.code >> 1) & 0xFFFFF800) -
b;
1135 code = bytestream2_get_byteu(gb) | (
code << 8);
1142 s->mv_model3[0].freqs[0],
1143 s->mv_model3[0].freqs[1],
1144 s->mv_model3[0].cnts,
1145 s->mv_model3[0].dectab, &mvx);
1147 s->mv_model3[1].freqs[0],
1148 s->mv_model3[1].freqs[1],
1149 s->mv_model3[1].cnts,
1150 s->mv_model3[1].dectab, &mvy);
1158 if (by + mvy + sy1 < 0 || bx + mvx + sx1 < 0 ||
1159 by + mvy + sy1 >= avctx->
height || bx + mvx + sx1 >= avctx->
width)
1162 for (
i = 0;
i < sy2 - sy1 && (by + sy1 +
i) < avctx->
height && (by + mvy + sy1 +
i) < avctx->
height;
i++) {
1163 for (j = 0; j < sx2 - sx1 && (bx + sx1 + j) < avctx->
width && (bx + mvx + sx1 + j) < avctx->
width; j++) {
1164 dst[(by +
i + sy1) * linesize + bx + sx1 + j] = prev[(by + mvy + sy1 +
i) * plinesize + bx + sx1 + mvx + j];
1168 int run, bx = x * 16 + sx1, by = y * 16 + sy1;
1169 uint32_t clr, ptype = 0,
r,
g,
b;
1171 for (; by < y * 16 + sy2 && by < avctx->
height;) {
1173 s->op_model3[ptype].freqs[0],
1174 s->op_model3[ptype].freqs[1],
1175 s->op_model3[ptype].cnts,
1176 s->op_model3[ptype].dectab, &ptype);
1184 clr = (
b << 16) + (
g << 8) +
r;
1189 s->run_model3[ptype].freqs[0],
1190 s->run_model3[ptype].freqs[1],
1191 s->run_model3[ptype].cnts,
1192 s->run_model3[ptype].dectab, &
run);
1199 dst, prev, linesize, plinesize, &bx, &by,
1200 backstep, sx1, sx2, &cx, &cx1);
static double val(void *priv, double ch)
Libavcodec external API header.
static av_always_inline int bytestream2_get_bytes_left(GetByteContext *g)
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
#define FFSWAP(type, a, b)
#define FFDIFFSIGN(x, y)
Comparator.
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
int av_frame_copy(AVFrame *dst, const AVFrame *src)
Copy the frame data from src to dst.
common internal API header
#define AV_QSORT(p, num, type, cmp)
Quicksort This sort is fast, and fully inplace but not stable and it is possible to construct input t...
static int decode3(GetByteContext *gb, RangeCoder *rc, uint32_t a, uint32_t b)
static void grow_dec(PixelModel3 *m)
static void incr_cntdec(PixelModel3 *m, int a)
static int update_model5_to_6(PixelModel3 *m, uint8_t value)
static int decode_static2(PixelModel3 *m, uint32_t val)
static int decode_value3(SCPRContext *s, uint32_t max, uint32_t *cntsum, uint16_t *freqs1, uint16_t *freqs2, uint16_t *cnts, uint8_t *dectable, uint32_t *value)
static int decode_adaptive45(PixelModel3 *m, int rccode, uint32_t *value, uint16_t *a, uint16_t *b, uint32_t *c, int max)
static int update_model3_to_7(PixelModel3 *m, uint8_t value)
static int cmpbytes(const void *p1, const void *p2)
static int add_dec(PixelModel3 *m, int sym, int f1, int f2)
static int decode_unit3(SCPRContext *s, PixelModel3 *m, uint32_t code, uint32_t *value)
static int update_model4_to_5(PixelModel3 *m, uint32_t value)
static void calc_sum(PixelModel3 *m)
static int decompress_p3(AVCodecContext *avctx, uint32_t *dst, int linesize, uint32_t *prev, int plinesize)
static int add_symbol(PixelModel3 *m, int index, uint32_t symbol, int *totfr, int max)
static void calc_sum5(PixelModel3 *m)
static void rescale(PixelModel3 *m, int *totfr)
static int update_model1_to_2(PixelModel3 *m, uint32_t val)
static int update_model1_to_4(PixelModel3 *m, uint32_t val)
static int decode_adaptive6(PixelModel3 *m, uint32_t code, uint32_t *value, uint16_t *a, uint16_t *b)
static void sync_code3(GetByteContext *gb, RangeCoder *rc)
static int decode_static3(PixelModel3 *m, uint32_t val)
static int decode_static1(PixelModel3 *m, uint32_t val)
static void init_rangecoder3(RangeCoder *rc, GetByteContext *gb)
static int update_model1_to_5(PixelModel3 *m, uint32_t val)
static int update_model2_to_3(PixelModel3 *m, uint32_t val)
static void renew_table3(uint32_t nsym, uint32_t *cntsum, uint16_t *freqs, uint16_t *freqs1, uint16_t *cnts, uint8_t *dectab)
static int decompress_i3(AVCodecContext *avctx, uint32_t *dst, int linesize)
static void reinit_tables3(SCPRContext *s)
static int update_model2_to_6(PixelModel3 *m, uint8_t value, int a4)
static int update_model6_to_7(PixelModel3 *m)
static int decode_units3(SCPRContext *s, uint32_t *red, uint32_t *green, uint32_t *blue, int *cx, int *cx1)
static void rescale_dec(PixelModel3 *m)
static int decode_run_i(AVCodecContext *avctx, uint32_t ptype, int run, int *px, int *py, uint32_t clr, uint32_t *dst, int linesize, uint32_t *plx, uint32_t *ply, uint32_t backstep, int off, int *cx, int *cx1)
static int decode_run_p(AVCodecContext *avctx, uint32_t ptype, int run, int x, int y, uint32_t clr, uint32_t *dst, uint32_t *prev, int linesize, int plinesize, uint32_t *bx, uint32_t *by, uint32_t backstep, int sx1, int sx2, int *cx, int *cx1)
#define FF_ARRAY_ELEMS(a)
main external API structure.
int width
picture width / height.