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