git.sesse.net Git - ffmpeg/blob - 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     ptrdiff_t  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)
 147 {
 148     uint8_t  bits[MAX_ENTRIES];
 149     int i, j;
 150     int idx = 0;
 151
 152     for (i = 0; i < 16; i++) {
 153         for (j = 0; j < lens[i]; j++) {
 154             bits[idx]  = i + 1;
 155             idx++;
 156         }
 157     }
 158
 159     return ff_init_vlc_from_lengths(vlc, FFMIN(bits[idx - 1], 9), idx,
 160                                     bits, 1, syms, 1, 1, 0, 0, NULL);
 161 }
 162
 163 static av_cold int mss4_init_vlcs(MSS4Context *ctx)
 164 {
 165     int ret, i;
 166
 167     for (i = 0; i < 2; i++) {
 168         ret = mss4_init_vlc(&ctx->dc_vlc[i], mss4_dc_vlc_lens[i], NULL);
 169         if (ret)
 170             return ret;
 171         ret = mss4_init_vlc(&ctx->ac_vlc[i], mss4_ac_vlc_lens[i],
 172                             mss4_ac_vlc_syms[i]);
 173         if (ret)
 174             return ret;
 175         ret = mss4_init_vlc(&ctx->vec_entry_vlc[i], mss4_vec_entry_vlc_lens[i],
 176                             mss4_vec_entry_vlc_syms[i]);
 177         if (ret)
 178             return ret;
 179     }
 180     return 0;
 181 }
 182
 183 static av_cold void mss4_free_vlcs(MSS4Context *ctx)
 184 {
 185     int i;
 186
 187     for (i = 0; i < 2; i++) {
 188         ff_free_vlc(&ctx->dc_vlc[i]);
 189         ff_free_vlc(&ctx->ac_vlc[i]);
 190         ff_free_vlc(&ctx->vec_entry_vlc[i]);
 191     }
 192 }
 193
 194 /* This function returns values in the range
 195  * (-range + 1; -range/2] U [range/2; range - 1)
 196  * i.e.
 197  * nbits = 0 -> 0
 198  * nbits = 1 -> -1, 1
 199  * nbits = 2 -> -3, -2, 2, 3
 200  */
 201 static av_always_inline int get_coeff_bits(GetBitContext *gb, int nbits)
 202 {
 203     int val;
 204
 205     if (!nbits)
 206         return 0;
 207
 208     val = get_bits(gb, nbits);
 209     if (val < (1 << (nbits - 1)))
 210         val -= (1 << nbits) - 1;
 211
 212     return val;
 213 }
 214
 215 static inline int get_coeff(GetBitContext *gb, VLC *vlc)
 216 {
 217     int val = get_vlc2(gb, vlc->table, vlc->bits, 2);
 218
 219     return get_coeff_bits(gb, val);
 220 }
 221
 222 static int mss4_decode_dct(GetBitContext *gb, VLC *dc_vlc, VLC *ac_vlc,
 223                            int *block, int *dc_cache,
 224                            int bx, int by, uint16_t *quant_mat)
 225 {
 226     int skip, val, pos = 1, zz_pos, dc;
 227
 228     memset(block, 0, sizeof(*block) * 64);
 229
 230     dc = get_coeff(gb, dc_vlc);
 231     // DC prediction is the same as in MSS3
 232     if (by) {
 233         if (bx) {
 234             int l, tl, t;
 235
 236             l  = dc_cache[LEFT];
 237             tl = dc_cache[TOP_LEFT];
 238             t  = dc_cache[TOP];
 239
 240             if (FFABS(t - tl) <= FFABS(l - tl))
 241                 dc += l;
 242             else
 243                 dc += t;
 244         } else {
 245             dc += dc_cache[TOP];
 246         }
 247     } else if (bx) {
 248         dc += dc_cache[LEFT];
 249     }
 250     dc_cache[LEFT] = dc;
 251     block[0]       = dc * quant_mat[0];
 252
 253     while (pos < 64) {
 254         val = get_vlc2(gb, ac_vlc->table, 9, 2);
 255         if (!val)
 256             return 0;
 257         if (val == -1)
 258             return -1;
 259         if (val == 0xF0) {
 260             pos += 16;
 261             continue;
 262         }
 263         skip = val >> 4;
 264         val  = get_coeff_bits(gb, val & 0xF);
 265         pos += skip;
 266         if (pos >= 64)
 267             return -1;
 268
 269         zz_pos = ff_zigzag_direct[pos];
 270         block[zz_pos] = val * quant_mat[zz_pos];
 271         pos++;
 272     }
 273
 274     return pos == 64 ? 0 : -1;
 275 }
 276
 277 static int mss4_decode_dct_block(MSS4Context *c, GetBitContext *gb,
 278                                  uint8_t *dst[3], int mb_x, int mb_y)
 279 {
 280     int i, j, k, ret;
 281     uint8_t *out = dst[0];
 282
 283     for (j = 0; j < 2; j++) {
 284         for (i = 0; i < 2; i++) {
 285             int xpos = mb_x * 2 + i;
 286             c->dc_cache[j][TOP_LEFT] = c->dc_cache[j][TOP];
 287             c->dc_cache[j][TOP]      = c->prev_dc[0][mb_x * 2 + i];
 288             ret = mss4_decode_dct(gb, c->dc_vlc, c->ac_vlc, c->block,
 289                                   c->dc_cache[j],
 290                                   xpos, mb_y * 2 + j, c->quant_mat[0]);
 291             if (ret)
 292                 return ret;
 293             c->prev_dc[0][mb_x * 2 + i] = c->dc_cache[j][LEFT];
 294
 295             ff_mss34_dct_put(out + xpos * 8, c->pic->linesize[0],
 296                              c->block);
 297         }
 298         out += 8 * c->pic->linesize[0];
 299     }
 300
 301     for (i = 1; i < 3; i++) {
 302         c->dc_cache[i + 1][TOP_LEFT] = c->dc_cache[i + 1][TOP];
 303         c->dc_cache[i + 1][TOP]      = c->prev_dc[i][mb_x];
 304         ret = mss4_decode_dct(gb, c->dc_vlc + 1, c->ac_vlc + 1,
 305                               c->block, c->dc_cache[i + 1], mb_x, mb_y,
 306                               c->quant_mat[1]);
 307         if (ret)
 308             return ret;
 309         c->prev_dc[i][mb_x] = c->dc_cache[i + 1][LEFT];
 310
 311         ff_mss34_dct_put(c->imgbuf[i], 8, c->block);
 312         out = dst[i] + mb_x * 16;
 313         // Since the DCT block is coded as YUV420 and the whole frame as YUV444,
 314         // we need to scale chroma.
 315         for (j = 0; j < 16; j++) {
 316             for (k = 0; k < 8; k++)
 317                 AV_WN16A(out + k * 2, c->imgbuf[i][k + (j & ~1) * 4] * 0x101);
 318             out += c->pic->linesize[i];
 319         }
 320     }
 321
 322     return 0;
 323 }
 324
 325 static void read_vec_pos(GetBitContext *gb, int *vec_pos, int *sel_flag,
 326                          int *sel_len, int *prev)
 327 {
 328     int i, y_flag = 0;
 329
 330     for (i = 2; i >= 0; i--) {
 331         if (!sel_flag[i]) {
 332             vec_pos[i] = 0;
 333             continue;
 334         }
 335         if ((!i && !y_flag) || get_bits1(gb)) {
 336             if (sel_len[i] > 0) {
 337                 int pval = prev[i];
 338                 vec_pos[i] = get_bits(gb, sel_len[i]);
 339                 if (vec_pos[i] >= pval)
 340                     vec_pos[i]++;
 341             } else {
 342                 vec_pos[i] = !prev[i];
 343             }
 344             y_flag = 1;
 345         } else {
 346             vec_pos[i] = prev[i];
 347         }
 348     }
 349 }
 350
 351 static int get_value_cached(GetBitContext *gb, int vec_pos, uint8_t *vec,
 352                             int vec_size, int component, int shift, int *prev)
 353 {
 354     if (vec_pos < vec_size)
 355         return vec[vec_pos];
 356     if (!get_bits1(gb))
 357         return prev[component];
 358     prev[component] = get_bits(gb, 8 - shift) << shift;
 359     return prev[component];
 360 }
 361
 362 #define MKVAL(vals)  ((vals)[0] | ((vals)[1] << 3) | ((vals)[2] << 6))
 363
 364 /* Image mode - the hardest to comprehend MSS4 coding mode.
 365  *
 366  * In this mode all three 16x16 blocks are coded together with a method
 367  * remotely similar to the methods employed in MSS1-MSS3.
 368  * The idea is that every component has a vector of 1-4 most common symbols
 369  * and an escape mode for reading new value from the bitstream. Decoding
 370  * consists of retrieving pixel values from the vector or reading new ones
 371  * from the bitstream; depending on flags read from the bitstream, these vector
 372  * positions can be updated or reused from the state of the previous line
 373  * or previous pixel.
 374  */
 375 static int mss4_decode_image_block(MSS4Context *ctx, GetBitContext *gb,
 376                                    uint8_t *picdst[3], int mb_x, int mb_y)
 377 {
 378     uint8_t vec[3][4];
 379     int     vec_len[3];
 380     int     sel_len[3], sel_flag[3];
 381     int     i, j, k, mode, split;
 382     int     prev_vec1 = 0, prev_split = 0;
 383     int     vals[3] = { 0 };
 384     int     prev_pix[3] = { 0 };
 385     int     prev_mode[16] = { 0 };
 386     uint8_t *dst[3];
 387
 388     const int val_shift = ctx->quality == 100 ? 0 : 2;
 389
 390     for (i = 0; i < 3; i++)
 391         dst[i] = ctx->imgbuf[i];
 392
 393     for (i = 0; i < 3; i++) {
 394         vec_len[i] = vec_len_syms[!!i][get_unary(gb, 0, 3)];
 395         for (j = 0; j < vec_len[i]; j++) {
 396             vec[i][j]  = get_coeff(gb, &ctx->vec_entry_vlc[!!i]);
 397             vec[i][j] += ctx->prev_vec[i][j];
 398             ctx->prev_vec[i][j] = vec[i][j];
 399         }
 400         sel_flag[i] = vec_len[i] > 1;
 401         sel_len[i]  = vec_len[i] > 2 ? vec_len[i] - 2 : 0;
 402     }
 403
 404     for (j = 0; j < 16; j++) {
 405         if (get_bits1(gb)) {
 406             split = 0;
 407             if (get_bits1(gb)) {
 408                 prev_mode[0] = 0;
 409                 vals[0] = vals[1] = vals[2] = 0;
 410                 mode = 2;
 411             } else {
 412                 mode = get_bits1(gb);
 413                 if (mode)
 414                     split = get_bits(gb, 4);
 415             }
 416             for (i = 0; i < 16; i++) {
 417                 if (mode <= 1) {
 418                     vals[0] =  prev_mode[i]       & 7;
 419                     vals[1] = (prev_mode[i] >> 3) & 7;
 420                     vals[2] =  prev_mode[i] >> 6;
 421                     if (mode == 1 && i == split) {
 422                         read_vec_pos(gb, vals, sel_flag, sel_len, vals);
 423                     }
 424                 } else if (mode == 2) {
 425                     if (get_bits1(gb))
 426                         read_vec_pos(gb, vals, sel_flag, sel_len, vals);
 427                 }
 428                 for (k = 0; k < 3; k++)
 429                     *dst[k]++ = get_value_cached(gb, vals[k], vec[k],
 430                                                  vec_len[k], k,
 431                                                  val_shift, prev_pix);
 432                 prev_mode[i] = MKVAL(vals);
 433             }
 434         } else {
 435             if (get_bits1(gb)) {
 436                 split = get_bits(gb, 4);
 437                 if (split >= prev_split)
 438                     split++;
 439                 prev_split = split;
 440             } else {
 441                 split = prev_split;
 442             }
 443             if (split) {
 444                 vals[0] =  prev_mode[0]       & 7;
 445                 vals[1] = (prev_mode[0] >> 3) & 7;
 446                 vals[2] =  prev_mode[0] >> 6;
 447                 for (i = 0; i < 3; i++) {
 448                     for (k = 0; k < split; k++) {
 449                         *dst[i]++ = get_value_cached(gb, vals[i], vec[i],
 450                                                      vec_len[i], i, val_shift,
 451                                                      prev_pix);
 452                         prev_mode[k] = MKVAL(vals);
 453                     }
 454                 }
 455             }
 456
 457             if (split != 16) {
 458                 vals[0] =  prev_vec1       & 7;
 459                 vals[1] = (prev_vec1 >> 3) & 7;
 460                 vals[2] =  prev_vec1 >> 6;
 461                 if (get_bits1(gb)) {
 462                     read_vec_pos(gb, vals, sel_flag, sel_len, vals);
 463                     prev_vec1 = MKVAL(vals);
 464                 }
 465                 for (i = 0; i < 3; i++) {
 466                     for (k = 0; k < 16 - split; k++) {
 467                         *dst[i]++ = get_value_cached(gb, vals[i], vec[i],
 468                                                      vec_len[i], i, val_shift,
 469                                                      prev_pix);
 470                         prev_mode[split + k] = MKVAL(vals);
 471                     }
 472                 }
 473             }
 474         }
 475     }
 476
 477     for (i = 0; i < 3; i++)
 478         for (j = 0; j < 16; j++)
 479             memcpy(picdst[i] + mb_x * 16 + j * ctx->pic->linesize[i],
 480                    ctx->imgbuf[i] + j * 16, 16);
 481
 482     return 0;
 483 }
 484
 485 static inline void mss4_update_dc_cache(MSS4Context *c, int mb_x)
 486 {
 487     int i;
 488
 489     c->dc_cache[0][TOP]  = c->prev_dc[0][mb_x * 2 + 1];
 490     c->dc_cache[0][LEFT] = 0;
 491     c->dc_cache[1][TOP]  = 0;
 492     c->dc_cache[1][LEFT] = 0;
 493
 494     for (i = 0; i < 2; i++)
 495         c->prev_dc[0][mb_x * 2 + i] = 0;
 496
 497     for (i = 1; i < 3; i++) {
 498         c->dc_cache[i + 1][TOP]  = c->prev_dc[i][mb_x];
 499         c->dc_cache[i + 1][LEFT] = 0;
 500         c->prev_dc[i][mb_x]      = 0;
 501     }
 502 }
 503
 504 static int mss4_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
 505                              AVPacket *avpkt)
 506 {
 507     const uint8_t *buf = avpkt->data;
 508     int buf_size = avpkt->size;
 509     MSS4Context *c = avctx->priv_data;
 510     GetBitContext gb;
 511     GetByteContext bc;
 512     uint8_t *dst[3];
 513     int width, height, quality, frame_type;
 514     int x, y, i, mb_width, mb_height, blk_type;
 515     int ret;
 516
 517     if (buf_size < HEADER_SIZE) {
 518         av_log(avctx, AV_LOG_ERROR,
 519                "Frame should have at least %d bytes, got %d instead\n",
 520                HEADER_SIZE, buf_size);
 521         return AVERROR_INVALIDDATA;
 522     }
 523
 524     bytestream2_init(&bc, buf, buf_size);
 525     width      = bytestream2_get_be16(&bc);
 526     height     = bytestream2_get_be16(&bc);
 527     bytestream2_skip(&bc, 2);
 528     quality    = bytestream2_get_byte(&bc);
 529     frame_type = bytestream2_get_byte(&bc);
 530
 531     if (width > avctx->width ||
 532         height != avctx->height) {
 533         av_log(avctx, AV_LOG_ERROR, "Invalid frame dimensions %dx%d\n",
 534                width, height);
 535         return AVERROR_INVALIDDATA;
 536     }
 537     if (quality < 1 || quality > 100) {
 538         av_log(avctx, AV_LOG_ERROR, "Invalid quality setting %d\n", quality);
 539         return AVERROR_INVALIDDATA;
 540     }
 541     if ((frame_type & ~3) || frame_type == 3) {
 542         av_log(avctx, AV_LOG_ERROR, "Invalid frame type %d\n", frame_type);
 543         return AVERROR_INVALIDDATA;
 544     }
 545
 546     if (frame_type != SKIP_FRAME && !bytestream2_get_bytes_left(&bc)) {
 547         av_log(avctx, AV_LOG_ERROR,
 548                "Empty frame found but it is not a skip frame.\n");
 549         return AVERROR_INVALIDDATA;
 550     }
 551     mb_width  = FFALIGN(width,  16) >> 4;
 552     mb_height = FFALIGN(height, 16) >> 4;
 553
 554     if (frame_type != SKIP_FRAME && 8*buf_size < 8*HEADER_SIZE + mb_width*mb_height)
 555         return AVERROR_INVALIDDATA;
 556
 557     if ((ret = ff_reget_buffer(avctx, c->pic, 0)) < 0)
 558         return ret;
 559     c->pic->key_frame = (frame_type == INTRA_FRAME);
 560     c->pic->pict_type = (frame_type == INTRA_FRAME) ? AV_PICTURE_TYPE_I
 561                                                    : AV_PICTURE_TYPE_P;
 562     if (frame_type == SKIP_FRAME) {
 563         *got_frame      = 1;
 564         if ((ret = av_frame_ref(data, c->pic)) < 0)
 565             return ret;
 566
 567         return buf_size;
 568     }
 569
 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);
 574     }
 575
 576     if ((ret = init_get_bits8(&gb, buf + HEADER_SIZE, buf_size - HEADER_SIZE)) < 0)
 577         return ret;
 578     dst[0] = c->pic->data[0];
 579     dst[1] = c->pic->data[1];
 580     dst[2] = c->pic->data[2];
 581
 582     memset(c->prev_vec, 0, sizeof(c->prev_vec));
 583     for (y = 0; y < mb_height; y++) {
 584         memset(c->dc_cache, 0, sizeof(c->dc_cache));
 585         for (x = 0; x < mb_width; x++) {
 586             blk_type = decode012(&gb);
 587             switch (blk_type) {
 588             case DCT_BLOCK:
 589                 if (mss4_decode_dct_block(c, &gb, dst, x, y) < 0) {
 590                     av_log(avctx, AV_LOG_ERROR,
 591                            "Error decoding DCT block %d,%d\n",
 592                            x, y);
 593                     return AVERROR_INVALIDDATA;
 594                 }
 595                 break;
 596             case IMAGE_BLOCK:
 597                 if (mss4_decode_image_block(c, &gb, dst, x, y) < 0) {
 598                     av_log(avctx, AV_LOG_ERROR,
 599                            "Error decoding VQ block %d,%d\n",
 600                            x, y);
 601                     return AVERROR_INVALIDDATA;
 602                 }
 603                 break;
 604             case SKIP_BLOCK:
 605                 if (frame_type == INTRA_FRAME) {
 606                     av_log(avctx, AV_LOG_ERROR, "Skip block in intra frame\n");
 607                     return AVERROR_INVALIDDATA;
 608                 }
 609                 break;
 610             }
 611             if (blk_type != DCT_BLOCK)
 612                 mss4_update_dc_cache(c, x);
 613         }
 614         dst[0] += c->pic->linesize[0] * 16;
 615         dst[1] += c->pic->linesize[1] * 16;
 616         dst[2] += c->pic->linesize[2] * 16;
 617     }
 618
 619     if ((ret = av_frame_ref(data, c->pic)) < 0)
 620         return ret;
 621
 622     *got_frame      = 1;
 623
 624     return buf_size;
 625 }
 626
 627 static av_cold int mss4_decode_end(AVCodecContext *avctx)
 628 {
 629     MSS4Context * const c = avctx->priv_data;
 630     int i;
 631
 632     av_frame_free(&c->pic);
 633     for (i = 0; i < 3; i++)
 634         av_freep(&c->prev_dc[i]);
 635     mss4_free_vlcs(c);
 636
 637     return 0;
 638 }
 639
 640 static av_cold int mss4_decode_init(AVCodecContext *avctx)
 641 {
 642     MSS4Context * const c = avctx->priv_data;
 643     int i;
 644
 645     if (mss4_init_vlcs(c)) {
 646         av_log(avctx, AV_LOG_ERROR, "Cannot initialise VLCs\n");
 647         return AVERROR(ENOMEM);
 648     }
 649     for (i = 0; i < 3; i++) {
 650         c->dc_stride[i] = FFALIGN(avctx->width, 16) >> (2 + !!i);
 651         c->prev_dc[i]   = av_malloc_array(c->dc_stride[i], sizeof(**c->prev_dc));
 652         if (!c->prev_dc[i]) {
 653             av_log(avctx, AV_LOG_ERROR, "Cannot allocate buffer\n");
 654             return AVERROR(ENOMEM);
 655         }
 656     }
 657
 658     c->pic = av_frame_alloc();
 659     if (!c->pic)
 660         return AVERROR(ENOMEM);
 661
 662     avctx->pix_fmt     = AV_PIX_FMT_YUV444P;
 663
 664     return 0;
 665 }
 666
 667 AVCodec ff_mts2_decoder = {
 668     .name           = "mts2",
 669     .long_name      = NULL_IF_CONFIG_SMALL("MS Expression Encoder Screen"),
 670     .type           = AVMEDIA_TYPE_VIDEO,
 671     .id             = AV_CODEC_ID_MTS2,
 672     .priv_data_size = sizeof(MSS4Context),
 673     .init           = mss4_decode_init,
 674     .close          = mss4_decode_end,
 675     .decode         = mss4_decode_frame,
 676     .capabilities   = AV_CODEC_CAP_DR1,
 677     .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP | FF_CODEC_CAP_INIT_THREADSAFE,
 678 };