src/third_party/ffmpeg/libavcodec/mss4.c

   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 "avcodec.h"
  29 #include "bytestream.h"
  30 #include "get_bits.h"
  31 #include "internal.h"
  32 #include "mss34dsp.h"
  33 #include "unary.h"
  34
  35 #define HEADER_SIZE 8
  36
  37 enum FrameType {
  38     INTRA_FRAME = 0,
  39     INTER_FRAME,
  40     SKIP_FRAME
  41 };
  42
  43 enum BlockType {
  44     SKIP_BLOCK = 0,
  45     DCT_BLOCK,
  46     IMAGE_BLOCK,
  47 };
  48
  49 enum CachePos {
  50     LEFT = 0,
  51     TOP_LEFT,
  52     TOP,
  53 };
  54
  55 static const uint8_t mss4_dc_vlc_lens[2][16] = {
  56     { 0, 1, 5, 1, 1, 1, 1, 2, 0, 0, 0, 0, 0, 0, 0, 0 },
  57     { 0, 3, 1, 1, 1, 1, 1, 1, 1, 2, 0, 0, 0, 0, 0, 0 }
  58 };
  59
  60 static const uint8_t mss4_ac_vlc_lens[2][16] = {
  61     { 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 125 },
  62     { 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 119 }
  63 };
  64
  65 static const uint8_t mss4_ac_vlc_syms[2][162] = {
  66   { 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12,
  67     0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07,
  68     0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xA1, 0x08,
  69     0x23, 0x42, 0xB1, 0xC1, 0x15, 0x52, 0xD1, 0xF0,
  70     0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0A, 0x16,
  71     0x17, 0x18, 0x19, 0x1A, 0x25, 0x26, 0x27, 0x28,
  72     0x29, 0x2A, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
  73     0x3A, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
  74     0x4A, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
  75     0x5A, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
  76     0x6A, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
  77     0x7A, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
  78     0x8A, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98,
  79     0x99, 0x9A, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7,
  80     0xA8, 0xA9, 0xAA, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6,
  81     0xB7, 0xB8, 0xB9, 0xBA, 0xC2, 0xC3, 0xC4, 0xC5,
  82     0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xD2, 0xD3, 0xD4,
  83     0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xE1, 0xE2,
  84     0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA,
  85     0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8,
  86     0xF9, 0xFA  },
  87   { 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21,
  88     0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
  89     0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91,
  90     0xA1, 0xB1, 0xC1, 0x09, 0x23, 0x33, 0x52, 0xF0,
  91     0x15, 0x62, 0x72, 0xD1, 0x0A, 0x16, 0x24, 0x34,
  92     0xE1, 0x25, 0xF1, 0x17, 0x18, 0x19, 0x1A, 0x26,
  93     0x27, 0x28, 0x29, 0x2A, 0x35, 0x36, 0x37, 0x38,
  94     0x39, 0x3A, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
  95     0x49, 0x4A, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
  96     0x59, 0x5A, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
  97     0x69, 0x6A, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
  98     0x79, 0x7A, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
  99     0x88, 0x89, 0x8A, 0x92, 0x93, 0x94, 0x95, 0x96,
 100     0x97, 0x98, 0x99, 0x9A, 0xA2, 0xA3, 0xA4, 0xA5,
 101     0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xB2, 0xB3, 0xB4,
 102     0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xC2, 0xC3,
 103     0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xD2,
 104     0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA,
 105     0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9,
 106     0xEA, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8,
 107     0xF9, 0xFA  }
 108 };
 109
 110 static const uint8_t vec_len_syms[2][4] = {
 111     { 4, 2, 3, 1 },
 112     { 4, 1, 2, 3 }
 113 };
 114
 115 static const uint8_t mss4_vec_entry_vlc_lens[2][16] = {
 116     { 0, 2, 2, 3, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
 117     { 0, 1, 5, 1, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
 118 };
 119
 120 static const uint8_t mss4_vec_entry_vlc_syms[2][9] = {
 121     { 0, 7, 6, 5, 8, 4, 3, 1, 2 },
 122     { 0, 2, 3, 4, 5, 6, 7, 1, 8 }
 123 };
 124
 125 #define MAX_ENTRIES  162
 126
 127 typedef struct MSS4Context {
 128     AVFrame    *pic;
 129
 130     VLC        dc_vlc[2], ac_vlc[2];
 131     VLC        vec_entry_vlc[2];
 132     int        block[64];
 133     uint8_t    imgbuf[3][16 * 16];
 134
 135     int        quality;
 136     uint16_t   quant_mat[2][64];
 137
 138     int        *prev_dc[3];
 139     int        dc_stride[3];
 140     int        dc_cache[4][4];
 141
 142     int        prev_vec[3][4];
 143 } MSS4Context;
 144
 145 static av_cold int mss4_init_vlc(VLC *vlc, const uint8_t *lens,
 146                                  const uint8_t *syms, int num_syms)
 147 {
 148     uint8_t  bits[MAX_ENTRIES];
 149     uint16_t codes[MAX_ENTRIES];
 150     int i, j;
 151     int prefix = 0, max_bits = 0, idx = 0;
 152
 153     for (i = 0; i < 16; i++) {
 154         for (j = 0; j < lens[i]; j++) {
 155             bits[idx]  = i + 1;
 156             codes[idx] = prefix++;
 157             max_bits   = i + 1;
 158             idx++;
 159         }
 160         prefix <<= 1;
 161     }
 162
 163     return ff_init_vlc_sparse(vlc, FFMIN(max_bits, 9), num_syms, bits, 1, 1,
 164                               codes, 2, 2, syms, 1, 1, 0);
 165 }
 166
 167 static av_cold int mss4_init_vlcs(MSS4Context *ctx)
 168 {
 169     int ret, i;
 170
 171     for (i = 0; i < 2; i++) {
 172         ret = mss4_init_vlc(&ctx->dc_vlc[i], mss4_dc_vlc_lens[i], NULL, 12);
 173         if (ret)
 174             return ret;
 175         ret = mss4_init_vlc(&ctx->ac_vlc[i], mss4_ac_vlc_lens[i],
 176                             mss4_ac_vlc_syms[i], 162);
 177         if (ret)
 178             return ret;
 179         ret = mss4_init_vlc(&ctx->vec_entry_vlc[i], mss4_vec_entry_vlc_lens[i],
 180                             mss4_vec_entry_vlc_syms[i], 9);
 181         if (ret)
 182             return ret;
 183     }
 184     return 0;
 185 }
 186
 187 static av_cold void mss4_free_vlcs(MSS4Context *ctx)
 188 {
 189     int i;
 190
 191     for (i = 0; i < 2; i++) {
 192         ff_free_vlc(&ctx->dc_vlc[i]);
 193         ff_free_vlc(&ctx->ac_vlc[i]);
 194         ff_free_vlc(&ctx->vec_entry_vlc[i]);
 195     }
 196 }
 197
 198 /* This function returns values in the range
 199  * (-range + 1; -range/2] U [range/2; range - 1)
 200  * i.e.
 201  * nbits = 0 -> 0
 202  * nbits = 1 -> -1, 1
 203  * nbits = 2 -> -3, -2, 2, 3
 204  */
 205 static av_always_inline int get_coeff_bits(GetBitContext *gb, int nbits)
 206 {
 207     int val;
 208
 209     if (!nbits)
 210         return 0;
 211
 212     val = get_bits(gb, nbits);
 213     if (val < (1 << (nbits - 1)))
 214         val -= (1 << nbits) - 1;
 215
 216     return val;
 217 }
 218
 219 static inline int get_coeff(GetBitContext *gb, VLC *vlc)
 220 {
 221     int val = get_vlc2(gb, vlc->table, vlc->bits, 2);
 222
 223     return get_coeff_bits(gb, val);
 224 }
 225
 226 static int mss4_decode_dct(GetBitContext *gb, VLC *dc_vlc, VLC *ac_vlc,
 227                            int *block, int *dc_cache,
 228                            int bx, int by, uint16_t *quant_mat)
 229 {
 230     int skip, val, pos = 1, zz_pos, dc;
 231
 232     memset(block, 0, sizeof(*block) * 64);
 233
 234     dc = get_coeff(gb, dc_vlc);
 235     // DC prediction is the same as in MSS3
 236     if (by) {
 237         if (bx) {
 238             int l, tl, t;
 239
 240             l  = dc_cache[LEFT];
 241             tl = dc_cache[TOP_LEFT];
 242             t  = dc_cache[TOP];
 243
 244             if (FFABS(t - tl) <= FFABS(l - tl))
 245                 dc += l;
 246             else
 247                 dc += t;
 248         } else {
 249             dc += dc_cache[TOP];
 250         }
 251     } else if (bx) {
 252         dc += dc_cache[LEFT];
 253     }
 254     dc_cache[LEFT] = dc;
 255     block[0]       = dc * quant_mat[0];
 256
 257     while (pos < 64) {
 258         val = get_vlc2(gb, ac_vlc->table, 9, 2);
 259         if (!val)
 260             return 0;
 261         if (val == -1)
 262             return -1;
 263         if (val == 0xF0) {
 264             pos += 16;
 265             continue;
 266         }
 267         skip = val >> 4;
 268         val  = get_coeff_bits(gb, val & 0xF);
 269         pos += skip;
 270         if (pos >= 64)
 271             return -1;
 272
 273         zz_pos = ff_zigzag_direct[pos];
 274         block[zz_pos] = val * quant_mat[zz_pos];
 275         pos++;
 276     }
 277
 278     return pos == 64 ? 0 : -1;
 279 }
 280
 281 static int mss4_decode_dct_block(MSS4Context *c, GetBitContext *gb,
 282                                  uint8_t *dst[3], int mb_x, int mb_y)
 283 {
 284     int i, j, k, ret;
 285     uint8_t *out = dst[0];
 286
 287     for (j = 0; j < 2; j++) {
 288         for (i = 0; i < 2; i++) {
 289             int xpos = mb_x * 2 + i;
 290             c->dc_cache[j][TOP_LEFT] = c->dc_cache[j][TOP];
 291             c->dc_cache[j][TOP]      = c->prev_dc[0][mb_x * 2 + i];
 292             ret = mss4_decode_dct(gb, c->dc_vlc, c->ac_vlc, c->block,
 293                                   c->dc_cache[j],
 294                                   xpos, mb_y * 2 + j, c->quant_mat[0]);
 295             if (ret)
 296                 return ret;
 297             c->prev_dc[0][mb_x * 2 + i] = c->dc_cache[j][LEFT];
 298
 299             ff_mss34_dct_put(out + xpos * 8, c->pic->linesize[0],
 300                              c->block);
 301         }
 302         out += 8 * c->pic->linesize[0];
 303     }
 304
 305     for (i = 1; i < 3; i++) {
 306         c->dc_cache[i + 1][TOP_LEFT] = c->dc_cache[i + 1][TOP];
 307         c->dc_cache[i + 1][TOP]      = c->prev_dc[i][mb_x];
 308         ret = mss4_decode_dct(gb, c->dc_vlc + 1, c->ac_vlc + 1,
 309                               c->block, c->dc_cache[i + 1], mb_x, mb_y,
 310                               c->quant_mat[1]);
 311         if (ret)
 312             return ret;
 313         c->prev_dc[i][mb_x] = c->dc_cache[i + 1][LEFT];
 314
 315         ff_mss34_dct_put(c->imgbuf[i], 8, c->block);
 316         out = dst[i] + mb_x * 16;
 317         // Since the DCT block is coded as YUV420 and the whole frame as YUV444,
 318         // we need to scale chroma.
 319         for (j = 0; j < 16; j++) {
 320             for (k = 0; k < 8; k++)
 321                 AV_WN16A(out + k * 2, c->imgbuf[i][k + (j & ~1) * 4] * 0x101);
 322             out += c->pic->linesize[i];
 323         }
 324     }
 325
 326     return 0;
 327 }
 328
 329 static void read_vec_pos(GetBitContext *gb, int *vec_pos, int *sel_flag,
 330                          int *sel_len, int *prev)
 331 {
 332     int i, y_flag = 0;
 333
 334     for (i = 2; i >= 0; i--) {
 335         if (!sel_flag[i]) {
 336             vec_pos[i] = 0;
 337             continue;
 338         }
 339         if ((!i && !y_flag) || get_bits1(gb)) {
 340             if (sel_len[i] > 0) {
 341                 int pval = prev[i];
 342                 vec_pos[i] = get_bits(gb, sel_len[i]);
 343                 if (vec_pos[i] >= pval)
 344                     vec_pos[i]++;
 345             } else {
 346                 vec_pos[i] = !prev[i];
 347             }
 348             y_flag = 1;
 349         } else {
 350             vec_pos[i] = prev[i];
 351         }
 352     }
 353 }
 354
 355 static int get_value_cached(GetBitContext *gb, int vec_pos, uint8_t *vec,
 356                             int vec_size, int component, int shift, int *prev)
 357 {
 358     if (vec_pos < vec_size)
 359         return vec[vec_pos];
 360     if (!get_bits1(gb))
 361         return prev[component];
 362     prev[component] = get_bits(gb, 8 - shift) << shift;
 363     return prev[component];
 364 }
 365
 366 #define MKVAL(vals)  (vals[0] | (vals[1] << 3) | (vals[2] << 6))
 367
 368 /* Image mode - the hardest to comprehend MSS4 coding mode.
 369  *
 370  * In this mode all three 16x16 blocks are coded together with a method
 371  * remotely similar to the methods employed in MSS1-MSS3.
 372  * The idea is that every component has a vector of 1-4 most common symbols
 373  * and an escape mode for reading new value from the bitstream. Decoding
 374  * consists of retrieving pixel values from the vector or reading new ones
 375  * from the bitstream; depending on flags read from the bitstream, these vector
 376  * positions can be updated or reused from the state of the previous line
 377  * or previous pixel.
 378  */
 379 static int mss4_decode_image_block(MSS4Context *ctx, GetBitContext *gb,
 380                                    uint8_t *picdst[3], int mb_x, int mb_y)
 381 {
 382     uint8_t vec[3][4];
 383     int     vec_len[3];
 384     int     sel_len[3], sel_flag[3];
 385     int     i, j, k, mode, split;
 386     int     prev_vec1 = 0, prev_split = 0;
 387     int     vals[3] = { 0 };
 388     int     prev_pix[3] = { 0 };
 389     int     prev_mode[16] = { 0 };
 390     uint8_t *dst[3];
 391
 392     const int val_shift = ctx->quality == 100 ? 0 : 2;
 393
 394     for (i = 0; i < 3; i++)
 395         dst[i] = ctx->imgbuf[i];
 396
 397     for (i = 0; i < 3; i++) {
 398         vec_len[i] = vec_len_syms[!!i][get_unary(gb, 0, 3)];
 399         for (j = 0; j < vec_len[i]; j++) {
 400             vec[i][j]  = get_coeff(gb, &ctx->vec_entry_vlc[!!i]);
 401             vec[i][j] += ctx->prev_vec[i][j];
 402             ctx->prev_vec[i][j] = vec[i][j];
 403         }
 404         sel_flag[i] = vec_len[i] > 1;
 405         sel_len[i]  = vec_len[i] > 2 ? vec_len[i] - 2 : 0;
 406     }
 407
 408     for (j = 0; j < 16; j++) {
 409         if (get_bits1(gb)) {
 410             split = 0;
 411             if (get_bits1(gb)) {
 412                 prev_mode[0] = 0;
 413                 vals[0] = vals[1] = vals[2] = 0;
 414                 mode = 2;
 415             } else {
 416                 mode = get_bits1(gb);
 417                 if (mode)
 418                     split = get_bits(gb, 4);
 419             }
 420             for (i = 0; i < 16; i++) {
 421                 if (mode <= 1) {
 422                     vals[0] =  prev_mode[i]       & 7;
 423                     vals[1] = (prev_mode[i] >> 3) & 7;
 424                     vals[2] =  prev_mode[i] >> 6;
 425                     if (mode == 1 && i == split) {
 426                         read_vec_pos(gb, vals, sel_flag, sel_len, vals);
 427                     }
 428                 } else if (mode == 2) {
 429                     if (get_bits1(gb))
 430                         read_vec_pos(gb, vals, sel_flag, sel_len, vals);
 431                 }
 432                 for (k = 0; k < 3; k++)
 433                     *dst[k]++ = get_value_cached(gb, vals[k], vec[k],
 434                                                  vec_len[k], k,
 435                                                  val_shift, prev_pix);
 436                 prev_mode[i] = MKVAL(vals);
 437             }
 438         } else {
 439             if (get_bits1(gb)) {
 440                 split = get_bits(gb, 4);
 441                 if (split >= prev_split)
 442                     split++;
 443                 prev_split = split;
 444             } else {
 445                 split = prev_split;
 446             }
 447             if (split) {
 448                 vals[0] =  prev_mode[0]       & 7;
 449                 vals[1] = (prev_mode[0] >> 3) & 7;
 450                 vals[2] =  prev_mode[0] >> 6;
 451                 for (i = 0; i < 3; i++) {
 452                     for (k = 0; k < split; k++) {
 453                         *dst[i]++ = get_value_cached(gb, vals[i], vec[i],
 454                                                      vec_len[i], i, val_shift,
 455                                                      prev_pix);
 456                         prev_mode[k] = MKVAL(vals);
 457                     }
 458                 }
 459             }
 460
 461             if (split != 16) {
 462                 vals[0] =  prev_vec1       & 7;
 463                 vals[1] = (prev_vec1 >> 3) & 7;
 464                 vals[2] =  prev_vec1 >> 6;
 465                 if (get_bits1(gb)) {
 466                     read_vec_pos(gb, vals, sel_flag, sel_len, vals);
 467                     prev_vec1 = MKVAL(vals);
 468                 }
 469                 for (i = 0; i < 3; i++) {
 470                     for (k = 0; k < 16 - split; k++) {
 471                         *dst[i]++ = get_value_cached(gb, vals[i], vec[i],
 472                                                      vec_len[i], i, val_shift,
 473                                                      prev_pix);
 474                         prev_mode[split + k] = MKVAL(vals);
 475                     }
 476                 }
 477             }
 478         }
 479     }
 480
 481     for (i = 0; i < 3; i++)
 482         for (j = 0; j < 16; j++)
 483             memcpy(picdst[i] + mb_x * 16 + j * ctx->pic->linesize[i],
 484                    ctx->imgbuf[i] + j * 16, 16);
 485
 486     return 0;
 487 }
 488
 489 static inline void mss4_update_dc_cache(MSS4Context *c, int mb_x)
 490 {
 491     int i;
 492
 493     c->dc_cache[0][TOP]  = c->prev_dc[0][mb_x * 2 + 1];
 494     c->dc_cache[0][LEFT] = 0;
 495     c->dc_cache[1][TOP]  = 0;
 496     c->dc_cache[1][LEFT] = 0;
 497
 498     for (i = 0; i < 2; i++)
 499         c->prev_dc[0][mb_x * 2 + i] = 0;
 500
 501     for (i = 1; i < 3; i++) {
 502         c->dc_cache[i + 1][TOP]  = c->prev_dc[i][mb_x];
 503         c->dc_cache[i + 1][LEFT] = 0;
 504         c->prev_dc[i][mb_x]      = 0;
 505     }
 506 }
 507
 508 static int mss4_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
 509                              AVPacket *avpkt)
 510 {
 511     const uint8_t *buf = avpkt->data;
 512     int buf_size = avpkt->size;
 513     MSS4Context *c = avctx->priv_data;
 514     GetBitContext gb;
 515     GetByteContext bc;
 516     uint8_t *dst[3];
 517     int width, height, quality, frame_type;
 518     int x, y, i, mb_width, mb_height, blk_type;
 519     int ret;
 520
 521     if (buf_size < HEADER_SIZE) {
 522         av_log(avctx, AV_LOG_ERROR,
 523                "Frame should have at least %d bytes, got %d instead\n",
 524                HEADER_SIZE, buf_size);
 525         return AVERROR_INVALIDDATA;
 526     }
 527
 528     bytestream2_init(&bc, buf, buf_size);
 529     width      = bytestream2_get_be16(&bc);
 530     height     = bytestream2_get_be16(&bc);
 531     bytestream2_skip(&bc, 2);
 532     quality    = bytestream2_get_byte(&bc);
 533     frame_type = bytestream2_get_byte(&bc);
 534
 535     if (width > avctx->width ||
 536         height != avctx->height) {
 537         av_log(avctx, AV_LOG_ERROR, "Invalid frame dimensions %dx%d\n",
 538                width, height);
 539         return AVERROR_INVALIDDATA;
 540     }
 541     if (quality < 1 || quality > 100) {
 542         av_log(avctx, AV_LOG_ERROR, "Invalid quality setting %d\n", quality);
 543         return AVERROR_INVALIDDATA;
 544     }
 545     if ((frame_type & ~3) || frame_type == 3) {
 546         av_log(avctx, AV_LOG_ERROR, "Invalid frame type %d\n", frame_type);
 547         return AVERROR_INVALIDDATA;
 548     }
 549
 550     if (frame_type != SKIP_FRAME && !bytestream2_get_bytes_left(&bc)) {
 551         av_log(avctx, AV_LOG_ERROR,
 552                "Empty frame found but it is not a skip frame.\n");
 553         return AVERROR_INVALIDDATA;
 554     }
 555
 556     if ((ret = ff_reget_buffer(avctx, c->pic)) < 0)
 557         return ret;
 558     c->pic->key_frame = (frame_type == INTRA_FRAME);
 559     c->pic->pict_type = (frame_type == INTRA_FRAME) ? AV_PICTURE_TYPE_I
 560                                                    : AV_PICTURE_TYPE_P;
 561     if (frame_type == SKIP_FRAME) {
 562         *got_frame      = 1;
 563         if ((ret = av_frame_ref(data, c->pic)) < 0)
 564             return ret;
 565
 566         return buf_size;
 567     }
 568
 569     if (c->quality != quality) {
 570         c->quality = quality;
 571         for (i = 0; i < 2; i++)
 572             ff_mss34_gen_quant_mat(c->quant_mat[i], quality, !i);
 573     }
 574
 575     init_get_bits8(&gb, buf + HEADER_SIZE, (buf_size - HEADER_SIZE));
 576
 577     mb_width  = FFALIGN(width,  16) >> 4;
 578     mb_height = FFALIGN(height, 16) >> 4;
 579     dst[0] = c->pic->data[0];
 580     dst[1] = c->pic->data[1];
 581     dst[2] = c->pic->data[2];
 582
 583     memset(c->prev_vec, 0, sizeof(c->prev_vec));
 584     for (y = 0; y < mb_height; y++) {
 585         memset(c->dc_cache, 0, sizeof(c->dc_cache));
 586         for (x = 0; x < mb_width; x++) {
 587             blk_type = decode012(&gb);
 588             switch (blk_type) {
 589             case DCT_BLOCK:
 590                 if (mss4_decode_dct_block(c, &gb, dst, x, y) < 0) {
 591                     av_log(avctx, AV_LOG_ERROR,
 592                            "Error decoding DCT block %d,%d\n",
 593                            x, y);
 594                     return AVERROR_INVALIDDATA;
 595                 }
 596                 break;
 597             case IMAGE_BLOCK:
 598                 if (mss4_decode_image_block(c, &gb, dst, x, y) < 0) {
 599                     av_log(avctx, AV_LOG_ERROR,
 600                            "Error decoding VQ block %d,%d\n",
 601                            x, y);
 602                     return AVERROR_INVALIDDATA;
 603                 }
 604                 break;
 605             case SKIP_BLOCK:
 606                 if (frame_type == INTRA_FRAME) {
 607                     av_log(avctx, AV_LOG_ERROR, "Skip block in intra frame\n");
 608                     return AVERROR_INVALIDDATA;
 609                 }
 610                 break;
 611             }
 612             if (blk_type != DCT_BLOCK)
 613                 mss4_update_dc_cache(c, x);
 614         }
 615         dst[0] += c->pic->linesize[0] * 16;
 616         dst[1] += c->pic->linesize[1] * 16;
 617         dst[2] += c->pic->linesize[2] * 16;
 618     }
 619
 620     if ((ret = av_frame_ref(data, c->pic)) < 0)
 621         return ret;
 622
 623     *got_frame      = 1;
 624
 625     return buf_size;
 626 }
 627
 628 static av_cold int mss4_decode_end(AVCodecContext *avctx)
 629 {
 630     MSS4Context * const c = avctx->priv_data;
 631     int i;
 632
 633     av_frame_free(&c->pic);
 634     for (i = 0; i < 3; i++)
 635         av_freep(&c->prev_dc[i]);
 636     mss4_free_vlcs(c);
 637
 638     return 0;
 639 }
 640
 641 static av_cold int mss4_decode_init(AVCodecContext *avctx)
 642 {
 643     MSS4Context * const c = avctx->priv_data;
 644     int i;
 645
 646     if (mss4_init_vlcs(c)) {
 647         av_log(avctx, AV_LOG_ERROR, "Cannot initialise VLCs\n");
 648         mss4_free_vlcs(c);
 649         return AVERROR(ENOMEM);
 650     }
 651     for (i = 0; i < 3; i++) {
 652         c->dc_stride[i] = FFALIGN(avctx->width, 16) >> (2 + !!i);
 653         c->prev_dc[i]   = av_malloc(sizeof(**c->prev_dc) * c->dc_stride[i]);
 654         if (!c->prev_dc[i]) {
 655             av_log(avctx, AV_LOG_ERROR, "Cannot allocate buffer\n");
 656             mss4_free_vlcs(c);
 657             return AVERROR(ENOMEM);
 658         }
 659     }
 660
 661     c->pic = av_frame_alloc();
 662     if (!c->pic) {
 663         mss4_decode_end(avctx);
 664         return AVERROR(ENOMEM);
 665     }
 666
 667     avctx->pix_fmt     = AV_PIX_FMT_YUV444P;
 668
 669     return 0;
 670 }
 671
 672 AVCodec ff_mts2_decoder = {
 673     .name           = "mts2",
 674     .long_name      = NULL_IF_CONFIG_SMALL("MS Expression Encoder Screen"),
 675     .type           = AVMEDIA_TYPE_VIDEO,
 676     .id             = AV_CODEC_ID_MTS2,
 677     .priv_data_size = sizeof(MSS4Context),
 678     .init           = mss4_decode_init,
 679     .close          = mss4_decode_end,
 680     .decode         = mss4_decode_frame,
 681     .capabilities   = CODEC_CAP_DR1,
 682 };