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