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 "dsputil.h"
  31 #include "get_bits.h"
  32 #include "internal.h"
  33 #include "mss34dsp.h"
  34 #include "unary.h"
  35
  36 #define HEADER_SIZE 8
  37
  38 enum FrameType {
  39     INTRA_FRAME = 0,
  40     INTER_FRAME,
  41     SKIP_FRAME
  42 };
  43
  44 enum BlockType {
  45     SKIP_BLOCK = 0,
  46     DCT_BLOCK,
  47     IMAGE_BLOCK,
  48 };
  49
  50 enum CachePos {
  51     LEFT = 0,
  52     TOP_LEFT,
  53     TOP,
  54 };
  55
  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 }
  59 };
  60
  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 }
  64 };
  65
  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,
  87     0xF9, 0xFA  },
  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,
 108     0xF9, 0xFA  }
 109 };
 110
 111 static const uint8_t vec_len_syms[2][4] = {
 112     { 4, 2, 3, 1 },
 113     { 4, 1, 2, 3 }
 114 };
 115
 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 }
 119 };
 120
 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 }
 124 };
 125
 126 #define MAX_ENTRIES  162
 127
 128 typedef struct MSS4Context {
 129     AVFrame    *pic;
 130
 131     VLC        dc_vlc[2], ac_vlc[2];
 132     VLC        vec_entry_vlc[2];
 133     int        block[64];
 134     uint8_t    imgbuf[3][16 * 16];
 135
 136     int        quality;
 137     uint16_t   quant_mat[2][64];
 138
 139     int        *prev_dc[3];
 140     int        dc_stride[3];
 141     int        dc_cache[4][4];
 142
 143     int        prev_vec[3][4];
 144 } MSS4Context;
 145
 146 static av_cold int mss4_init_vlc(VLC *vlc, const uint8_t *lens,
 147                                  const uint8_t *syms, int num_syms)
 148 {
 149     uint8_t  bits[MAX_ENTRIES];
 150     uint16_t codes[MAX_ENTRIES];
 151     int i, j;
 152     int prefix = 0, max_bits = 0, idx = 0;
 153
 154     for (i = 0; i < 16; i++) {
 155         for (j = 0; j < lens[i]; j++) {
 156             bits[idx]  = i + 1;
 157             codes[idx] = prefix++;
 158             max_bits   = i + 1;
 159             idx++;
 160         }
 161         prefix <<= 1;
 162     }
 163
 164     return ff_init_vlc_sparse(vlc, FFMIN(max_bits, 9), num_syms, bits, 1, 1,
 165                               codes, 2, 2, syms, 1, 1, 0);
 166 }
 167
 168 static av_cold int mss4_init_vlcs(MSS4Context *ctx)
 169 {
 170     int ret, i;
 171
 172     for (i = 0; i < 2; i++) {
 173         ret = mss4_init_vlc(&ctx->dc_vlc[i], mss4_dc_vlc_lens[i], NULL, 12);
 174         if (ret)
 175             return ret;
 176         ret = mss4_init_vlc(&ctx->ac_vlc[i], mss4_ac_vlc_lens[i],
 177                             mss4_ac_vlc_syms[i], 162);
 178         if (ret)
 179             return ret;
 180         ret = mss4_init_vlc(&ctx->vec_entry_vlc[i], mss4_vec_entry_vlc_lens[i],
 181                             mss4_vec_entry_vlc_syms[i], 9);
 182         if (ret)
 183             return ret;
 184     }
 185     return 0;
 186 }
 187
 188 static av_cold void mss4_free_vlcs(MSS4Context *ctx)
 189 {
 190     int i;
 191
 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]);
 196     }
 197 }
 198
 199 /* This function returns values in the range
 200  * (-range + 1; -range/2] U [range/2; range - 1)
 201  * i.e.
 202  * nbits = 0 -> 0
 203  * nbits = 1 -> -1, 1
 204  * nbits = 2 -> -3, -2, 2, 3
 205  */
 206 static av_always_inline int get_coeff_bits(GetBitContext *gb, int nbits)
 207 {
 208     int val;
 209
 210     if (!nbits)
 211         return 0;
 212
 213     val = get_bits(gb, nbits);
 214     if (val < (1 << (nbits - 1)))
 215         val -= (1 << nbits) - 1;
 216
 217     return val;
 218 }
 219
 220 static inline int get_coeff(GetBitContext *gb, VLC *vlc)
 221 {
 222     int val = get_vlc2(gb, vlc->table, vlc->bits, 2);
 223
 224     return get_coeff_bits(gb, val);
 225 }
 226
 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)
 230 {
 231     int skip, val, pos = 1, zz_pos, dc;
 232
 233     memset(block, 0, sizeof(*block) * 64);
 234
 235     dc = get_coeff(gb, dc_vlc);
 236     // DC prediction is the same as in MSS3
 237     if (by) {
 238         if (bx) {
 239             int l, tl, t;
 240
 241             l  = dc_cache[LEFT];
 242             tl = dc_cache[TOP_LEFT];
 243             t  = dc_cache[TOP];
 244
 245             if (FFABS(t - tl) <= FFABS(l - tl))
 246                 dc += l;
 247             else
 248                 dc += t;
 249         } else {
 250             dc += dc_cache[TOP];
 251         }
 252     } else if (bx) {
 253         dc += dc_cache[LEFT];
 254     }
 255     dc_cache[LEFT] = dc;
 256     block[0]       = dc * quant_mat[0];
 257
 258     while (pos < 64) {
 259         val = get_vlc2(gb, ac_vlc->table, 9, 2);
 260         if (!val)
 261             return 0;
 262         if (val == -1)
 263             return -1;
 264         if (val == 0xF0) {
 265             pos += 16;
 266             continue;
 267         }
 268         skip = val >> 4;
 269         val  = get_coeff_bits(gb, val & 0xF);
 270         pos += skip;
 271         if (pos >= 64)
 272             return -1;
 273
 274         zz_pos = ff_zigzag_direct[pos];
 275         block[zz_pos] = val * quant_mat[zz_pos];
 276         pos++;
 277     }
 278
 279     return pos == 64 ? 0 : -1;
 280 }
 281
 282 static int mss4_decode_dct_block(MSS4Context *c, GetBitContext *gb,
 283                                  uint8_t *dst[3], int mb_x, int mb_y)
 284 {
 285     int i, j, k, ret;
 286     uint8_t *out = dst[0];
 287
 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,
 294                                   c->dc_cache[j],
 295                                   xpos, mb_y * 2 + j, c->quant_mat[0]);
 296             if (ret)
 297                 return ret;
 298             c->prev_dc[0][mb_x * 2 + i] = c->dc_cache[j][LEFT];
 299
 300             ff_mss34_dct_put(out + xpos * 8, c->pic->linesize[0],
 301                              c->block);
 302         }
 303         out += 8 * c->pic->linesize[0];
 304     }
 305
 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,
 311                               c->quant_mat[1]);
 312         if (ret)
 313             return ret;
 314         c->prev_dc[i][mb_x] = c->dc_cache[i + 1][LEFT];
 315
 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];
 324         }
 325     }
 326
 327     return 0;
 328 }
 329
 330 static void read_vec_pos(GetBitContext *gb, int *vec_pos, int *sel_flag,
 331                          int *sel_len, int *prev)
 332 {
 333     int i, y_flag = 0;
 334
 335     for (i = 2; i >= 0; i--) {
 336         if (!sel_flag[i]) {
 337             vec_pos[i] = 0;
 338             continue;
 339         }
 340         if ((!i && !y_flag) || get_bits1(gb)) {
 341             if (sel_len[i] > 0) {
 342                 int pval = prev[i];
 343                 vec_pos[i] = get_bits(gb, sel_len[i]);
 344                 if (vec_pos[i] >= pval)
 345                     vec_pos[i]++;
 346             } else {
 347                 vec_pos[i] = !prev[i];
 348             }
 349             y_flag = 1;
 350         } else {
 351             vec_pos[i] = prev[i];
 352         }
 353     }
 354 }
 355
 356 static int get_value_cached(GetBitContext *gb, int vec_pos, uint8_t *vec,
 357                             int vec_size, int component, int shift, int *prev)
 358 {
 359     if (vec_pos < vec_size)
 360         return vec[vec_pos];
 361     if (!get_bits1(gb))
 362         return prev[component];
 363     prev[component] = get_bits(gb, 8 - shift) << shift;
 364     return prev[component];
 365 }
 366
 367 #define MKVAL(vals)  (vals[0] | (vals[1] << 3) | (vals[2] << 6))
 368
 369 /* Image mode - the hardest to comprehend MSS4 coding mode.
 370  *
 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
 378  * or previous pixel.
 379  */
 380 static int mss4_decode_image_block(MSS4Context *ctx, GetBitContext *gb,
 381                                    uint8_t *picdst[3], int mb_x, int mb_y)
 382 {
 383     uint8_t vec[3][4];
 384     int     vec_len[3];
 385     int     sel_len[3], sel_flag[3];
 386     int     i, j, k, mode, split;
 387     int     prev_vec1 = 0, prev_split = 0;
 388     int     vals[3] = { 0 };
 389     int     prev_pix[3] = { 0 };
 390     int     prev_mode[16] = { 0 };
 391     uint8_t *dst[3];
 392
 393     const int val_shift = ctx->quality == 100 ? 0 : 2;
 394
 395     for (i = 0; i < 3; i++)
 396         dst[i] = ctx->imgbuf[i];
 397
 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];
 404         }
 405         sel_flag[i] = vec_len[i] > 1;
 406         sel_len[i]  = vec_len[i] > 2 ? vec_len[i] - 2 : 0;
 407     }
 408
 409     for (j = 0; j < 16; j++) {
 410         if (get_bits1(gb)) {
 411             split = 0;
 412             if (get_bits1(gb)) {
 413                 prev_mode[0] = 0;
 414                 vals[0] = vals[1] = vals[2] = 0;
 415                 mode = 2;
 416             } else {
 417                 mode = get_bits1(gb);
 418                 if (mode)
 419                     split = get_bits(gb, 4);
 420             }
 421             for (i = 0; i < 16; i++) {
 422                 if (mode <= 1) {
 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);
 428                     }
 429                 } else if (mode == 2) {
 430                     if (get_bits1(gb))
 431                         read_vec_pos(gb, vals, sel_flag, sel_len, vals);
 432                 }
 433                 for (k = 0; k < 3; k++)
 434                     *dst[k]++ = get_value_cached(gb, vals[k], vec[k],
 435                                                  vec_len[k], k,
 436                                                  val_shift, prev_pix);
 437                 prev_mode[i] = MKVAL(vals);
 438             }
 439         } else {
 440             if (get_bits1(gb)) {
 441                 split = get_bits(gb, 4);
 442                 if (split >= prev_split)
 443                     split++;
 444                 prev_split = split;
 445             } else {
 446                 split = prev_split;
 447             }
 448             if (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,
 456                                                      prev_pix);
 457                         prev_mode[k] = MKVAL(vals);
 458                     }
 459                 }
 460             }
 461
 462             if (split != 16) {
 463                 vals[0] =  prev_vec1       & 7;
 464                 vals[1] = (prev_vec1 >> 3) & 7;
 465                 vals[2] =  prev_vec1 >> 6;
 466                 if (get_bits1(gb)) {
 467                     read_vec_pos(gb, vals, sel_flag, sel_len, vals);
 468                     prev_vec1 = MKVAL(vals);
 469                 }
 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,
 474                                                      prev_pix);
 475                         prev_mode[split + k] = MKVAL(vals);
 476                     }
 477                 }
 478             }
 479         }
 480     }
 481
 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);
 486
 487     return 0;
 488 }
 489
 490 static inline void mss4_update_dc_cache(MSS4Context *c, int mb_x)
 491 {
 492     int i;
 493
 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;
 498
 499     for (i = 0; i < 2; i++)
 500         c->prev_dc[0][mb_x * 2 + i] = 0;
 501
 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;
 506     }
 507 }
 508
 509 static int mss4_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
 510                              AVPacket *avpkt)
 511 {
 512     const uint8_t *buf = avpkt->data;
 513     int buf_size = avpkt->size;
 514     MSS4Context *c = avctx->priv_data;
 515     GetBitContext gb;
 516     GetByteContext bc;
 517     uint8_t *dst[3];
 518     int width, height, quality, frame_type;
 519     int x, y, i, mb_width, mb_height, blk_type;
 520     int ret;
 521
 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;
 527     }
 528
 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);
 535
 536     if (width > avctx->width ||
 537         height != avctx->height) {
 538         av_log(avctx, AV_LOG_ERROR, "Invalid frame dimensions %dx%d\n",
 539                width, height);
 540         return AVERROR_INVALIDDATA;
 541     }
 542     if (quality < 1 || quality > 100) {
 543         av_log(avctx, AV_LOG_ERROR, "Invalid quality setting %d\n", quality);
 544         return AVERROR_INVALIDDATA;
 545     }
 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;
 549     }
 550
 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;
 555     }
 556
 557     if ((ret = ff_reget_buffer(avctx, c->pic)) < 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     init_get_bits8(&gb, buf + HEADER_SIZE, (buf_size - HEADER_SIZE));
 577
 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];
 583
 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);
 589             switch (blk_type) {
 590             case DCT_BLOCK:
 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",
 594                            x, y);
 595                     return AVERROR_INVALIDDATA;
 596                 }
 597                 break;
 598             case IMAGE_BLOCK:
 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",
 602                            x, y);
 603                     return AVERROR_INVALIDDATA;
 604                 }
 605                 break;
 606             case SKIP_BLOCK:
 607                 if (frame_type == INTRA_FRAME) {
 608                     av_log(avctx, AV_LOG_ERROR, "Skip block in intra frame\n");
 609                     return AVERROR_INVALIDDATA;
 610                 }
 611                 break;
 612             }
 613             if (blk_type != DCT_BLOCK)
 614                 mss4_update_dc_cache(c, x);
 615         }
 616         dst[0] += c->pic->linesize[0] * 16;
 617         dst[1] += c->pic->linesize[1] * 16;
 618         dst[2] += c->pic->linesize[2] * 16;
 619     }
 620
 621     if ((ret = av_frame_ref(data, c->pic)) < 0)
 622         return ret;
 623
 624     *got_frame      = 1;
 625
 626     return buf_size;
 627 }
 628
 629 static av_cold int mss4_decode_end(AVCodecContext *avctx)
 630 {
 631     MSS4Context * const c = avctx->priv_data;
 632     int i;
 633
 634     av_frame_free(&c->pic);
 635     for (i = 0; i < 3; i++)
 636         av_freep(&c->prev_dc[i]);
 637     mss4_free_vlcs(c);
 638
 639     return 0;
 640 }
 641
 642 static av_cold int mss4_decode_init(AVCodecContext *avctx)
 643 {
 644     MSS4Context * const c = avctx->priv_data;
 645     int i;
 646
 647     if (mss4_init_vlcs(c)) {
 648         av_log(avctx, AV_LOG_ERROR, "Cannot initialise VLCs\n");
 649         mss4_free_vlcs(c);
 650         return AVERROR(ENOMEM);
 651     }
 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");
 657             mss4_free_vlcs(c);
 658             return AVERROR(ENOMEM);
 659         }
 660     }
 661
 662     c->pic = av_frame_alloc();
 663     if (!c->pic) {
 664         mss4_decode_end(avctx);
 665         return AVERROR(ENOMEM);
 666     }
 667
 668     avctx->pix_fmt     = AV_PIX_FMT_YUV444P;
 669
 670     return 0;
 671 }
 672
 673 AVCodec ff_mts2_decoder = {
 674     .name           = "mts2",
 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,
 683 };