2 * Microsoft Screen 4 (aka Microsoft Expression Encoder Screen) decoder
3 * Copyright (c) 2012 Konstantin Shishkov
5 * This file is part of FFmpeg.
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.
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.
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
24 * Microsoft Screen 4 (aka Microsoft Titanium Screen 2,
25 * aka Microsoft Expression Encoder Screen) decoder
29 #include "bytestream.h"
56 static const uint8_t mss4_dc_vlc_lens[2][16] = {
57 { 0, 1, 5, 1, 1, 1, 1, 2, 0, 0, 0, 0, 0, 0, 0, 0 },
58 { 0, 3, 1, 1, 1, 1, 1, 1, 1, 2, 0, 0, 0, 0, 0, 0 }
61 static const uint8_t mss4_ac_vlc_lens[2][16] = {
62 { 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 125 },
63 { 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 119 }
66 static const uint8_t mss4_ac_vlc_syms[2][162] = {
67 { 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12,
68 0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07,
69 0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xA1, 0x08,
70 0x23, 0x42, 0xB1, 0xC1, 0x15, 0x52, 0xD1, 0xF0,
71 0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0A, 0x16,
72 0x17, 0x18, 0x19, 0x1A, 0x25, 0x26, 0x27, 0x28,
73 0x29, 0x2A, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
74 0x3A, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
75 0x4A, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
76 0x5A, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
77 0x6A, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
78 0x7A, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
79 0x8A, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98,
80 0x99, 0x9A, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7,
81 0xA8, 0xA9, 0xAA, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6,
82 0xB7, 0xB8, 0xB9, 0xBA, 0xC2, 0xC3, 0xC4, 0xC5,
83 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xD2, 0xD3, 0xD4,
84 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xE1, 0xE2,
85 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA,
86 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8,
88 { 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21,
89 0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
90 0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91,
91 0xA1, 0xB1, 0xC1, 0x09, 0x23, 0x33, 0x52, 0xF0,
92 0x15, 0x62, 0x72, 0xD1, 0x0A, 0x16, 0x24, 0x34,
93 0xE1, 0x25, 0xF1, 0x17, 0x18, 0x19, 0x1A, 0x26,
94 0x27, 0x28, 0x29, 0x2A, 0x35, 0x36, 0x37, 0x38,
95 0x39, 0x3A, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
96 0x49, 0x4A, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
97 0x59, 0x5A, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
98 0x69, 0x6A, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
99 0x79, 0x7A, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
100 0x88, 0x89, 0x8A, 0x92, 0x93, 0x94, 0x95, 0x96,
101 0x97, 0x98, 0x99, 0x9A, 0xA2, 0xA3, 0xA4, 0xA5,
102 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xB2, 0xB3, 0xB4,
103 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xC2, 0xC3,
104 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xD2,
105 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA,
106 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9,
107 0xEA, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8,
111 static const uint8_t vec_len_syms[2][4] = {
116 static const uint8_t mss4_vec_entry_vlc_lens[2][16] = {
117 { 0, 2, 2, 3, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
118 { 0, 1, 5, 1, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
121 static const uint8_t mss4_vec_entry_vlc_syms[2][9] = {
122 { 0, 7, 6, 5, 8, 4, 3, 1, 2 },
123 { 0, 2, 3, 4, 5, 6, 7, 1, 8 }
126 #define MAX_ENTRIES 162
128 typedef struct MSS4Context {
131 VLC dc_vlc[2], ac_vlc[2];
132 VLC vec_entry_vlc[2];
134 uint8_t imgbuf[3][16 * 16];
137 uint16_t quant_mat[2][64];
146 static av_cold int mss4_init_vlc(VLC *vlc, const uint8_t *lens,
147 const uint8_t *syms, int num_syms)
149 uint8_t bits[MAX_ENTRIES];
150 uint16_t codes[MAX_ENTRIES];
152 int prefix = 0, max_bits = 0, idx = 0;
154 for (i = 0; i < 16; i++) {
155 for (j = 0; j < lens[i]; j++) {
157 codes[idx] = prefix++;
164 return ff_init_vlc_sparse(vlc, FFMIN(max_bits, 9), num_syms, bits, 1, 1,
165 codes, 2, 2, syms, 1, 1, 0);
168 static av_cold int mss4_init_vlcs(MSS4Context *ctx)
172 for (i = 0; i < 2; i++) {
173 ret = mss4_init_vlc(&ctx->dc_vlc[i], mss4_dc_vlc_lens[i], NULL, 12);
176 ret = mss4_init_vlc(&ctx->ac_vlc[i], mss4_ac_vlc_lens[i],
177 mss4_ac_vlc_syms[i], 162);
180 ret = mss4_init_vlc(&ctx->vec_entry_vlc[i], mss4_vec_entry_vlc_lens[i],
181 mss4_vec_entry_vlc_syms[i], 9);
188 static av_cold void mss4_free_vlcs(MSS4Context *ctx)
192 for (i = 0; i < 2; i++) {
193 ff_free_vlc(&ctx->dc_vlc[i]);
194 ff_free_vlc(&ctx->ac_vlc[i]);
195 ff_free_vlc(&ctx->vec_entry_vlc[i]);
199 /* This function returns values in the range
200 * (-range + 1; -range/2] U [range/2; range - 1)
204 * nbits = 2 -> -3, -2, 2, 3
206 static av_always_inline int get_coeff_bits(GetBitContext *gb, int nbits)
213 val = get_bits(gb, nbits);
214 if (val < (1 << (nbits - 1)))
215 val -= (1 << nbits) - 1;
220 static inline int get_coeff(GetBitContext *gb, VLC *vlc)
222 int val = get_vlc2(gb, vlc->table, vlc->bits, 2);
224 return get_coeff_bits(gb, val);
227 static int mss4_decode_dct(GetBitContext *gb, VLC *dc_vlc, VLC *ac_vlc,
228 int *block, int *dc_cache,
229 int bx, int by, uint16_t *quant_mat)
231 int skip, val, pos = 1, zz_pos, dc;
233 memset(block, 0, sizeof(*block) * 64);
235 dc = get_coeff(gb, dc_vlc);
236 // DC prediction is the same as in MSS3
242 tl = dc_cache[TOP_LEFT];
245 if (FFABS(t - tl) <= FFABS(l - tl))
253 dc += dc_cache[LEFT];
256 block[0] = dc * quant_mat[0];
259 val = get_vlc2(gb, ac_vlc->table, 9, 2);
269 val = get_coeff_bits(gb, val & 0xF);
274 zz_pos = ff_zigzag_direct[pos];
275 block[zz_pos] = val * quant_mat[zz_pos];
279 return pos == 64 ? 0 : -1;
282 static int mss4_decode_dct_block(MSS4Context *c, GetBitContext *gb,
283 uint8_t *dst[3], int mb_x, int mb_y)
286 uint8_t *out = dst[0];
288 for (j = 0; j < 2; j++) {
289 for (i = 0; i < 2; i++) {
290 int xpos = mb_x * 2 + i;
291 c->dc_cache[j][TOP_LEFT] = c->dc_cache[j][TOP];
292 c->dc_cache[j][TOP] = c->prev_dc[0][mb_x * 2 + i];
293 ret = mss4_decode_dct(gb, c->dc_vlc, c->ac_vlc, c->block,
295 xpos, mb_y * 2 + j, c->quant_mat[0]);
298 c->prev_dc[0][mb_x * 2 + i] = c->dc_cache[j][LEFT];
300 ff_mss34_dct_put(out + xpos * 8, c->pic->linesize[0],
303 out += 8 * c->pic->linesize[0];
306 for (i = 1; i < 3; i++) {
307 c->dc_cache[i + 1][TOP_LEFT] = c->dc_cache[i + 1][TOP];
308 c->dc_cache[i + 1][TOP] = c->prev_dc[i][mb_x];
309 ret = mss4_decode_dct(gb, c->dc_vlc + 1, c->ac_vlc + 1,
310 c->block, c->dc_cache[i + 1], mb_x, mb_y,
314 c->prev_dc[i][mb_x] = c->dc_cache[i + 1][LEFT];
316 ff_mss34_dct_put(c->imgbuf[i], 8, c->block);
317 out = dst[i] + mb_x * 16;
318 // Since the DCT block is coded as YUV420 and the whole frame as YUV444,
319 // we need to scale chroma.
320 for (j = 0; j < 16; j++) {
321 for (k = 0; k < 8; k++)
322 AV_WN16A(out + k * 2, c->imgbuf[i][k + (j & ~1) * 4] * 0x101);
323 out += c->pic->linesize[i];
330 static void read_vec_pos(GetBitContext *gb, int *vec_pos, int *sel_flag,
331 int *sel_len, int *prev)
335 for (i = 2; i >= 0; i--) {
340 if ((!i && !y_flag) || get_bits1(gb)) {
341 if (sel_len[i] > 0) {
343 vec_pos[i] = get_bits(gb, sel_len[i]);
344 if (vec_pos[i] >= pval)
347 vec_pos[i] = !prev[i];
351 vec_pos[i] = prev[i];
356 static int get_value_cached(GetBitContext *gb, int vec_pos, uint8_t *vec,
357 int vec_size, int component, int shift, int *prev)
359 if (vec_pos < vec_size)
362 return prev[component];
363 prev[component] = get_bits(gb, 8 - shift) << shift;
364 return prev[component];
367 #define MKVAL(vals) (vals[0] | (vals[1] << 3) | (vals[2] << 6))
369 /* Image mode - the hardest to comprehend MSS4 coding mode.
371 * In this mode all three 16x16 blocks are coded together with a method
372 * remotely similar to the methods employed in MSS1-MSS3.
373 * The idea is that every component has a vector of 1-4 most common symbols
374 * and an escape mode for reading new value from the bitstream. Decoding
375 * consists of retrieving pixel values from the vector or reading new ones
376 * from the bitstream; depending on flags read from the bitstream, these vector
377 * positions can be updated or reused from the state of the previous line
380 static int mss4_decode_image_block(MSS4Context *ctx, GetBitContext *gb,
381 uint8_t *picdst[3], int mb_x, int mb_y)
385 int sel_len[3], sel_flag[3];
386 int i, j, k, mode, split;
387 int prev_vec1 = 0, prev_split = 0;
389 int prev_pix[3] = { 0 };
390 int prev_mode[16] = { 0 };
393 const int val_shift = ctx->quality == 100 ? 0 : 2;
395 for (i = 0; i < 3; i++)
396 dst[i] = ctx->imgbuf[i];
398 for (i = 0; i < 3; i++) {
399 vec_len[i] = vec_len_syms[!!i][get_unary(gb, 0, 3)];
400 for (j = 0; j < vec_len[i]; j++) {
401 vec[i][j] = get_coeff(gb, &ctx->vec_entry_vlc[!!i]);
402 vec[i][j] += ctx->prev_vec[i][j];
403 ctx->prev_vec[i][j] = vec[i][j];
405 sel_flag[i] = vec_len[i] > 1;
406 sel_len[i] = vec_len[i] > 2 ? vec_len[i] - 2 : 0;
409 for (j = 0; j < 16; j++) {
414 vals[0] = vals[1] = vals[2] = 0;
417 mode = get_bits1(gb);
419 split = get_bits(gb, 4);
421 for (i = 0; i < 16; i++) {
423 vals[0] = prev_mode[i] & 7;
424 vals[1] = (prev_mode[i] >> 3) & 7;
425 vals[2] = prev_mode[i] >> 6;
426 if (mode == 1 && i == split) {
427 read_vec_pos(gb, vals, sel_flag, sel_len, vals);
429 } else if (mode == 2) {
431 read_vec_pos(gb, vals, sel_flag, sel_len, vals);
433 for (k = 0; k < 3; k++)
434 *dst[k]++ = get_value_cached(gb, vals[k], vec[k],
436 val_shift, prev_pix);
437 prev_mode[i] = MKVAL(vals);
441 split = get_bits(gb, 4);
442 if (split >= prev_split)
449 vals[0] = prev_mode[0] & 7;
450 vals[1] = (prev_mode[0] >> 3) & 7;
451 vals[2] = prev_mode[0] >> 6;
452 for (i = 0; i < 3; i++) {
453 for (k = 0; k < split; k++) {
454 *dst[i]++ = get_value_cached(gb, vals[i], vec[i],
455 vec_len[i], i, val_shift,
457 prev_mode[k] = MKVAL(vals);
463 vals[0] = prev_vec1 & 7;
464 vals[1] = (prev_vec1 >> 3) & 7;
465 vals[2] = prev_vec1 >> 6;
467 read_vec_pos(gb, vals, sel_flag, sel_len, vals);
468 prev_vec1 = MKVAL(vals);
470 for (i = 0; i < 3; i++) {
471 for (k = 0; k < 16 - split; k++) {
472 *dst[i]++ = get_value_cached(gb, vals[i], vec[i],
473 vec_len[i], i, val_shift,
475 prev_mode[split + k] = MKVAL(vals);
482 for (i = 0; i < 3; i++)
483 for (j = 0; j < 16; j++)
484 memcpy(picdst[i] + mb_x * 16 + j * ctx->pic->linesize[i],
485 ctx->imgbuf[i] + j * 16, 16);
490 static inline void mss4_update_dc_cache(MSS4Context *c, int mb_x)
494 c->dc_cache[0][TOP] = c->prev_dc[0][mb_x * 2 + 1];
495 c->dc_cache[0][LEFT] = 0;
496 c->dc_cache[1][TOP] = 0;
497 c->dc_cache[1][LEFT] = 0;
499 for (i = 0; i < 2; i++)
500 c->prev_dc[0][mb_x * 2 + i] = 0;
502 for (i = 1; i < 3; i++) {
503 c->dc_cache[i + 1][TOP] = c->prev_dc[i][mb_x];
504 c->dc_cache[i + 1][LEFT] = 0;
505 c->prev_dc[i][mb_x] = 0;
509 static int mss4_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
512 const uint8_t *buf = avpkt->data;
513 int buf_size = avpkt->size;
514 MSS4Context *c = avctx->priv_data;
518 int width, height, quality, frame_type;
519 int x, y, i, mb_width, mb_height, blk_type;
522 if (buf_size < HEADER_SIZE) {
523 av_log(avctx, AV_LOG_ERROR,
524 "Frame should have at least %d bytes, got %d instead\n",
525 HEADER_SIZE, buf_size);
526 return AVERROR_INVALIDDATA;
529 bytestream2_init(&bc, buf, buf_size);
530 width = bytestream2_get_be16(&bc);
531 height = bytestream2_get_be16(&bc);
532 bytestream2_skip(&bc, 2);
533 quality = bytestream2_get_byte(&bc);
534 frame_type = bytestream2_get_byte(&bc);
536 if (width > avctx->width ||
537 height != avctx->height) {
538 av_log(avctx, AV_LOG_ERROR, "Invalid frame dimensions %dx%d\n",
540 return AVERROR_INVALIDDATA;
542 if (quality < 1 || quality > 100) {
543 av_log(avctx, AV_LOG_ERROR, "Invalid quality setting %d\n", quality);
544 return AVERROR_INVALIDDATA;
546 if ((frame_type & ~3) || frame_type == 3) {
547 av_log(avctx, AV_LOG_ERROR, "Invalid frame type %d\n", frame_type);
548 return AVERROR_INVALIDDATA;
551 if (frame_type != SKIP_FRAME && !bytestream2_get_bytes_left(&bc)) {
552 av_log(avctx, AV_LOG_ERROR,
553 "Empty frame found but it is not a skip frame.\n");
554 return AVERROR_INVALIDDATA;
557 if ((ret = ff_reget_buffer(avctx, c->pic)) < 0)
559 c->pic->key_frame = (frame_type == INTRA_FRAME);
560 c->pic->pict_type = (frame_type == INTRA_FRAME) ? AV_PICTURE_TYPE_I
562 if (frame_type == SKIP_FRAME) {
564 if ((ret = av_frame_ref(data, c->pic)) < 0)
570 if (c->quality != quality) {
571 c->quality = quality;
572 for (i = 0; i < 2; i++)
573 ff_mss34_gen_quant_mat(c->quant_mat[i], quality, !i);
576 init_get_bits8(&gb, buf + HEADER_SIZE, (buf_size - HEADER_SIZE));
578 mb_width = FFALIGN(width, 16) >> 4;
579 mb_height = FFALIGN(height, 16) >> 4;
580 dst[0] = c->pic->data[0];
581 dst[1] = c->pic->data[1];
582 dst[2] = c->pic->data[2];
584 memset(c->prev_vec, 0, sizeof(c->prev_vec));
585 for (y = 0; y < mb_height; y++) {
586 memset(c->dc_cache, 0, sizeof(c->dc_cache));
587 for (x = 0; x < mb_width; x++) {
588 blk_type = decode012(&gb);
591 if (mss4_decode_dct_block(c, &gb, dst, x, y) < 0) {
592 av_log(avctx, AV_LOG_ERROR,
593 "Error decoding DCT block %d,%d\n",
595 return AVERROR_INVALIDDATA;
599 if (mss4_decode_image_block(c, &gb, dst, x, y) < 0) {
600 av_log(avctx, AV_LOG_ERROR,
601 "Error decoding VQ block %d,%d\n",
603 return AVERROR_INVALIDDATA;
607 if (frame_type == INTRA_FRAME) {
608 av_log(avctx, AV_LOG_ERROR, "Skip block in intra frame\n");
609 return AVERROR_INVALIDDATA;
613 if (blk_type != DCT_BLOCK)
614 mss4_update_dc_cache(c, x);
616 dst[0] += c->pic->linesize[0] * 16;
617 dst[1] += c->pic->linesize[1] * 16;
618 dst[2] += c->pic->linesize[2] * 16;
621 if ((ret = av_frame_ref(data, c->pic)) < 0)
629 static av_cold int mss4_decode_end(AVCodecContext *avctx)
631 MSS4Context * const c = avctx->priv_data;
634 av_frame_free(&c->pic);
635 for (i = 0; i < 3; i++)
636 av_freep(&c->prev_dc[i]);
642 static av_cold int mss4_decode_init(AVCodecContext *avctx)
644 MSS4Context * const c = avctx->priv_data;
647 if (mss4_init_vlcs(c)) {
648 av_log(avctx, AV_LOG_ERROR, "Cannot initialise VLCs\n");
650 return AVERROR(ENOMEM);
652 for (i = 0; i < 3; i++) {
653 c->dc_stride[i] = FFALIGN(avctx->width, 16) >> (2 + !!i);
654 c->prev_dc[i] = av_malloc(sizeof(**c->prev_dc) * c->dc_stride[i]);
655 if (!c->prev_dc[i]) {
656 av_log(avctx, AV_LOG_ERROR, "Cannot allocate buffer\n");
658 return AVERROR(ENOMEM);
662 c->pic = av_frame_alloc();
664 mss4_decode_end(avctx);
665 return AVERROR(ENOMEM);
668 avctx->pix_fmt = AV_PIX_FMT_YUV444P;
673 AVCodec ff_mts2_decoder = {
675 .long_name = NULL_IF_CONFIG_SMALL("MS Expression Encoder Screen"),
676 .type = AVMEDIA_TYPE_VIDEO,
677 .id = AV_CODEC_ID_MTS2,
678 .priv_data_size = sizeof(MSS4Context),
679 .init = mss4_decode_init,
680 .close = mss4_decode_end,
681 .decode = mss4_decode_frame,
682 .capabilities = CODEC_CAP_DR1,