1 /*
2 * Microsoft Screen 4 (aka Microsoft Expression Encoder 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 4 (aka Microsoft Titanium Screen 2,
25 * aka Microsoft Expression Encoder Screen) decoder
26 */
27
28 #include "libavutil/thread.h"
29
30 #include "avcodec.h"
31 #include "bytestream.h"
32 #include "get_bits.h"
33 #include "internal.h"
34 #include "jpegtables.h"
35 #include "mss34dsp.h"
36 #include "unary.h"
37
38 #define HEADER_SIZE 8
39
40 enum FrameType {
41 INTRA_FRAME = 0,
42 INTER_FRAME,
43 SKIP_FRAME
44 };
45
46 enum BlockType {
47 SKIP_BLOCK = 0,
48 DCT_BLOCK,
49 IMAGE_BLOCK,
50 };
51
52 enum CachePos {
53 LEFT = 0,
54 TOP_LEFT,
55 TOP,
56 };
57
58 static const uint8_t mss4_dc_vlc_lens[2][16] = {
59 { 0, 1, 5, 1, 1, 1, 1, 2, 0, 0, 0, 0, 0, 0, 0, 0 },
60 { 0, 3, 1, 1, 1, 1, 1, 1, 1, 2, 0, 0, 0, 0, 0, 0 }
61 };
62
63 static const uint8_t vec_len_syms[2][4] = {
64 { 4, 2, 3, 1 },
65 { 4, 1, 2, 3 }
66 };
67
68 static const uint8_t mss4_vec_entry_vlc_lens[2][16] = {
69 { 0, 2, 2, 3, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
70 { 0, 1, 5, 1, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
71 };
72
73 static const uint8_t mss4_vec_entry_vlc_syms[2][9] = {
74 { 0, 7, 6, 5, 8, 4, 3, 1, 2 },
75 { 0, 2, 3, 4, 5, 6, 7, 1, 8 }
76 };
77
78 #define MAX_ENTRIES 162
79
80 typedef struct MSS4Context {
81 AVFrame *pic;
82
83 int block[64];
84 uint8_t imgbuf[3][16 * 16];
85
86 int quality;
87 uint16_t quant_mat[2][64];
88
89 int *prev_dc[3];
90 ptrdiff_t dc_stride[3];
91 int dc_cache[4][4];
92
93 int prev_vec[3][4];
94 } MSS4Context;
95
96 static VLC dc_vlc[2], ac_vlc[2];
97 static VLC vec_entry_vlc[2];
98
mss4_init_vlc(VLC * vlc,unsigned * offset,const uint8_t * lens,const uint8_t * syms)99 static av_cold void mss4_init_vlc(VLC *vlc, unsigned *offset,
100 const uint8_t *lens, const uint8_t *syms)
101 {
102 static VLC_TYPE vlc_buf[2146][2];
103 uint8_t bits[MAX_ENTRIES];
104 int i, j;
105 int idx = 0;
106
107 for (i = 0; i < 16; i++) {
108 for (j = 0; j < lens[i]; j++) {
109 bits[idx] = i + 1;
110 idx++;
111 }
112 }
113
114 vlc->table = &vlc_buf[*offset];
115 vlc->table_allocated = FF_ARRAY_ELEMS(vlc_buf) - *offset;
116 ff_init_vlc_from_lengths(vlc, FFMIN(bits[idx - 1], 9), idx,
117 bits, 1, syms, 1, 1,
118 0, INIT_VLC_STATIC_OVERLONG, NULL);
119 *offset += vlc->table_size;
120 }
121
mss4_init_vlcs(void)122 static av_cold void mss4_init_vlcs(void)
123 {
124 for (unsigned i = 0, offset = 0; i < 2; i++) {
125 mss4_init_vlc(&dc_vlc[i], &offset, mss4_dc_vlc_lens[i], NULL);
126 mss4_init_vlc(&ac_vlc[i], &offset,
127 i ? avpriv_mjpeg_bits_ac_chrominance + 1
128 : avpriv_mjpeg_bits_ac_luminance + 1,
129 i ? avpriv_mjpeg_val_ac_chrominance
130 : avpriv_mjpeg_val_ac_luminance);
131 mss4_init_vlc(&vec_entry_vlc[i], &offset, mss4_vec_entry_vlc_lens[i],
132 mss4_vec_entry_vlc_syms[i]);
133 }
134 }
135
136 /* This function returns values in the range
137 * (-range + 1; -range/2] U [range/2; range - 1)
138 * i.e.
139 * nbits = 0 -> 0
140 * nbits = 1 -> -1, 1
141 * nbits = 2 -> -3, -2, 2, 3
142 */
get_coeff_bits(GetBitContext * gb,int nbits)143 static av_always_inline int get_coeff_bits(GetBitContext *gb, int nbits)
144 {
145 int val;
146
147 if (!nbits)
148 return 0;
149
150 val = get_bits(gb, nbits);
151 if (val < (1 << (nbits - 1)))
152 val -= (1 << nbits) - 1;
153
154 return val;
155 }
156
get_coeff(GetBitContext * gb,VLC * vlc)157 static inline int get_coeff(GetBitContext *gb, VLC *vlc)
158 {
159 int val = get_vlc2(gb, vlc->table, vlc->bits, 2);
160
161 return get_coeff_bits(gb, val);
162 }
163
mss4_decode_dct(GetBitContext * gb,VLC * dc_vlc,VLC * ac_vlc,int * block,int * dc_cache,int bx,int by,uint16_t * quant_mat)164 static int mss4_decode_dct(GetBitContext *gb, VLC *dc_vlc, VLC *ac_vlc,
165 int *block, int *dc_cache,
166 int bx, int by, uint16_t *quant_mat)
167 {
168 int skip, val, pos = 1, zz_pos, dc;
169
170 memset(block, 0, sizeof(*block) * 64);
171
172 dc = get_coeff(gb, dc_vlc);
173 // DC prediction is the same as in MSS3
174 if (by) {
175 if (bx) {
176 int l, tl, t;
177
178 l = dc_cache[LEFT];
179 tl = dc_cache[TOP_LEFT];
180 t = dc_cache[TOP];
181
182 if (FFABS(t - tl) <= FFABS(l - tl))
183 dc += l;
184 else
185 dc += t;
186 } else {
187 dc += dc_cache[TOP];
188 }
189 } else if (bx) {
190 dc += dc_cache[LEFT];
191 }
192 dc_cache[LEFT] = dc;
193 block[0] = dc * quant_mat[0];
194
195 while (pos < 64) {
196 val = get_vlc2(gb, ac_vlc->table, 9, 2);
197 if (!val)
198 return 0;
199 if (val == -1)
200 return -1;
201 if (val == 0xF0) {
202 pos += 16;
203 continue;
204 }
205 skip = val >> 4;
206 val = get_coeff_bits(gb, val & 0xF);
207 pos += skip;
208 if (pos >= 64)
209 return -1;
210
211 zz_pos = ff_zigzag_direct[pos];
212 block[zz_pos] = val * quant_mat[zz_pos];
213 pos++;
214 }
215
216 return pos == 64 ? 0 : -1;
217 }
218
mss4_decode_dct_block(MSS4Context * c,GetBitContext * gb,uint8_t * dst[3],int mb_x,int mb_y)219 static int mss4_decode_dct_block(MSS4Context *c, GetBitContext *gb,
220 uint8_t *dst[3], int mb_x, int mb_y)
221 {
222 int i, j, k, ret;
223 uint8_t *out = dst[0];
224
225 for (j = 0; j < 2; j++) {
226 for (i = 0; i < 2; i++) {
227 int xpos = mb_x * 2 + i;
228 c->dc_cache[j][TOP_LEFT] = c->dc_cache[j][TOP];
229 c->dc_cache[j][TOP] = c->prev_dc[0][mb_x * 2 + i];
230 ret = mss4_decode_dct(gb, &dc_vlc[0], &ac_vlc[0], c->block,
231 c->dc_cache[j],
232 xpos, mb_y * 2 + j, c->quant_mat[0]);
233 if (ret)
234 return ret;
235 c->prev_dc[0][mb_x * 2 + i] = c->dc_cache[j][LEFT];
236
237 ff_mss34_dct_put(out + xpos * 8, c->pic->linesize[0],
238 c->block);
239 }
240 out += 8 * c->pic->linesize[0];
241 }
242
243 for (i = 1; i < 3; i++) {
244 c->dc_cache[i + 1][TOP_LEFT] = c->dc_cache[i + 1][TOP];
245 c->dc_cache[i + 1][TOP] = c->prev_dc[i][mb_x];
246 ret = mss4_decode_dct(gb, &dc_vlc[1], &ac_vlc[1],
247 c->block, c->dc_cache[i + 1], mb_x, mb_y,
248 c->quant_mat[1]);
249 if (ret)
250 return ret;
251 c->prev_dc[i][mb_x] = c->dc_cache[i + 1][LEFT];
252
253 ff_mss34_dct_put(c->imgbuf[i], 8, c->block);
254 out = dst[i] + mb_x * 16;
255 // Since the DCT block is coded as YUV420 and the whole frame as YUV444,
256 // we need to scale chroma.
257 for (j = 0; j < 16; j++) {
258 for (k = 0; k < 8; k++)
259 AV_WN16A(out + k * 2, c->imgbuf[i][k + (j & ~1) * 4] * 0x101);
260 out += c->pic->linesize[i];
261 }
262 }
263
264 return 0;
265 }
266
read_vec_pos(GetBitContext * gb,int * vec_pos,int * sel_flag,int * sel_len,int * prev)267 static void read_vec_pos(GetBitContext *gb, int *vec_pos, int *sel_flag,
268 int *sel_len, int *prev)
269 {
270 int i, y_flag = 0;
271
272 for (i = 2; i >= 0; i--) {
273 if (!sel_flag[i]) {
274 vec_pos[i] = 0;
275 continue;
276 }
277 if ((!i && !y_flag) || get_bits1(gb)) {
278 if (sel_len[i] > 0) {
279 int pval = prev[i];
280 vec_pos[i] = get_bits(gb, sel_len[i]);
281 if (vec_pos[i] >= pval)
282 vec_pos[i]++;
283 } else {
284 vec_pos[i] = !prev[i];
285 }
286 y_flag = 1;
287 } else {
288 vec_pos[i] = prev[i];
289 }
290 }
291 }
292
get_value_cached(GetBitContext * gb,int vec_pos,uint8_t * vec,int vec_size,int component,int shift,int * prev)293 static int get_value_cached(GetBitContext *gb, int vec_pos, uint8_t *vec,
294 int vec_size, int component, int shift, int *prev)
295 {
296 if (vec_pos < vec_size)
297 return vec[vec_pos];
298 if (!get_bits1(gb))
299 return prev[component];
300 prev[component] = get_bits(gb, 8 - shift) << shift;
301 return prev[component];
302 }
303
304 #define MKVAL(vals) ((vals)[0] | ((vals)[1] << 3) | ((vals)[2] << 6))
305
306 /* Image mode - the hardest to comprehend MSS4 coding mode.
307 *
308 * In this mode all three 16x16 blocks are coded together with a method
309 * remotely similar to the methods employed in MSS1-MSS3.
310 * The idea is that every component has a vector of 1-4 most common symbols
311 * and an escape mode for reading new value from the bitstream. Decoding
312 * consists of retrieving pixel values from the vector or reading new ones
313 * from the bitstream; depending on flags read from the bitstream, these vector
314 * positions can be updated or reused from the state of the previous line
315 * or previous pixel.
316 */
mss4_decode_image_block(MSS4Context * ctx,GetBitContext * gb,uint8_t * picdst[3],int mb_x,int mb_y)317 static int mss4_decode_image_block(MSS4Context *ctx, GetBitContext *gb,
318 uint8_t *picdst[3], int mb_x, int mb_y)
319 {
320 uint8_t vec[3][4];
321 int vec_len[3];
322 int sel_len[3], sel_flag[3];
323 int i, j, k, mode, split;
324 int prev_vec1 = 0, prev_split = 0;
325 int vals[3] = { 0 };
326 int prev_pix[3] = { 0 };
327 int prev_mode[16] = { 0 };
328 uint8_t *dst[3];
329
330 const int val_shift = ctx->quality == 100 ? 0 : 2;
331
332 for (i = 0; i < 3; i++)
333 dst[i] = ctx->imgbuf[i];
334
335 for (i = 0; i < 3; i++) {
336 vec_len[i] = vec_len_syms[!!i][get_unary(gb, 0, 3)];
337 for (j = 0; j < vec_len[i]; j++) {
338 vec[i][j] = get_coeff(gb, &vec_entry_vlc[!!i]);
339 vec[i][j] += ctx->prev_vec[i][j];
340 ctx->prev_vec[i][j] = vec[i][j];
341 }
342 sel_flag[i] = vec_len[i] > 1;
343 sel_len[i] = vec_len[i] > 2 ? vec_len[i] - 2 : 0;
344 }
345
346 for (j = 0; j < 16; j++) {
347 if (get_bits1(gb)) {
348 split = 0;
349 if (get_bits1(gb)) {
350 prev_mode[0] = 0;
351 vals[0] = vals[1] = vals[2] = 0;
352 mode = 2;
353 } else {
354 mode = get_bits1(gb);
355 if (mode)
356 split = get_bits(gb, 4);
357 }
358 for (i = 0; i < 16; i++) {
359 if (mode <= 1) {
360 vals[0] = prev_mode[i] & 7;
361 vals[1] = (prev_mode[i] >> 3) & 7;
362 vals[2] = prev_mode[i] >> 6;
363 if (mode == 1 && i == split) {
364 read_vec_pos(gb, vals, sel_flag, sel_len, vals);
365 }
366 } else if (mode == 2) {
367 if (get_bits1(gb))
368 read_vec_pos(gb, vals, sel_flag, sel_len, vals);
369 }
370 for (k = 0; k < 3; k++)
371 *dst[k]++ = get_value_cached(gb, vals[k], vec[k],
372 vec_len[k], k,
373 val_shift, prev_pix);
374 prev_mode[i] = MKVAL(vals);
375 }
376 } else {
377 if (get_bits1(gb)) {
378 split = get_bits(gb, 4);
379 if (split >= prev_split)
380 split++;
381 prev_split = split;
382 } else {
383 split = prev_split;
384 }
385 if (split) {
386 vals[0] = prev_mode[0] & 7;
387 vals[1] = (prev_mode[0] >> 3) & 7;
388 vals[2] = prev_mode[0] >> 6;
389 for (i = 0; i < 3; i++) {
390 for (k = 0; k < split; k++) {
391 *dst[i]++ = get_value_cached(gb, vals[i], vec[i],
392 vec_len[i], i, val_shift,
393 prev_pix);
394 prev_mode[k] = MKVAL(vals);
395 }
396 }
397 }
398
399 if (split != 16) {
400 vals[0] = prev_vec1 & 7;
401 vals[1] = (prev_vec1 >> 3) & 7;
402 vals[2] = prev_vec1 >> 6;
403 if (get_bits1(gb)) {
404 read_vec_pos(gb, vals, sel_flag, sel_len, vals);
405 prev_vec1 = MKVAL(vals);
406 }
407 for (i = 0; i < 3; i++) {
408 for (k = 0; k < 16 - split; k++) {
409 *dst[i]++ = get_value_cached(gb, vals[i], vec[i],
410 vec_len[i], i, val_shift,
411 prev_pix);
412 prev_mode[split + k] = MKVAL(vals);
413 }
414 }
415 }
416 }
417 }
418
419 for (i = 0; i < 3; i++)
420 for (j = 0; j < 16; j++)
421 memcpy(picdst[i] + mb_x * 16 + j * ctx->pic->linesize[i],
422 ctx->imgbuf[i] + j * 16, 16);
423
424 return 0;
425 }
426
mss4_update_dc_cache(MSS4Context * c,int mb_x)427 static inline void mss4_update_dc_cache(MSS4Context *c, int mb_x)
428 {
429 int i;
430
431 c->dc_cache[0][TOP] = c->prev_dc[0][mb_x * 2 + 1];
432 c->dc_cache[0][LEFT] = 0;
433 c->dc_cache[1][TOP] = 0;
434 c->dc_cache[1][LEFT] = 0;
435
436 for (i = 0; i < 2; i++)
437 c->prev_dc[0][mb_x * 2 + i] = 0;
438
439 for (i = 1; i < 3; i++) {
440 c->dc_cache[i + 1][TOP] = c->prev_dc[i][mb_x];
441 c->dc_cache[i + 1][LEFT] = 0;
442 c->prev_dc[i][mb_x] = 0;
443 }
444 }
445
mss4_decode_frame(AVCodecContext * avctx,void * data,int * got_frame,AVPacket * avpkt)446 static int mss4_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
447 AVPacket *avpkt)
448 {
449 const uint8_t *buf = avpkt->data;
450 int buf_size = avpkt->size;
451 MSS4Context *c = avctx->priv_data;
452 GetBitContext gb;
453 GetByteContext bc;
454 uint8_t *dst[3];
455 int width, height, quality, frame_type;
456 int x, y, i, mb_width, mb_height, blk_type;
457 int ret;
458
459 if (buf_size < HEADER_SIZE) {
460 av_log(avctx, AV_LOG_ERROR,
461 "Frame should have at least %d bytes, got %d instead\n",
462 HEADER_SIZE, buf_size);
463 return AVERROR_INVALIDDATA;
464 }
465
466 bytestream2_init(&bc, buf, buf_size);
467 width = bytestream2_get_be16(&bc);
468 height = bytestream2_get_be16(&bc);
469 bytestream2_skip(&bc, 2);
470 quality = bytestream2_get_byte(&bc);
471 frame_type = bytestream2_get_byte(&bc);
472
473 if (width > avctx->width ||
474 height != avctx->height) {
475 av_log(avctx, AV_LOG_ERROR, "Invalid frame dimensions %dx%d\n",
476 width, height);
477 return AVERROR_INVALIDDATA;
478 }
479 if (quality < 1 || quality > 100) {
480 av_log(avctx, AV_LOG_ERROR, "Invalid quality setting %d\n", quality);
481 return AVERROR_INVALIDDATA;
482 }
483 if ((frame_type & ~3) || frame_type == 3) {
484 av_log(avctx, AV_LOG_ERROR, "Invalid frame type %d\n", frame_type);
485 return AVERROR_INVALIDDATA;
486 }
487
488 if (frame_type != SKIP_FRAME && !bytestream2_get_bytes_left(&bc)) {
489 av_log(avctx, AV_LOG_ERROR,
490 "Empty frame found but it is not a skip frame.\n");
491 return AVERROR_INVALIDDATA;
492 }
493 mb_width = FFALIGN(width, 16) >> 4;
494 mb_height = FFALIGN(height, 16) >> 4;
495
496 if (frame_type != SKIP_FRAME && 8*buf_size < 8*HEADER_SIZE + mb_width*mb_height)
497 return AVERROR_INVALIDDATA;
498
499 if ((ret = ff_reget_buffer(avctx, c->pic, 0)) < 0)
500 return ret;
501 c->pic->key_frame = (frame_type == INTRA_FRAME);
502 c->pic->pict_type = (frame_type == INTRA_FRAME) ? AV_PICTURE_TYPE_I
503 : AV_PICTURE_TYPE_P;
504 if (frame_type == SKIP_FRAME) {
505 *got_frame = 1;
506 if ((ret = av_frame_ref(data, c->pic)) < 0)
507 return ret;
508
509 return buf_size;
510 }
511
512 if (c->quality != quality) {
513 c->quality = quality;
514 for (i = 0; i < 2; i++)
515 ff_mss34_gen_quant_mat(c->quant_mat[i], quality, !i);
516 }
517
518 if ((ret = init_get_bits8(&gb, buf + HEADER_SIZE, buf_size - HEADER_SIZE)) < 0)
519 return ret;
520 dst[0] = c->pic->data[0];
521 dst[1] = c->pic->data[1];
522 dst[2] = c->pic->data[2];
523
524 memset(c->prev_vec, 0, sizeof(c->prev_vec));
525 for (y = 0; y < mb_height; y++) {
526 memset(c->dc_cache, 0, sizeof(c->dc_cache));
527 for (x = 0; x < mb_width; x++) {
528 blk_type = decode012(&gb);
529 switch (blk_type) {
530 case DCT_BLOCK:
531 if (mss4_decode_dct_block(c, &gb, dst, x, y) < 0) {
532 av_log(avctx, AV_LOG_ERROR,
533 "Error decoding DCT block %d,%d\n",
534 x, y);
535 return AVERROR_INVALIDDATA;
536 }
537 break;
538 case IMAGE_BLOCK:
539 if (mss4_decode_image_block(c, &gb, dst, x, y) < 0) {
540 av_log(avctx, AV_LOG_ERROR,
541 "Error decoding VQ block %d,%d\n",
542 x, y);
543 return AVERROR_INVALIDDATA;
544 }
545 break;
546 case SKIP_BLOCK:
547 if (frame_type == INTRA_FRAME) {
548 av_log(avctx, AV_LOG_ERROR, "Skip block in intra frame\n");
549 return AVERROR_INVALIDDATA;
550 }
551 break;
552 }
553 if (blk_type != DCT_BLOCK)
554 mss4_update_dc_cache(c, x);
555 }
556 dst[0] += c->pic->linesize[0] * 16;
557 dst[1] += c->pic->linesize[1] * 16;
558 dst[2] += c->pic->linesize[2] * 16;
559 }
560
561 if ((ret = av_frame_ref(data, c->pic)) < 0)
562 return ret;
563
564 *got_frame = 1;
565
566 return buf_size;
567 }
568
mss4_decode_end(AVCodecContext * avctx)569 static av_cold int mss4_decode_end(AVCodecContext *avctx)
570 {
571 MSS4Context * const c = avctx->priv_data;
572 int i;
573
574 av_frame_free(&c->pic);
575 for (i = 0; i < 3; i++)
576 av_freep(&c->prev_dc[i]);
577
578 return 0;
579 }
580
mss4_decode_init(AVCodecContext * avctx)581 static av_cold int mss4_decode_init(AVCodecContext *avctx)
582 {
583 static AVOnce init_static_once = AV_ONCE_INIT;
584 MSS4Context * const c = avctx->priv_data;
585 int i;
586
587 for (i = 0; i < 3; i++) {
588 c->dc_stride[i] = FFALIGN(avctx->width, 16) >> (2 + !!i);
589 c->prev_dc[i] = av_malloc_array(c->dc_stride[i], sizeof(**c->prev_dc));
590 if (!c->prev_dc[i]) {
591 av_log(avctx, AV_LOG_ERROR, "Cannot allocate buffer\n");
592 return AVERROR(ENOMEM);
593 }
594 }
595
596 c->pic = av_frame_alloc();
597 if (!c->pic)
598 return AVERROR(ENOMEM);
599
600 avctx->pix_fmt = AV_PIX_FMT_YUV444P;
601
602 ff_thread_once(&init_static_once, mss4_init_vlcs);
603
604 return 0;
605 }
606
607 AVCodec ff_mts2_decoder = {
608 .name = "mts2",
609 .long_name = NULL_IF_CONFIG_SMALL("MS Expression Encoder Screen"),
610 .type = AVMEDIA_TYPE_VIDEO,
611 .id = AV_CODEC_ID_MTS2,
612 .priv_data_size = sizeof(MSS4Context),
613 .init = mss4_decode_init,
614 .close = mss4_decode_end,
615 .decode = mss4_decode_frame,
616 .capabilities = AV_CODEC_CAP_DR1,
617 .caps_internal = FF_CODEC_CAP_INIT_CLEANUP | FF_CODEC_CAP_INIT_THREADSAFE,
618 };
619