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 Libav.
   6  *
   7  * Libav 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  * Libav 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 Libav; 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 "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     DSPContext dsp;
 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 *data_size,
 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     c->pic.reference    = 3;
 558     c->pic.buffer_hints = FF_BUFFER_HINTS_VALID    |
 559                           FF_BUFFER_HINTS_PRESERVE |
 560                           FF_BUFFER_HINTS_REUSABLE;
 561     if ((ret = avctx->reget_buffer(avctx, &c->pic)) < 0) {
 562         av_log(avctx, AV_LOG_ERROR, "reget_buffer() failed\n");
 563         return ret;
 564     }
 565     c->pic.key_frame = (frame_type == INTRA_FRAME);
 566     c->pic.pict_type = (frame_type == INTRA_FRAME) ? AV_PICTURE_TYPE_I
 567                                                    : AV_PICTURE_TYPE_P;
 568     if (frame_type == SKIP_FRAME) {
 569         *data_size = sizeof(AVFrame);
 570         *(AVFrame*)data = c->pic;
 571
 572         return buf_size;
 573     }
 574
 575     if (c->quality != quality) {
 576         c->quality = quality;
 577         for (i = 0; i < 2; i++)
 578             ff_mss34_gen_quant_mat(c->quant_mat[i], quality, !i);
 579     }
 580
 581     init_get_bits(&gb, buf + HEADER_SIZE, (buf_size - HEADER_SIZE) * 8);
 582
 583     mb_width  = FFALIGN(width,  16) >> 4;
 584     mb_height = FFALIGN(height, 16) >> 4;
 585     dst[0] = c->pic.data[0];
 586     dst[1] = c->pic.data[1];
 587     dst[2] = c->pic.data[2];
 588
 589     memset(c->prev_vec, 0, sizeof(c->prev_vec));
 590     for (y = 0; y < mb_height; y++) {
 591         memset(c->dc_cache, 0, sizeof(c->dc_cache));
 592         for (x = 0; x < mb_width; x++) {
 593             blk_type = decode012(&gb);
 594             switch (blk_type) {
 595             case DCT_BLOCK:
 596                 if (mss4_decode_dct_block(c, &gb, dst, x, y) < 0) {
 597                     av_log(avctx, AV_LOG_ERROR,
 598                            "Error decoding DCT block %d,%d\n",
 599                            x, y);
 600                     return AVERROR_INVALIDDATA;
 601                 }
 602                 break;
 603             case IMAGE_BLOCK:
 604                 if (mss4_decode_image_block(c, &gb, dst, x, y) < 0) {
 605                     av_log(avctx, AV_LOG_ERROR,
 606                            "Error decoding VQ block %d,%d\n",
 607                            x, y);
 608                     return AVERROR_INVALIDDATA;
 609                 }
 610                 break;
 611             case SKIP_BLOCK:
 612                 if (frame_type == INTRA_FRAME) {
 613                     av_log(avctx, AV_LOG_ERROR, "Skip block in intra frame\n");
 614                     return AVERROR_INVALIDDATA;
 615                 }
 616                 break;
 617             }
 618             if (blk_type != DCT_BLOCK)
 619                 mss4_update_dc_cache(c, x);
 620         }
 621         dst[0] += c->pic.linesize[0] * 16;
 622         dst[1] += c->pic.linesize[1] * 16;
 623         dst[2] += c->pic.linesize[2] * 16;
 624     }
 625
 626     *data_size = sizeof(AVFrame);
 627     *(AVFrame*)data = c->pic;
 628
 629     return buf_size;
 630 }
 631
 632 static av_cold int mss4_decode_init(AVCodecContext *avctx)
 633 {
 634     MSS4Context * const c = avctx->priv_data;
 635     int i;
 636
 637     if (mss4_init_vlcs(c)) {
 638         av_log(avctx, AV_LOG_ERROR, "Cannot initialise VLCs\n");
 639         mss4_free_vlcs(c);
 640         return AVERROR(ENOMEM);
 641     }
 642     for (i = 0; i < 3; i++) {
 643         c->dc_stride[i] = FFALIGN(avctx->width, 16) >> (2 + !!i);
 644         c->prev_dc[i]   = av_malloc(sizeof(**c->prev_dc) * c->dc_stride[i]);
 645         if (!c->prev_dc[i]) {
 646             av_log(avctx, AV_LOG_ERROR, "Cannot allocate buffer\n");
 647             mss4_free_vlcs(c);
 648             return AVERROR(ENOMEM);
 649         }
 650     }
 651
 652     avctx->pix_fmt     = AV_PIX_FMT_YUV444P;
 653     avctx->coded_frame = &c->pic;
 654
 655     return 0;
 656 }
 657
 658 static av_cold int mss4_decode_end(AVCodecContext *avctx)
 659 {
 660     MSS4Context * const c = avctx->priv_data;
 661     int i;
 662
 663     if (c->pic.data[0])
 664         avctx->release_buffer(avctx, &c->pic);
 665     for (i = 0; i < 3; i++)
 666         av_freep(&c->prev_dc[i]);
 667     mss4_free_vlcs(c);
 668
 669     return 0;
 670 }
 671
 672 AVCodec ff_mts2_decoder = {
 673     .name           = "mts2",
 674     .type           = AVMEDIA_TYPE_VIDEO,
 675     .id             = AV_CODEC_ID_MTS2,
 676     .priv_data_size = sizeof(MSS4Context),
 677     .init           = mss4_decode_init,
 678     .close          = mss4_decode_end,
 679     .decode         = mss4_decode_frame,
 680     .capabilities   = CODEC_CAP_DR1,
 681     .long_name      = NULL_IF_CONFIG_SMALL("MS Expression Encoder Screen"),
 682 };