Commit | Line | Data |
---|---|---|
2ba45a60 DM |
1 | /* |
2 | * Microsoft Screen 3 (aka Microsoft ATC Screen) decoder | |
3 | * Copyright (c) 2012 Konstantin Shishkov | |
4 | * | |
5 | * This file is part of FFmpeg. | |
6 | * | |
7 | * FFmpeg is free software; you can redistribute it and/or | |
8 | * modify it under the terms of the GNU Lesser General Public | |
9 | * License as published by the Free Software Foundation; either | |
10 | * version 2.1 of the License, or (at your option) any later version. | |
11 | * | |
12 | * FFmpeg is distributed in the hope that it will be useful, | |
13 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
15 | * Lesser General Public License for more details. | |
16 | * | |
17 | * You should have received a copy of the GNU Lesser General Public | |
18 | * License along with FFmpeg; if not, write to the Free Software | |
19 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA | |
20 | */ | |
21 | ||
22 | /** | |
23 | * @file | |
24 | * Microsoft Screen 3 (aka Microsoft ATC Screen) decoder | |
25 | */ | |
26 | ||
27 | #include "avcodec.h" | |
28 | #include "bytestream.h" | |
29 | #include "internal.h" | |
30 | #include "mathops.h" | |
31 | #include "mss34dsp.h" | |
32 | ||
33 | #define HEADER_SIZE 27 | |
34 | ||
35 | #define MODEL2_SCALE 13 | |
36 | #define MODEL_SCALE 15 | |
37 | #define MODEL256_SEC_SCALE 9 | |
38 | ||
39 | typedef struct Model2 { | |
40 | int upd_val, till_rescale; | |
41 | unsigned zero_freq, zero_weight; | |
42 | unsigned total_freq, total_weight; | |
43 | } Model2; | |
44 | ||
45 | typedef struct Model { | |
46 | int weights[16], freqs[16]; | |
47 | int num_syms; | |
48 | int tot_weight; | |
49 | int upd_val, max_upd_val, till_rescale; | |
50 | } Model; | |
51 | ||
52 | typedef struct Model256 { | |
53 | int weights[256], freqs[256]; | |
54 | int tot_weight; | |
55 | int secondary[68]; | |
56 | int sec_size; | |
57 | int upd_val, max_upd_val, till_rescale; | |
58 | } Model256; | |
59 | ||
60 | #define RAC_BOTTOM 0x01000000 | |
61 | typedef struct RangeCoder { | |
62 | const uint8_t *src, *src_end; | |
63 | ||
64 | uint32_t range, low; | |
65 | int got_error; | |
66 | } RangeCoder; | |
67 | ||
68 | enum BlockType { | |
69 | FILL_BLOCK = 0, | |
70 | IMAGE_BLOCK, | |
71 | DCT_BLOCK, | |
72 | HAAR_BLOCK, | |
73 | SKIP_BLOCK | |
74 | }; | |
75 | ||
76 | typedef struct BlockTypeContext { | |
77 | int last_type; | |
78 | Model bt_model[5]; | |
79 | } BlockTypeContext; | |
80 | ||
81 | typedef struct FillBlockCoder { | |
82 | int fill_val; | |
83 | Model coef_model; | |
84 | } FillBlockCoder; | |
85 | ||
86 | typedef struct ImageBlockCoder { | |
87 | Model256 esc_model, vec_entry_model; | |
88 | Model vec_size_model; | |
89 | Model vq_model[125]; | |
90 | } ImageBlockCoder; | |
91 | ||
92 | typedef struct DCTBlockCoder { | |
93 | int *prev_dc; | |
94 | int prev_dc_stride; | |
95 | int prev_dc_height; | |
96 | int quality; | |
97 | uint16_t qmat[64]; | |
98 | Model dc_model; | |
99 | Model2 sign_model; | |
100 | Model256 ac_model; | |
101 | } DCTBlockCoder; | |
102 | ||
103 | typedef struct HaarBlockCoder { | |
104 | int quality, scale; | |
105 | Model256 coef_model; | |
106 | Model coef_hi_model; | |
107 | } HaarBlockCoder; | |
108 | ||
109 | typedef struct MSS3Context { | |
110 | AVCodecContext *avctx; | |
111 | AVFrame *pic; | |
112 | ||
113 | int got_error; | |
114 | RangeCoder coder; | |
115 | BlockTypeContext btype[3]; | |
116 | FillBlockCoder fill_coder[3]; | |
117 | ImageBlockCoder image_coder[3]; | |
118 | DCTBlockCoder dct_coder[3]; | |
119 | HaarBlockCoder haar_coder[3]; | |
120 | ||
121 | int dctblock[64]; | |
122 | int hblock[16 * 16]; | |
123 | } MSS3Context; | |
124 | ||
125 | ||
126 | static void model2_reset(Model2 *m) | |
127 | { | |
128 | m->zero_weight = 1; | |
129 | m->total_weight = 2; | |
130 | m->zero_freq = 0x1000; | |
131 | m->total_freq = 0x2000; | |
132 | m->upd_val = 4; | |
133 | m->till_rescale = 4; | |
134 | } | |
135 | ||
136 | static void model2_update(Model2 *m, int bit) | |
137 | { | |
138 | unsigned scale; | |
139 | ||
140 | if (!bit) | |
141 | m->zero_weight++; | |
142 | m->till_rescale--; | |
143 | if (m->till_rescale) | |
144 | return; | |
145 | ||
146 | m->total_weight += m->upd_val; | |
147 | if (m->total_weight > 0x2000) { | |
148 | m->total_weight = (m->total_weight + 1) >> 1; | |
149 | m->zero_weight = (m->zero_weight + 1) >> 1; | |
150 | if (m->total_weight == m->zero_weight) | |
151 | m->total_weight = m->zero_weight + 1; | |
152 | } | |
153 | m->upd_val = m->upd_val * 5 >> 2; | |
154 | if (m->upd_val > 64) | |
155 | m->upd_val = 64; | |
156 | scale = 0x80000000u / m->total_weight; | |
157 | m->zero_freq = m->zero_weight * scale >> 18; | |
158 | m->total_freq = m->total_weight * scale >> 18; | |
159 | m->till_rescale = m->upd_val; | |
160 | } | |
161 | ||
162 | static void model_update(Model *m, int val) | |
163 | { | |
164 | int i, sum = 0; | |
165 | unsigned scale; | |
166 | ||
167 | m->weights[val]++; | |
168 | m->till_rescale--; | |
169 | if (m->till_rescale) | |
170 | return; | |
171 | m->tot_weight += m->upd_val; | |
172 | ||
173 | if (m->tot_weight > 0x8000) { | |
174 | m->tot_weight = 0; | |
175 | for (i = 0; i < m->num_syms; i++) { | |
176 | m->weights[i] = (m->weights[i] + 1) >> 1; | |
177 | m->tot_weight += m->weights[i]; | |
178 | } | |
179 | } | |
180 | scale = 0x80000000u / m->tot_weight; | |
181 | for (i = 0; i < m->num_syms; i++) { | |
182 | m->freqs[i] = sum * scale >> 16; | |
183 | sum += m->weights[i]; | |
184 | } | |
185 | ||
186 | m->upd_val = m->upd_val * 5 >> 2; | |
187 | if (m->upd_val > m->max_upd_val) | |
188 | m->upd_val = m->max_upd_val; | |
189 | m->till_rescale = m->upd_val; | |
190 | } | |
191 | ||
192 | static void model_reset(Model *m) | |
193 | { | |
194 | int i; | |
195 | ||
196 | m->tot_weight = 0; | |
197 | for (i = 0; i < m->num_syms - 1; i++) | |
198 | m->weights[i] = 1; | |
199 | m->weights[m->num_syms - 1] = 0; | |
200 | ||
201 | m->upd_val = m->num_syms; | |
202 | m->till_rescale = 1; | |
203 | model_update(m, m->num_syms - 1); | |
204 | m->till_rescale = | |
205 | m->upd_val = (m->num_syms + 6) >> 1; | |
206 | } | |
207 | ||
208 | static av_cold void model_init(Model *m, int num_syms) | |
209 | { | |
210 | m->num_syms = num_syms; | |
211 | m->max_upd_val = 8 * num_syms + 48; | |
212 | ||
213 | model_reset(m); | |
214 | } | |
215 | ||
216 | static void model256_update(Model256 *m, int val) | |
217 | { | |
218 | int i, sum = 0; | |
219 | unsigned scale; | |
220 | int send, sidx = 1; | |
221 | ||
222 | m->weights[val]++; | |
223 | m->till_rescale--; | |
224 | if (m->till_rescale) | |
225 | return; | |
226 | m->tot_weight += m->upd_val; | |
227 | ||
228 | if (m->tot_weight > 0x8000) { | |
229 | m->tot_weight = 0; | |
230 | for (i = 0; i < 256; i++) { | |
231 | m->weights[i] = (m->weights[i] + 1) >> 1; | |
232 | m->tot_weight += m->weights[i]; | |
233 | } | |
234 | } | |
235 | scale = 0x80000000u / m->tot_weight; | |
236 | m->secondary[0] = 0; | |
237 | for (i = 0; i < 256; i++) { | |
238 | m->freqs[i] = sum * scale >> 16; | |
239 | sum += m->weights[i]; | |
240 | send = m->freqs[i] >> MODEL256_SEC_SCALE; | |
241 | while (sidx <= send) | |
242 | m->secondary[sidx++] = i - 1; | |
243 | } | |
244 | while (sidx < m->sec_size) | |
245 | m->secondary[sidx++] = 255; | |
246 | ||
247 | m->upd_val = m->upd_val * 5 >> 2; | |
248 | if (m->upd_val > m->max_upd_val) | |
249 | m->upd_val = m->max_upd_val; | |
250 | m->till_rescale = m->upd_val; | |
251 | } | |
252 | ||
253 | static void model256_reset(Model256 *m) | |
254 | { | |
255 | int i; | |
256 | ||
257 | for (i = 0; i < 255; i++) | |
258 | m->weights[i] = 1; | |
259 | m->weights[255] = 0; | |
260 | ||
261 | m->tot_weight = 0; | |
262 | m->upd_val = 256; | |
263 | m->till_rescale = 1; | |
264 | model256_update(m, 255); | |
265 | m->till_rescale = | |
266 | m->upd_val = (256 + 6) >> 1; | |
267 | } | |
268 | ||
269 | static av_cold void model256_init(Model256 *m) | |
270 | { | |
271 | m->max_upd_val = 8 * 256 + 48; | |
272 | m->sec_size = (1 << 6) + 2; | |
273 | ||
274 | model256_reset(m); | |
275 | } | |
276 | ||
277 | static void rac_init(RangeCoder *c, const uint8_t *src, int size) | |
278 | { | |
279 | int i; | |
280 | ||
281 | c->src = src; | |
282 | c->src_end = src + size; | |
283 | c->low = 0; | |
284 | for (i = 0; i < FFMIN(size, 4); i++) | |
285 | c->low = (c->low << 8) | *c->src++; | |
286 | c->range = 0xFFFFFFFF; | |
287 | c->got_error = 0; | |
288 | } | |
289 | ||
290 | static void rac_normalise(RangeCoder *c) | |
291 | { | |
292 | for (;;) { | |
293 | c->range <<= 8; | |
294 | c->low <<= 8; | |
295 | if (c->src < c->src_end) { | |
296 | c->low |= *c->src++; | |
297 | } else if (!c->low) { | |
298 | c->got_error = 1; | |
299 | c->low = 1; | |
300 | } | |
301 | if (c->range >= RAC_BOTTOM) | |
302 | return; | |
303 | } | |
304 | } | |
305 | ||
306 | static int rac_get_bit(RangeCoder *c) | |
307 | { | |
308 | int bit; | |
309 | ||
310 | c->range >>= 1; | |
311 | ||
312 | bit = (c->range <= c->low); | |
313 | if (bit) | |
314 | c->low -= c->range; | |
315 | ||
316 | if (c->range < RAC_BOTTOM) | |
317 | rac_normalise(c); | |
318 | ||
319 | return bit; | |
320 | } | |
321 | ||
322 | static int rac_get_bits(RangeCoder *c, int nbits) | |
323 | { | |
324 | int val; | |
325 | ||
326 | c->range >>= nbits; | |
327 | val = c->low / c->range; | |
328 | c->low -= c->range * val; | |
329 | ||
330 | if (c->range < RAC_BOTTOM) | |
331 | rac_normalise(c); | |
332 | ||
333 | return val; | |
334 | } | |
335 | ||
336 | static int rac_get_model2_sym(RangeCoder *c, Model2 *m) | |
337 | { | |
338 | int bit, helper; | |
339 | ||
340 | helper = m->zero_freq * (c->range >> MODEL2_SCALE); | |
341 | bit = (c->low >= helper); | |
342 | if (bit) { | |
343 | c->low -= helper; | |
344 | c->range -= helper; | |
345 | } else { | |
346 | c->range = helper; | |
347 | } | |
348 | ||
349 | if (c->range < RAC_BOTTOM) | |
350 | rac_normalise(c); | |
351 | ||
352 | model2_update(m, bit); | |
353 | ||
354 | return bit; | |
355 | } | |
356 | ||
357 | static int rac_get_model_sym(RangeCoder *c, Model *m) | |
358 | { | |
359 | int prob, prob2, helper, val; | |
360 | int end, end2; | |
361 | ||
362 | prob = 0; | |
363 | prob2 = c->range; | |
364 | c->range >>= MODEL_SCALE; | |
365 | val = 0; | |
366 | end = m->num_syms >> 1; | |
367 | end2 = m->num_syms; | |
368 | do { | |
369 | helper = m->freqs[end] * c->range; | |
370 | if (helper <= c->low) { | |
371 | val = end; | |
372 | prob = helper; | |
373 | } else { | |
374 | end2 = end; | |
375 | prob2 = helper; | |
376 | } | |
377 | end = (end2 + val) >> 1; | |
378 | } while (end != val); | |
379 | c->low -= prob; | |
380 | c->range = prob2 - prob; | |
381 | if (c->range < RAC_BOTTOM) | |
382 | rac_normalise(c); | |
383 | ||
384 | model_update(m, val); | |
385 | ||
386 | return val; | |
387 | } | |
388 | ||
389 | static int rac_get_model256_sym(RangeCoder *c, Model256 *m) | |
390 | { | |
391 | int prob, prob2, helper, val; | |
392 | int start, end; | |
393 | int ssym; | |
394 | ||
395 | prob2 = c->range; | |
396 | c->range >>= MODEL_SCALE; | |
397 | ||
398 | helper = c->low / c->range; | |
399 | ssym = helper >> MODEL256_SEC_SCALE; | |
400 | val = m->secondary[ssym]; | |
401 | ||
402 | end = start = m->secondary[ssym + 1] + 1; | |
403 | while (end > val + 1) { | |
404 | ssym = (end + val) >> 1; | |
405 | if (m->freqs[ssym] <= helper) { | |
406 | end = start; | |
407 | val = ssym; | |
408 | } else { | |
409 | end = (end + val) >> 1; | |
410 | start = ssym; | |
411 | } | |
412 | } | |
413 | prob = m->freqs[val] * c->range; | |
414 | if (val != 255) | |
415 | prob2 = m->freqs[val + 1] * c->range; | |
416 | ||
417 | c->low -= prob; | |
418 | c->range = prob2 - prob; | |
419 | if (c->range < RAC_BOTTOM) | |
420 | rac_normalise(c); | |
421 | ||
422 | model256_update(m, val); | |
423 | ||
424 | return val; | |
425 | } | |
426 | ||
427 | static int decode_block_type(RangeCoder *c, BlockTypeContext *bt) | |
428 | { | |
429 | bt->last_type = rac_get_model_sym(c, &bt->bt_model[bt->last_type]); | |
430 | ||
431 | return bt->last_type; | |
432 | } | |
433 | ||
434 | static int decode_coeff(RangeCoder *c, Model *m) | |
435 | { | |
436 | int val, sign; | |
437 | ||
438 | val = rac_get_model_sym(c, m); | |
439 | if (val) { | |
440 | sign = rac_get_bit(c); | |
441 | if (val > 1) { | |
442 | val--; | |
443 | val = (1 << val) + rac_get_bits(c, val); | |
444 | } | |
445 | if (!sign) | |
446 | val = -val; | |
447 | } | |
448 | ||
449 | return val; | |
450 | } | |
451 | ||
452 | static void decode_fill_block(RangeCoder *c, FillBlockCoder *fc, | |
453 | uint8_t *dst, int stride, int block_size) | |
454 | { | |
455 | int i; | |
456 | ||
457 | fc->fill_val += decode_coeff(c, &fc->coef_model); | |
458 | ||
459 | for (i = 0; i < block_size; i++, dst += stride) | |
460 | memset(dst, fc->fill_val, block_size); | |
461 | } | |
462 | ||
463 | static void decode_image_block(RangeCoder *c, ImageBlockCoder *ic, | |
464 | uint8_t *dst, int stride, int block_size) | |
465 | { | |
466 | int i, j; | |
467 | int vec_size; | |
468 | int vec[4]; | |
469 | int prev_line[16]; | |
470 | int A, B, C; | |
471 | ||
472 | vec_size = rac_get_model_sym(c, &ic->vec_size_model) + 2; | |
473 | for (i = 0; i < vec_size; i++) | |
474 | vec[i] = rac_get_model256_sym(c, &ic->vec_entry_model); | |
475 | for (; i < 4; i++) | |
476 | vec[i] = 0; | |
477 | memset(prev_line, 0, sizeof(prev_line)); | |
478 | ||
479 | for (j = 0; j < block_size; j++) { | |
480 | A = 0; | |
481 | B = 0; | |
482 | for (i = 0; i < block_size; i++) { | |
483 | C = B; | |
484 | B = prev_line[i]; | |
485 | A = rac_get_model_sym(c, &ic->vq_model[A + B * 5 + C * 25]); | |
486 | ||
487 | prev_line[i] = A; | |
488 | if (A < 4) | |
489 | dst[i] = vec[A]; | |
490 | else | |
491 | dst[i] = rac_get_model256_sym(c, &ic->esc_model); | |
492 | } | |
493 | dst += stride; | |
494 | } | |
495 | } | |
496 | ||
497 | static int decode_dct(RangeCoder *c, DCTBlockCoder *bc, int *block, | |
498 | int bx, int by) | |
499 | { | |
500 | int skip, val, sign, pos = 1, zz_pos, dc; | |
501 | int blk_pos = bx + by * bc->prev_dc_stride; | |
502 | ||
503 | memset(block, 0, sizeof(*block) * 64); | |
504 | ||
505 | dc = decode_coeff(c, &bc->dc_model); | |
506 | if (by) { | |
507 | if (bx) { | |
508 | int l, tl, t; | |
509 | ||
510 | l = bc->prev_dc[blk_pos - 1]; | |
511 | tl = bc->prev_dc[blk_pos - 1 - bc->prev_dc_stride]; | |
512 | t = bc->prev_dc[blk_pos - bc->prev_dc_stride]; | |
513 | ||
514 | if (FFABS(t - tl) <= FFABS(l - tl)) | |
515 | dc += l; | |
516 | else | |
517 | dc += t; | |
518 | } else { | |
519 | dc += bc->prev_dc[blk_pos - bc->prev_dc_stride]; | |
520 | } | |
521 | } else if (bx) { | |
522 | dc += bc->prev_dc[bx - 1]; | |
523 | } | |
524 | bc->prev_dc[blk_pos] = dc; | |
525 | block[0] = dc * bc->qmat[0]; | |
526 | ||
527 | while (pos < 64) { | |
528 | val = rac_get_model256_sym(c, &bc->ac_model); | |
529 | if (!val) | |
530 | return 0; | |
531 | if (val == 0xF0) { | |
532 | pos += 16; | |
533 | continue; | |
534 | } | |
535 | skip = val >> 4; | |
536 | val = val & 0xF; | |
537 | if (!val) | |
538 | return -1; | |
539 | pos += skip; | |
540 | if (pos >= 64) | |
541 | return -1; | |
542 | ||
543 | sign = rac_get_model2_sym(c, &bc->sign_model); | |
544 | if (val > 1) { | |
545 | val--; | |
546 | val = (1 << val) + rac_get_bits(c, val); | |
547 | } | |
548 | if (!sign) | |
549 | val = -val; | |
550 | ||
551 | zz_pos = ff_zigzag_direct[pos]; | |
552 | block[zz_pos] = val * bc->qmat[zz_pos]; | |
553 | pos++; | |
554 | } | |
555 | ||
556 | return pos == 64 ? 0 : -1; | |
557 | } | |
558 | ||
559 | static void decode_dct_block(RangeCoder *c, DCTBlockCoder *bc, | |
560 | uint8_t *dst, int stride, int block_size, | |
561 | int *block, int mb_x, int mb_y) | |
562 | { | |
563 | int i, j; | |
564 | int bx, by; | |
565 | int nblocks = block_size >> 3; | |
566 | ||
567 | bx = mb_x * nblocks; | |
568 | by = mb_y * nblocks; | |
569 | ||
570 | for (j = 0; j < nblocks; j++) { | |
571 | for (i = 0; i < nblocks; i++) { | |
572 | if (decode_dct(c, bc, block, bx + i, by + j)) { | |
573 | c->got_error = 1; | |
574 | return; | |
575 | } | |
576 | ff_mss34_dct_put(dst + i * 8, stride, block); | |
577 | } | |
578 | dst += 8 * stride; | |
579 | } | |
580 | } | |
581 | ||
582 | static void decode_haar_block(RangeCoder *c, HaarBlockCoder *hc, | |
583 | uint8_t *dst, int stride, int block_size, | |
584 | int *block) | |
585 | { | |
586 | const int hsize = block_size >> 1; | |
587 | int A, B, C, D, t1, t2, t3, t4; | |
588 | int i, j; | |
589 | ||
590 | for (j = 0; j < block_size; j++) { | |
591 | for (i = 0; i < block_size; i++) { | |
592 | if (i < hsize && j < hsize) | |
593 | block[i] = rac_get_model256_sym(c, &hc->coef_model); | |
594 | else | |
595 | block[i] = decode_coeff(c, &hc->coef_hi_model); | |
596 | block[i] *= hc->scale; | |
597 | } | |
598 | block += block_size; | |
599 | } | |
600 | block -= block_size * block_size; | |
601 | ||
602 | for (j = 0; j < hsize; j++) { | |
603 | for (i = 0; i < hsize; i++) { | |
604 | A = block[i]; | |
605 | B = block[i + hsize]; | |
606 | C = block[i + hsize * block_size]; | |
607 | D = block[i + hsize * block_size + hsize]; | |
608 | ||
609 | t1 = A - B; | |
610 | t2 = C - D; | |
611 | t3 = A + B; | |
612 | t4 = C + D; | |
613 | dst[i * 2] = av_clip_uint8(t1 - t2); | |
614 | dst[i * 2 + stride] = av_clip_uint8(t1 + t2); | |
615 | dst[i * 2 + 1] = av_clip_uint8(t3 - t4); | |
616 | dst[i * 2 + 1 + stride] = av_clip_uint8(t3 + t4); | |
617 | } | |
618 | block += block_size; | |
619 | dst += stride * 2; | |
620 | } | |
621 | } | |
622 | ||
623 | static void reset_coders(MSS3Context *ctx, int quality) | |
624 | { | |
625 | int i, j; | |
626 | ||
627 | for (i = 0; i < 3; i++) { | |
628 | ctx->btype[i].last_type = SKIP_BLOCK; | |
629 | for (j = 0; j < 5; j++) | |
630 | model_reset(&ctx->btype[i].bt_model[j]); | |
631 | ctx->fill_coder[i].fill_val = 0; | |
632 | model_reset(&ctx->fill_coder[i].coef_model); | |
633 | model256_reset(&ctx->image_coder[i].esc_model); | |
634 | model256_reset(&ctx->image_coder[i].vec_entry_model); | |
635 | model_reset(&ctx->image_coder[i].vec_size_model); | |
636 | for (j = 0; j < 125; j++) | |
637 | model_reset(&ctx->image_coder[i].vq_model[j]); | |
638 | if (ctx->dct_coder[i].quality != quality) { | |
639 | ctx->dct_coder[i].quality = quality; | |
640 | ff_mss34_gen_quant_mat(ctx->dct_coder[i].qmat, quality, !i); | |
641 | } | |
642 | memset(ctx->dct_coder[i].prev_dc, 0, | |
643 | sizeof(*ctx->dct_coder[i].prev_dc) * | |
644 | ctx->dct_coder[i].prev_dc_stride * | |
645 | ctx->dct_coder[i].prev_dc_height); | |
646 | model_reset(&ctx->dct_coder[i].dc_model); | |
647 | model2_reset(&ctx->dct_coder[i].sign_model); | |
648 | model256_reset(&ctx->dct_coder[i].ac_model); | |
649 | if (ctx->haar_coder[i].quality != quality) { | |
650 | ctx->haar_coder[i].quality = quality; | |
651 | ctx->haar_coder[i].scale = 17 - 7 * quality / 50; | |
652 | } | |
653 | model_reset(&ctx->haar_coder[i].coef_hi_model); | |
654 | model256_reset(&ctx->haar_coder[i].coef_model); | |
655 | } | |
656 | } | |
657 | ||
658 | static av_cold void init_coders(MSS3Context *ctx) | |
659 | { | |
660 | int i, j; | |
661 | ||
662 | for (i = 0; i < 3; i++) { | |
663 | for (j = 0; j < 5; j++) | |
664 | model_init(&ctx->btype[i].bt_model[j], 5); | |
665 | model_init(&ctx->fill_coder[i].coef_model, 12); | |
666 | model256_init(&ctx->image_coder[i].esc_model); | |
667 | model256_init(&ctx->image_coder[i].vec_entry_model); | |
668 | model_init(&ctx->image_coder[i].vec_size_model, 3); | |
669 | for (j = 0; j < 125; j++) | |
670 | model_init(&ctx->image_coder[i].vq_model[j], 5); | |
671 | model_init(&ctx->dct_coder[i].dc_model, 12); | |
672 | model256_init(&ctx->dct_coder[i].ac_model); | |
673 | model_init(&ctx->haar_coder[i].coef_hi_model, 12); | |
674 | model256_init(&ctx->haar_coder[i].coef_model); | |
675 | } | |
676 | } | |
677 | ||
678 | static int mss3_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, | |
679 | AVPacket *avpkt) | |
680 | { | |
681 | const uint8_t *buf = avpkt->data; | |
682 | int buf_size = avpkt->size; | |
683 | MSS3Context *c = avctx->priv_data; | |
684 | RangeCoder *acoder = &c->coder; | |
685 | GetByteContext gb; | |
686 | uint8_t *dst[3]; | |
687 | int dec_width, dec_height, dec_x, dec_y, quality, keyframe; | |
688 | int x, y, i, mb_width, mb_height, blk_size, btype; | |
689 | int ret; | |
690 | ||
691 | if (buf_size < HEADER_SIZE) { | |
692 | av_log(avctx, AV_LOG_ERROR, | |
693 | "Frame should have at least %d bytes, got %d instead\n", | |
694 | HEADER_SIZE, buf_size); | |
695 | return AVERROR_INVALIDDATA; | |
696 | } | |
697 | ||
698 | bytestream2_init(&gb, buf, buf_size); | |
699 | keyframe = bytestream2_get_be32(&gb); | |
700 | if (keyframe & ~0x301) { | |
701 | av_log(avctx, AV_LOG_ERROR, "Invalid frame type %X\n", keyframe); | |
702 | return AVERROR_INVALIDDATA; | |
703 | } | |
704 | keyframe = !(keyframe & 1); | |
705 | bytestream2_skip(&gb, 6); | |
706 | dec_x = bytestream2_get_be16(&gb); | |
707 | dec_y = bytestream2_get_be16(&gb); | |
708 | dec_width = bytestream2_get_be16(&gb); | |
709 | dec_height = bytestream2_get_be16(&gb); | |
710 | ||
711 | if (dec_x + dec_width > avctx->width || | |
712 | dec_y + dec_height > avctx->height || | |
713 | (dec_width | dec_height) & 0xF) { | |
714 | av_log(avctx, AV_LOG_ERROR, "Invalid frame dimensions %dx%d +%d,%d\n", | |
715 | dec_width, dec_height, dec_x, dec_y); | |
716 | return AVERROR_INVALIDDATA; | |
717 | } | |
718 | bytestream2_skip(&gb, 4); | |
719 | quality = bytestream2_get_byte(&gb); | |
720 | if (quality < 1 || quality > 100) { | |
721 | av_log(avctx, AV_LOG_ERROR, "Invalid quality setting %d\n", quality); | |
722 | return AVERROR_INVALIDDATA; | |
723 | } | |
724 | bytestream2_skip(&gb, 4); | |
725 | ||
726 | if (keyframe && !bytestream2_get_bytes_left(&gb)) { | |
727 | av_log(avctx, AV_LOG_ERROR, "Keyframe without data found\n"); | |
728 | return AVERROR_INVALIDDATA; | |
729 | } | |
730 | if (!keyframe && c->got_error) | |
731 | return buf_size; | |
732 | c->got_error = 0; | |
733 | ||
734 | if ((ret = ff_reget_buffer(avctx, c->pic)) < 0) | |
735 | return ret; | |
736 | c->pic->key_frame = keyframe; | |
737 | c->pic->pict_type = keyframe ? AV_PICTURE_TYPE_I : AV_PICTURE_TYPE_P; | |
738 | if (!bytestream2_get_bytes_left(&gb)) { | |
739 | if ((ret = av_frame_ref(data, c->pic)) < 0) | |
740 | return ret; | |
741 | *got_frame = 1; | |
742 | ||
743 | return buf_size; | |
744 | } | |
745 | ||
746 | reset_coders(c, quality); | |
747 | ||
748 | rac_init(acoder, buf + HEADER_SIZE, buf_size - HEADER_SIZE); | |
749 | ||
750 | mb_width = dec_width >> 4; | |
751 | mb_height = dec_height >> 4; | |
752 | dst[0] = c->pic->data[0] + dec_x + dec_y * c->pic->linesize[0]; | |
753 | dst[1] = c->pic->data[1] + dec_x / 2 + (dec_y / 2) * c->pic->linesize[1]; | |
754 | dst[2] = c->pic->data[2] + dec_x / 2 + (dec_y / 2) * c->pic->linesize[2]; | |
755 | for (y = 0; y < mb_height; y++) { | |
756 | for (x = 0; x < mb_width; x++) { | |
757 | for (i = 0; i < 3; i++) { | |
758 | blk_size = 8 << !i; | |
759 | ||
760 | btype = decode_block_type(acoder, c->btype + i); | |
761 | switch (btype) { | |
762 | case FILL_BLOCK: | |
763 | decode_fill_block(acoder, c->fill_coder + i, | |
764 | dst[i] + x * blk_size, | |
765 | c->pic->linesize[i], blk_size); | |
766 | break; | |
767 | case IMAGE_BLOCK: | |
768 | decode_image_block(acoder, c->image_coder + i, | |
769 | dst[i] + x * blk_size, | |
770 | c->pic->linesize[i], blk_size); | |
771 | break; | |
772 | case DCT_BLOCK: | |
773 | decode_dct_block(acoder, c->dct_coder + i, | |
774 | dst[i] + x * blk_size, | |
775 | c->pic->linesize[i], blk_size, | |
776 | c->dctblock, x, y); | |
777 | break; | |
778 | case HAAR_BLOCK: | |
779 | decode_haar_block(acoder, c->haar_coder + i, | |
780 | dst[i] + x * blk_size, | |
781 | c->pic->linesize[i], blk_size, | |
782 | c->hblock); | |
783 | break; | |
784 | } | |
785 | if (c->got_error || acoder->got_error) { | |
786 | av_log(avctx, AV_LOG_ERROR, "Error decoding block %d,%d\n", | |
787 | x, y); | |
788 | c->got_error = 1; | |
789 | return AVERROR_INVALIDDATA; | |
790 | } | |
791 | } | |
792 | } | |
793 | dst[0] += c->pic->linesize[0] * 16; | |
794 | dst[1] += c->pic->linesize[1] * 8; | |
795 | dst[2] += c->pic->linesize[2] * 8; | |
796 | } | |
797 | ||
798 | if ((ret = av_frame_ref(data, c->pic)) < 0) | |
799 | return ret; | |
800 | ||
801 | *got_frame = 1; | |
802 | ||
803 | return buf_size; | |
804 | } | |
805 | ||
806 | static av_cold int mss3_decode_end(AVCodecContext *avctx) | |
807 | { | |
808 | MSS3Context * const c = avctx->priv_data; | |
809 | int i; | |
810 | ||
811 | av_frame_free(&c->pic); | |
812 | for (i = 0; i < 3; i++) | |
813 | av_freep(&c->dct_coder[i].prev_dc); | |
814 | ||
815 | return 0; | |
816 | } | |
817 | ||
818 | static av_cold int mss3_decode_init(AVCodecContext *avctx) | |
819 | { | |
820 | MSS3Context * const c = avctx->priv_data; | |
821 | int i; | |
822 | ||
823 | c->avctx = avctx; | |
824 | ||
825 | if ((avctx->width & 0xF) || (avctx->height & 0xF)) { | |
826 | av_log(avctx, AV_LOG_ERROR, | |
827 | "Image dimensions should be a multiple of 16.\n"); | |
828 | return AVERROR_INVALIDDATA; | |
829 | } | |
830 | ||
831 | c->got_error = 0; | |
832 | for (i = 0; i < 3; i++) { | |
833 | int b_width = avctx->width >> (2 + !!i); | |
834 | int b_height = avctx->height >> (2 + !!i); | |
835 | c->dct_coder[i].prev_dc_stride = b_width; | |
836 | c->dct_coder[i].prev_dc_height = b_height; | |
837 | c->dct_coder[i].prev_dc = av_malloc(sizeof(*c->dct_coder[i].prev_dc) * | |
838 | b_width * b_height); | |
839 | if (!c->dct_coder[i].prev_dc) { | |
840 | av_log(avctx, AV_LOG_ERROR, "Cannot allocate buffer\n"); | |
841 | av_frame_free(&c->pic); | |
842 | while (i >= 0) { | |
843 | av_freep(&c->dct_coder[i].prev_dc); | |
844 | i--; | |
845 | } | |
846 | return AVERROR(ENOMEM); | |
847 | } | |
848 | } | |
849 | ||
850 | c->pic = av_frame_alloc(); | |
851 | if (!c->pic) { | |
852 | mss3_decode_end(avctx); | |
853 | return AVERROR(ENOMEM); | |
854 | } | |
855 | ||
856 | avctx->pix_fmt = AV_PIX_FMT_YUV420P; | |
857 | ||
858 | init_coders(c); | |
859 | ||
860 | return 0; | |
861 | } | |
862 | ||
863 | AVCodec ff_msa1_decoder = { | |
864 | .name = "msa1", | |
865 | .long_name = NULL_IF_CONFIG_SMALL("MS ATC Screen"), | |
866 | .type = AVMEDIA_TYPE_VIDEO, | |
867 | .id = AV_CODEC_ID_MSA1, | |
868 | .priv_data_size = sizeof(MSS3Context), | |
869 | .init = mss3_decode_init, | |
870 | .close = mss3_decode_end, | |
871 | .decode = mss3_decode_frame, | |
872 | .capabilities = CODEC_CAP_DR1, | |
873 | }; |