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];
477 static int cmpbytes(
const void *p1,
const void *p2)
479 int left = *(
const uint8_t *)p1;
480 int right = *(
const uint8_t *)p2;
492 for (
i = 0;
i <
b;
i++)
496 memcpy(m, &n,
sizeof(n));
522 memcpy(m, &n,
sizeof(n));
535 for (
i = 0;
i <
size;
i++,
a += freqs)
548 for (
int i = 0;
i <
size;
i++) {
568 int c, d, e,
f,
g, q;
576 d = 256 -
c + (64 *
c + 64);
577 for (e = 0; d <= 2048; e++) {
583 for (
f = d = 0;
f <
c;
f++) {
597 n.
freqs[2 * p + 1] =
g << e;
599 n.
cnts[p] = l - (l >> 1);
614 n.
freqs[2 * d + 1] = e;
619 memcpy(m, &n,
sizeof(n));
637 memcpy(m, &n,
sizeof(n));
647 for (
int i = 0;
i <
size;
i++) {
671 int c, d, e,
f,
g, q;
675 for (
c = 0;
c < 256;
c++) {
681 for (
c = m->
size, d = (4096 - (256 -
c)) / (
c + 1) | 0, e = d - (d >> 1),
g = 0;
g <
c;) {
689 for (d =
c = n.
cntsum = 0; 256 > d; d++) {
694 f = (
c +
g - 1 >> 7) + 1;
697 for (q =
c + 128 - 1 >> 7; q <
f; q++) {
703 memcpy(m, &n,
sizeof(n));
712 for (
int i = 0;
i <
size;
i++) {
728 if (rc->
code1 == 0x20000) {
729 rc->
code = bytestream2_get_le32(gb);
735 uint16_t *freqs1, uint16_t *freqs2,
736 uint16_t *cnts,
uint8_t *dectable,
741 uint32_t
r, y,
a,
b, e,
g, q;
743 r = dectable[(rc->
code & 0xFFFu) >> 7];
745 while (freqs2[
r + 1] <= (rc->
code & 0xFFF)) {
758 if (*cntsum + 16 > 4096) {
760 for (
int c = 0,
i = 0;
i <
max + 1;
i++) {
766 q = ((
c - 1) >> 7) + 1;
768 for (
int j = 0; j < q -
g; j++)
790 for (
int b = 0;
b < m->
size;
b++)
810 for (;
c < m->
size;
g++,
c++) {
820 memcpy(m, &n,
sizeof(n));
829 uint16_t
a = 0,
b = 0;
837 *
value = bytestream2_get_byte(&
s->gb);
844 *
value = bytestream2_get_byte(&
s->gb);
849 *
value = bytestream2_get_byte(&
s->gb);
854 *
value = bytestream2_get_byte(&
s->gb);
895 uint32_t *green, uint32_t *blue,
905 *cx1 = (*cx << 6) & 0xFC0;
912 *cx1 = (*cx << 6) & 0xFC0;
919 *cx1 = (*cx << 6) & 0xFC0;
927 rc->
code = bytestream2_get_le32(gb);
936 int cx = 0, cx1 = 0, k = 0;
937 int run, off, y = 0, x = 0, ret;
938 uint32_t backstep = linesize - avctx->
width;
939 uint32_t clr = 0, lx, ly, ptype,
r,
g,
b;
945 while (k < avctx->
width + 1) {
950 s->run_model3[0].freqs[0],
951 s->run_model3[0].freqs[1],
952 s->run_model3[0].cnts,
953 s->run_model3[0].dectab, &
run);
959 clr = (
b << 16) + (
g << 8) +
r;
965 dst[y * linesize + x] = clr;
969 if (x >= avctx->
width) {
980 s->op_model3[ptype].freqs[0],
981 s->op_model3[ptype].freqs[1],
982 s->op_model3[ptype].cnts,
983 s->op_model3[ptype].dectab, &ptype);
990 clr = (
b << 16) + (
g << 8) +
r;
995 s->run_model3[ptype].freqs[0],
996 s->run_model3[ptype].freqs[1],
997 s->run_model3[ptype].cnts,
998 s->run_model3[ptype].dectab, &
run);
1005 dst, linesize, &lx, &ly,
1006 backstep, off, &cx, &cx1);
1015 uint32_t *dst,
int linesize,
1016 uint32_t *prev,
int plinesize)
1020 int ret,
temp,
min,
max, x, y, cx = 0, cx1 = 0;
1021 int backstep = linesize - avctx->
width;
1022 int mvx = 0, mvy = 0;
1024 if (bytestream2_get_byte(gb) == 0)
1029 s->range_model3.freqs[0],
1030 s->range_model3.freqs[1],
1031 s->range_model3.cnts,
1032 s->range_model3.dectab, &
min);
1034 s->range_model3.freqs[0],
1035 s->range_model3.freqs[1],
1036 s->range_model3.cnts,
1037 s->range_model3.dectab, &
temp);
1043 s->range_model3.freqs[0],
1044 s->range_model3.freqs[1],
1045 s->range_model3.cnts,
1046 s->range_model3.dectab, &
max);
1048 s->range_model3.freqs[0],
1049 s->range_model3.freqs[1],
1050 s->range_model3.cnts,
1051 s->range_model3.dectab, &
temp);
1059 memset(
s->blocks, 0,
sizeof(*
s->blocks) *
s->nbcount);
1065 s->fill_model3.freqs[0],
1066 s->fill_model3.freqs[1],
1067 s->fill_model3.cnts,
1068 s->fill_model3.dectab, &fill);
1070 s->count_model3.freqs[0],
1071 s->count_model3.freqs[1],
1072 s->count_model3.cnts,
1073 s->count_model3.dectab, &count);
1079 while (min < s->nbcount && count-- > 0) {
1080 s->blocks[
min++] = fill;
1088 for (y = 0; y <
s->nby; y++) {
1089 for (x = 0; x <
s->nbx; x++) {
1090 int sy1 = 0, sy2 = 16, sx1 = 0, sx2 = 16;
1092 if (
s->blocks[y *
s->nbx + x] == 0)
1095 if (((
s->blocks[y *
s->nbx + x] + 1) & 1) > 0) {
1097 s->sxy_model3[0].freqs[0],
1098 s->sxy_model3[0].freqs[1],
1099 s->sxy_model3[0].cnts,
1100 s->sxy_model3[0].dectab, &sx1);
1102 s->sxy_model3[1].freqs[0],
1103 s->sxy_model3[1].freqs[1],
1104 s->sxy_model3[1].cnts,
1105 s->sxy_model3[1].dectab, &sy1);
1107 s->sxy_model3[2].freqs[0],
1108 s->sxy_model3[2].freqs[1],
1109 s->sxy_model3[2].cnts,
1110 s->sxy_model3[2].dectab, &sx2);
1112 s->sxy_model3[3].freqs[0],
1113 s->sxy_model3[3].freqs[1],
1114 s->sxy_model3[3].cnts,
1115 s->sxy_model3[3].dectab, &sy2);
1122 if (((
s->blocks[y *
s->nbx + x] + 3) & 2) > 0) {
1123 int i,
a,
b,
c, j, by = y * 16, bx = x * 16;
1126 a =
s->rc.code & 0xFFF;
1135 code =
a + ((
s->rc.code >> 1) & 0xFFFFF800) -
b;
1137 code = bytestream2_get_byteu(gb) | (
code << 8);
1144 s->mv_model3[0].freqs[0],
1145 s->mv_model3[0].freqs[1],
1146 s->mv_model3[0].cnts,
1147 s->mv_model3[0].dectab, &mvx);
1149 s->mv_model3[1].freqs[0],
1150 s->mv_model3[1].freqs[1],
1151 s->mv_model3[1].cnts,
1152 s->mv_model3[1].dectab, &mvy);
1160 if (by + mvy + sy1 < 0 || bx + mvx + sx1 < 0 ||
1161 by + mvy + sy1 >= avctx->
height || bx + mvx + sx1 >= avctx->
width)
1164 for (
i = 0;
i < sy2 - sy1 && (by + sy1 +
i) < avctx->
height && (by + mvy + sy1 +
i) < avctx->
height;
i++) {
1165 for (j = 0; j < sx2 - sx1 && (bx + sx1 + j) < avctx->
width && (bx + mvx + sx1 + j) < avctx->
width; j++) {
1166 dst[(by +
i + sy1) * linesize + bx + sx1 + j] = prev[(by + mvy + sy1 +
i) * plinesize + bx + sx1 + mvx + j];
1170 int run, bx = x * 16 + sx1, by = y * 16 + sy1;
1171 uint32_t clr, ptype = 0,
r,
g,
b;
1173 if (bx >= avctx->
width)
1176 for (; by < y * 16 + sy2 && by < avctx->
height;) {
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);
1189 clr = (
b << 16) + (
g << 8) +
r;
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);
1204 dst, prev, linesize, plinesize, &bx, &by,
1205 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.