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