Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | RSS feed

  1. /*
  2.  * Microsoft Screen 2 (aka Windows Media Video V9 Screen) decoder
  3.  *
  4.  * This file is part of FFmpeg.
  5.  *
  6.  * FFmpeg is free software; you can redistribute it and/or
  7.  * modify it under the terms of the GNU Lesser General Public
  8.  * License as published by the Free Software Foundation; either
  9.  * version 2.1 of the License, or (at your option) any later version.
  10.  *
  11.  * FFmpeg is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14.  * Lesser General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU Lesser General Public
  17.  * License along with FFmpeg; if not, write to the Free Software
  18.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  19.  */
  20.  
  21. /**
  22.  * @file
  23.  * Microsoft Screen 2 (aka Windows Media Video V9 Screen) decoder
  24.  */
  25.  
  26. #include "libavutil/avassert.h"
  27. #include "error_resilience.h"
  28. #include "internal.h"
  29. #include "msmpeg4data.h"
  30. #include "vc1.h"
  31. #include "mss12.h"
  32. #include "mss2dsp.h"
  33.  
  34. typedef struct MSS2Context {
  35.     VC1Context     v;
  36.     int            split_position;
  37.     AVFrame       *last_pic;
  38.     MSS12Context   c;
  39.     MSS2DSPContext dsp;
  40.     SliceContext   sc[2];
  41. } MSS2Context;
  42.  
  43. static void arith2_normalise(ArithCoder *c)
  44. {
  45.     while ((c->high >> 15) - (c->low >> 15) < 2) {
  46.         if ((c->low ^ c->high) & 0x10000) {
  47.             c->high  ^= 0x8000;
  48.             c->value ^= 0x8000;
  49.             c->low   ^= 0x8000;
  50.         }
  51.         c->high  = c->high  << 8 & 0xFFFFFF | 0xFF;
  52.         c->value = c->value << 8 & 0xFFFFFF | bytestream2_get_byte(c->gbc.gB);
  53.         c->low   = c->low   << 8 & 0xFFFFFF;
  54.     }
  55. }
  56.  
  57. ARITH_GET_BIT(2)
  58.  
  59. /* L. Stuiver and A. Moffat: "Piecewise Integer Mapping for Arithmetic Coding."
  60.  * In Proc. 8th Data Compression Conference (DCC '98), pp. 3-12, Mar. 1998 */
  61.  
  62. static int arith2_get_scaled_value(int value, int n, int range)
  63. {
  64.     int split = (n << 1) - range;
  65.  
  66.     if (value > split)
  67.         return split + (value - split >> 1);
  68.     else
  69.         return value;
  70. }
  71.  
  72. static void arith2_rescale_interval(ArithCoder *c, int range,
  73.                                     int low, int high, int n)
  74. {
  75.     int split = (n << 1) - range;
  76.  
  77.     if (high > split)
  78.         c->high = split + (high - split << 1);
  79.     else
  80.         c->high = high;
  81.  
  82.     c->high += c->low - 1;
  83.  
  84.     if (low > split)
  85.         c->low += split + (low - split << 1);
  86.     else
  87.         c->low += low;
  88. }
  89.  
  90. static int arith2_get_number(ArithCoder *c, int n)
  91. {
  92.     int range = c->high - c->low + 1;
  93.     int scale = av_log2(range) - av_log2(n);
  94.     int val;
  95.  
  96.     if (n << scale > range)
  97.         scale--;
  98.  
  99.     n <<= scale;
  100.  
  101.     val = arith2_get_scaled_value(c->value - c->low, n, range) >> scale;
  102.  
  103.     arith2_rescale_interval(c, range, val << scale, (val + 1) << scale, n);
  104.  
  105.     arith2_normalise(c);
  106.  
  107.     return val;
  108. }
  109.  
  110. static int arith2_get_prob(ArithCoder *c, int16_t *probs)
  111. {
  112.     int range = c->high - c->low + 1, n = *probs;
  113.     int scale = av_log2(range) - av_log2(n);
  114.     int i     = 0, val;
  115.  
  116.     if (n << scale > range)
  117.         scale--;
  118.  
  119.     n <<= scale;
  120.  
  121.     val = arith2_get_scaled_value(c->value - c->low, n, range) >> scale;
  122.     while (probs[++i] > val) ;
  123.  
  124.     arith2_rescale_interval(c, range,
  125.                             probs[i] << scale, probs[i - 1] << scale, n);
  126.  
  127.     return i;
  128. }
  129.  
  130. ARITH_GET_MODEL_SYM(2)
  131.  
  132. static int arith2_get_consumed_bytes(ArithCoder *c)
  133. {
  134.     int diff = (c->high >> 16) - (c->low >> 16);
  135.     int bp   = bytestream2_tell(c->gbc.gB) - 3 << 3;
  136.     int bits = 1;
  137.  
  138.     while (!(diff & 0x80)) {
  139.         bits++;
  140.         diff <<= 1;
  141.     }
  142.  
  143.     return (bits + bp + 7 >> 3) + ((c->low >> 16) + 1 == c->high >> 16);
  144. }
  145.  
  146. static void arith2_init(ArithCoder *c, GetByteContext *gB)
  147. {
  148.     c->low           = 0;
  149.     c->high          = 0xFFFFFF;
  150.     c->value         = bytestream2_get_be24(gB);
  151.     c->gbc.gB        = gB;
  152.     c->get_model_sym = arith2_get_model_sym;
  153.     c->get_number    = arith2_get_number;
  154. }
  155.  
  156. static int decode_pal_v2(MSS12Context *ctx, const uint8_t *buf, int buf_size)
  157. {
  158.     int i, ncol;
  159.     uint32_t *pal = ctx->pal + 256 - ctx->free_colours;
  160.  
  161.     if (!ctx->free_colours)
  162.         return 0;
  163.  
  164.     ncol = *buf++;
  165.     if (ncol > ctx->free_colours || buf_size < 2 + ncol * 3)
  166.         return AVERROR_INVALIDDATA;
  167.     for (i = 0; i < ncol; i++)
  168.         *pal++ = AV_RB24(buf + 3 * i);
  169.  
  170.     return 1 + ncol * 3;
  171. }
  172.  
  173. static int decode_555(GetByteContext *gB, uint16_t *dst, int stride,
  174.                       int keyframe, int w, int h)
  175. {
  176.     int last_symbol = 0, repeat = 0, prev_avail = 0;
  177.  
  178.     if (!keyframe) {
  179.         int x, y, endx, endy, t;
  180.  
  181. #define READ_PAIR(a, b)                 \
  182.     a  = bytestream2_get_byte(gB) << 4; \
  183.     t  = bytestream2_get_byte(gB);      \
  184.     a |= t >> 4;                        \
  185.     b  = (t & 0xF) << 8;                \
  186.     b |= bytestream2_get_byte(gB);      \
  187.  
  188.         READ_PAIR(x, endx)
  189.         READ_PAIR(y, endy)
  190.  
  191.         if (endx >= w || endy >= h || x > endx || y > endy)
  192.             return AVERROR_INVALIDDATA;
  193.         dst += x + stride * y;
  194.         w    = endx - x + 1;
  195.         h    = endy - y + 1;
  196.         if (y)
  197.             prev_avail = 1;
  198.     }
  199.  
  200.     do {
  201.         uint16_t *p = dst;
  202.         do {
  203.             if (repeat-- < 1) {
  204.                 int b = bytestream2_get_byte(gB);
  205.                 if (b < 128)
  206.                     last_symbol = b << 8 | bytestream2_get_byte(gB);
  207.                 else if (b > 129) {
  208.                     repeat = 0;
  209.                     while (b-- > 130)
  210.                         repeat = (repeat << 8) + bytestream2_get_byte(gB) + 1;
  211.                     if (last_symbol == -2) {
  212.                         int skip = FFMIN((unsigned)repeat, dst + w - p);
  213.                         repeat -= skip;
  214.                         p      += skip;
  215.                     }
  216.                 } else
  217.                     last_symbol = 127 - b;
  218.             }
  219.             if (last_symbol >= 0)
  220.                 *p = last_symbol;
  221.             else if (last_symbol == -1 && prev_avail)
  222.                 *p = *(p - stride);
  223.         } while (++p < dst + w);
  224.         dst       += stride;
  225.         prev_avail = 1;
  226.     } while (--h);
  227.  
  228.     return 0;
  229. }
  230.  
  231. static int decode_rle(GetBitContext *gb, uint8_t *pal_dst, int pal_stride,
  232.                       uint8_t *rgb_dst, int rgb_stride, uint32_t *pal,
  233.                       int keyframe, int kf_slipt, int slice, int w, int h)
  234. {
  235.     uint8_t bits[270] = { 0 };
  236.     uint32_t codes[270];
  237.     VLC vlc;
  238.  
  239.     int current_length = 0, read_codes = 0, next_code = 0, current_codes = 0;
  240.     int remaining_codes, surplus_codes, i;
  241.  
  242.     const int alphabet_size = 270 - keyframe;
  243.  
  244.     int last_symbol = 0, repeat = 0, prev_avail = 0;
  245.  
  246.     if (!keyframe) {
  247.         int x, y, clipw, cliph;
  248.  
  249.         x     = get_bits(gb, 12);
  250.         y     = get_bits(gb, 12);
  251.         clipw = get_bits(gb, 12) + 1;
  252.         cliph = get_bits(gb, 12) + 1;
  253.  
  254.         if (x + clipw > w || y + cliph > h)
  255.             return AVERROR_INVALIDDATA;
  256.         pal_dst += pal_stride * y + x;
  257.         rgb_dst += rgb_stride * y + x * 3;
  258.         w        = clipw;
  259.         h        = cliph;
  260.         if (y)
  261.             prev_avail = 1;
  262.     } else {
  263.         if (slice > 0) {
  264.             pal_dst   += pal_stride * kf_slipt;
  265.             rgb_dst   += rgb_stride * kf_slipt;
  266.             prev_avail = 1;
  267.             h         -= kf_slipt;
  268.         } else
  269.             h = kf_slipt;
  270.     }
  271.  
  272.     /* read explicit codes */
  273.     do {
  274.         while (current_codes--) {
  275.             int symbol = get_bits(gb, 8);
  276.             if (symbol >= 204 - keyframe)
  277.                 symbol += 14 - keyframe;
  278.             else if (symbol > 189)
  279.                 symbol = get_bits1(gb) + (symbol << 1) - 190;
  280.             if (bits[symbol])
  281.                 return AVERROR_INVALIDDATA;
  282.             bits[symbol]  = current_length;
  283.             codes[symbol] = next_code++;
  284.             read_codes++;
  285.         }
  286.         current_length++;
  287.         next_code     <<= 1;
  288.         remaining_codes = (1 << current_length) - next_code;
  289.         current_codes   = get_bits(gb, av_ceil_log2(remaining_codes + 1));
  290.         if (current_length > 22 || current_codes > remaining_codes)
  291.             return AVERROR_INVALIDDATA;
  292.     } while (current_codes != remaining_codes);
  293.  
  294.     remaining_codes = alphabet_size - read_codes;
  295.  
  296.     /* determine the minimum length to fit the rest of the alphabet */
  297.     while ((surplus_codes = (2 << current_length) -
  298.                             (next_code << 1) - remaining_codes) < 0) {
  299.         current_length++;
  300.         next_code <<= 1;
  301.     }
  302.  
  303.     /* add the rest of the symbols lexicographically */
  304.     for (i = 0; i < alphabet_size; i++)
  305.         if (!bits[i]) {
  306.             if (surplus_codes-- == 0) {
  307.                 current_length++;
  308.                 next_code <<= 1;
  309.             }
  310.             bits[i]  = current_length;
  311.             codes[i] = next_code++;
  312.         }
  313.  
  314.     if (next_code != 1 << current_length)
  315.         return AVERROR_INVALIDDATA;
  316.  
  317.     if (i = init_vlc(&vlc, 9, alphabet_size, bits, 1, 1, codes, 4, 4, 0))
  318.         return i;
  319.  
  320.     /* frame decode */
  321.     do {
  322.         uint8_t *pp = pal_dst;
  323.         uint8_t *rp = rgb_dst;
  324.         do {
  325.             if (repeat-- < 1) {
  326.                 int b = get_vlc2(gb, vlc.table, 9, 3);
  327.                 if (b < 256)
  328.                     last_symbol = b;
  329.                 else if (b < 268) {
  330.                     b -= 256;
  331.                     if (b == 11)
  332.                         b = get_bits(gb, 4) + 10;
  333.  
  334.                     if (!b)
  335.                         repeat = 0;
  336.                     else
  337.                         repeat = get_bits(gb, b);
  338.  
  339.                     repeat += (1 << b) - 1;
  340.  
  341.                     if (last_symbol == -2) {
  342.                         int skip = FFMIN(repeat, pal_dst + w - pp);
  343.                         repeat -= skip;
  344.                         pp     += skip;
  345.                         rp     += skip * 3;
  346.                     }
  347.                 } else
  348.                     last_symbol = 267 - b;
  349.             }
  350.             if (last_symbol >= 0) {
  351.                 *pp = last_symbol;
  352.                 AV_WB24(rp, pal[last_symbol]);
  353.             } else if (last_symbol == -1 && prev_avail) {
  354.                 *pp = *(pp - pal_stride);
  355.                 memcpy(rp, rp - rgb_stride, 3);
  356.             }
  357.             rp += 3;
  358.         } while (++pp < pal_dst + w);
  359.         pal_dst   += pal_stride;
  360.         rgb_dst   += rgb_stride;
  361.         prev_avail = 1;
  362.     } while (--h);
  363.  
  364.     ff_free_vlc(&vlc);
  365.     return 0;
  366. }
  367.  
  368. static int decode_wmv9(AVCodecContext *avctx, const uint8_t *buf, int buf_size,
  369.                        int x, int y, int w, int h, int wmv9_mask)
  370. {
  371.     MSS2Context *ctx  = avctx->priv_data;
  372.     MSS12Context *c   = &ctx->c;
  373.     VC1Context *v     = avctx->priv_data;
  374.     MpegEncContext *s = &v->s;
  375.     AVFrame *f;
  376.     int ret;
  377.  
  378.     ff_mpeg_flush(avctx);
  379.  
  380.     if (s->current_picture_ptr == NULL || s->current_picture_ptr->f.data[0]) {
  381.         int i = ff_find_unused_picture(s, 0);
  382.         if (i < 0)
  383.             return i;
  384.         s->current_picture_ptr = &s->picture[i];
  385.     }
  386.  
  387.     init_get_bits(&s->gb, buf, buf_size * 8);
  388.  
  389.     s->loop_filter = avctx->skip_loop_filter < AVDISCARD_ALL;
  390.  
  391.     if (ff_vc1_parse_frame_header(v, &s->gb) < 0) {
  392.         av_log(v->s.avctx, AV_LOG_ERROR, "header error\n");
  393.         return AVERROR_INVALIDDATA;
  394.     }
  395.  
  396.     if (s->pict_type != AV_PICTURE_TYPE_I) {
  397.         av_log(v->s.avctx, AV_LOG_ERROR, "expected I-frame\n");
  398.         return AVERROR_INVALIDDATA;
  399.     }
  400.  
  401.     avctx->pix_fmt = AV_PIX_FMT_YUV420P;
  402.  
  403.     if ((ret = ff_MPV_frame_start(s, avctx)) < 0) {
  404.         av_log(v->s.avctx, AV_LOG_ERROR, "ff_MPV_frame_start error\n");
  405.         avctx->pix_fmt = AV_PIX_FMT_RGB24;
  406.         return ret;
  407.     }
  408.  
  409.     ff_mpeg_er_frame_start(s);
  410.  
  411.     v->bits = buf_size * 8;
  412.  
  413.     v->end_mb_x = (w + 15) >> 4;
  414.     s->end_mb_y = (h + 15) >> 4;
  415.     if (v->respic & 1)
  416.         v->end_mb_x = v->end_mb_x + 1 >> 1;
  417.     if (v->respic & 2)
  418.         s->end_mb_y = s->end_mb_y + 1 >> 1;
  419.  
  420.     ff_vc1_decode_blocks(v);
  421.  
  422.     ff_er_frame_end(&s->er);
  423.  
  424.     ff_MPV_frame_end(s);
  425.  
  426.     f = &s->current_picture.f;
  427.  
  428.     if (v->respic == 3) {
  429.         ctx->dsp.upsample_plane(f->data[0], f->linesize[0], w,      h);
  430.         ctx->dsp.upsample_plane(f->data[1], f->linesize[1], w >> 1, h >> 1);
  431.         ctx->dsp.upsample_plane(f->data[2], f->linesize[2], w >> 1, h >> 1);
  432.     } else if (v->respic)
  433.         avpriv_request_sample(v->s.avctx,
  434.                               "Asymmetric WMV9 rectangle subsampling");
  435.  
  436.     av_assert0(f->linesize[1] == f->linesize[2]);
  437.  
  438.     if (wmv9_mask != -1)
  439.         ctx->dsp.mss2_blit_wmv9_masked(c->rgb_pic + y * c->rgb_stride + x * 3,
  440.                                        c->rgb_stride, wmv9_mask,
  441.                                        c->pal_pic + y * c->pal_stride + x,
  442.                                        c->pal_stride,
  443.                                        f->data[0], f->linesize[0],
  444.                                        f->data[1], f->data[2], f->linesize[1],
  445.                                        w, h);
  446.     else
  447.         ctx->dsp.mss2_blit_wmv9(c->rgb_pic + y * c->rgb_stride + x * 3,
  448.                                 c->rgb_stride,
  449.                                 f->data[0], f->linesize[0],
  450.                                 f->data[1], f->data[2], f->linesize[1],
  451.                                 w, h);
  452.  
  453.     avctx->pix_fmt = AV_PIX_FMT_RGB24;
  454.  
  455.     return 0;
  456. }
  457.  
  458. typedef struct Rectangle {
  459.     int coded, x, y, w, h;
  460. } Rectangle;
  461.  
  462. #define MAX_WMV9_RECTANGLES 20
  463. #define ARITH2_PADDING 2
  464.  
  465. static int mss2_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
  466.                              AVPacket *avpkt)
  467. {
  468.     const uint8_t *buf = avpkt->data;
  469.     int buf_size       = avpkt->size;
  470.     MSS2Context *ctx = avctx->priv_data;
  471.     MSS12Context *c  = &ctx->c;
  472.     AVFrame *frame   = data;
  473.     GetBitContext gb;
  474.     GetByteContext gB;
  475.     ArithCoder acoder;
  476.  
  477.     int keyframe, has_wmv9, has_mv, is_rle, is_555, ret;
  478.  
  479.     Rectangle wmv9rects[MAX_WMV9_RECTANGLES], *r;
  480.     int used_rects = 0, i, implicit_rect = 0, av_uninit(wmv9_mask);
  481.  
  482.     av_assert0(FF_INPUT_BUFFER_PADDING_SIZE >=
  483.                ARITH2_PADDING + (MIN_CACHE_BITS + 7) / 8);
  484.  
  485.     init_get_bits(&gb, buf, buf_size * 8);
  486.  
  487.     if (keyframe = get_bits1(&gb))
  488.         skip_bits(&gb, 7);
  489.     has_wmv9 = get_bits1(&gb);
  490.     has_mv   = keyframe ? 0 : get_bits1(&gb);
  491.     is_rle   = get_bits1(&gb);
  492.     is_555   = is_rle && get_bits1(&gb);
  493.     if (c->slice_split > 0)
  494.         ctx->split_position = c->slice_split;
  495.     else if (c->slice_split < 0) {
  496.         if (get_bits1(&gb)) {
  497.             if (get_bits1(&gb)) {
  498.                 if (get_bits1(&gb))
  499.                     ctx->split_position = get_bits(&gb, 16);
  500.                 else
  501.                     ctx->split_position = get_bits(&gb, 12);
  502.             } else
  503.                 ctx->split_position = get_bits(&gb, 8) << 4;
  504.         } else {
  505.             if (keyframe)
  506.                 ctx->split_position = avctx->height / 2;
  507.         }
  508.     } else
  509.         ctx->split_position = avctx->height;
  510.  
  511.     if (c->slice_split && (ctx->split_position < 1 - is_555 ||
  512.                            ctx->split_position > avctx->height - 1))
  513.         return AVERROR_INVALIDDATA;
  514.  
  515.     align_get_bits(&gb);
  516.     buf      += get_bits_count(&gb) >> 3;
  517.     buf_size -= get_bits_count(&gb) >> 3;
  518.  
  519.     if (buf_size < 1)
  520.         return AVERROR_INVALIDDATA;
  521.  
  522.     if (is_555 && (has_wmv9 || has_mv || c->slice_split && ctx->split_position))
  523.         return AVERROR_INVALIDDATA;
  524.  
  525.     avctx->pix_fmt = is_555 ? AV_PIX_FMT_RGB555 : AV_PIX_FMT_RGB24;
  526.     if (ctx->last_pic->format != avctx->pix_fmt)
  527.         av_frame_unref(ctx->last_pic);
  528.  
  529.     if (has_wmv9) {
  530.         bytestream2_init(&gB, buf, buf_size + ARITH2_PADDING);
  531.         arith2_init(&acoder, &gB);
  532.  
  533.         implicit_rect = !arith2_get_bit(&acoder);
  534.  
  535.         while (arith2_get_bit(&acoder)) {
  536.             if (used_rects == MAX_WMV9_RECTANGLES)
  537.                 return AVERROR_INVALIDDATA;
  538.             r = &wmv9rects[used_rects];
  539.             if (!used_rects)
  540.                 r->x = arith2_get_number(&acoder, avctx->width);
  541.             else
  542.                 r->x = arith2_get_number(&acoder, avctx->width -
  543.                                          wmv9rects[used_rects - 1].x) +
  544.                        wmv9rects[used_rects - 1].x;
  545.             r->y = arith2_get_number(&acoder, avctx->height);
  546.             r->w = arith2_get_number(&acoder, avctx->width  - r->x) + 1;
  547.             r->h = arith2_get_number(&acoder, avctx->height - r->y) + 1;
  548.             used_rects++;
  549.         }
  550.  
  551.         if (implicit_rect && used_rects) {
  552.             av_log(avctx, AV_LOG_ERROR, "implicit_rect && used_rects > 0\n");
  553.             return AVERROR_INVALIDDATA;
  554.         }
  555.  
  556.         if (implicit_rect) {
  557.             wmv9rects[0].x = 0;
  558.             wmv9rects[0].y = 0;
  559.             wmv9rects[0].w = avctx->width;
  560.             wmv9rects[0].h = avctx->height;
  561.  
  562.             used_rects = 1;
  563.         }
  564.         for (i = 0; i < used_rects; i++) {
  565.             if (!implicit_rect && arith2_get_bit(&acoder)) {
  566.                 av_log(avctx, AV_LOG_ERROR, "Unexpected grandchildren\n");
  567.                 return AVERROR_INVALIDDATA;
  568.             }
  569.             if (!i) {
  570.                 wmv9_mask = arith2_get_bit(&acoder) - 1;
  571.                 if (!wmv9_mask)
  572.                     wmv9_mask = arith2_get_number(&acoder, 256);
  573.             }
  574.             wmv9rects[i].coded = arith2_get_number(&acoder, 2);
  575.         }
  576.  
  577.         buf      += arith2_get_consumed_bytes(&acoder);
  578.         buf_size -= arith2_get_consumed_bytes(&acoder);
  579.         if (buf_size < 1)
  580.             return AVERROR_INVALIDDATA;
  581.     }
  582.  
  583.     c->mvX = c->mvY = 0;
  584.     if (keyframe && !is_555) {
  585.         if ((i = decode_pal_v2(c, buf, buf_size)) < 0)
  586.             return AVERROR_INVALIDDATA;
  587.         buf      += i;
  588.         buf_size -= i;
  589.     } else if (has_mv) {
  590.         buf      += 4;
  591.         buf_size -= 4;
  592.         if (buf_size < 1)
  593.             return AVERROR_INVALIDDATA;
  594.         c->mvX = AV_RB16(buf - 4) - avctx->width;
  595.         c->mvY = AV_RB16(buf - 2) - avctx->height;
  596.     }
  597.  
  598.     if (c->mvX < 0 || c->mvY < 0) {
  599.         FFSWAP(uint8_t *, c->pal_pic, c->last_pal_pic);
  600.  
  601.         if ((ret = ff_get_buffer(avctx, frame, AV_GET_BUFFER_FLAG_REF)) < 0)
  602.             return ret;
  603.  
  604.         if (ctx->last_pic->data[0]) {
  605.             av_assert0(frame->linesize[0] == ctx->last_pic->linesize[0]);
  606.             c->last_rgb_pic = ctx->last_pic->data[0] +
  607.                               ctx->last_pic->linesize[0] * (avctx->height - 1);
  608.         } else {
  609.             av_log(avctx, AV_LOG_ERROR, "Missing keyframe\n");
  610.             return AVERROR_INVALIDDATA;
  611.         }
  612.     } else {
  613.         if ((ret = ff_reget_buffer(avctx, ctx->last_pic)) < 0)
  614.             return ret;
  615.         if ((ret = av_frame_ref(frame, ctx->last_pic)) < 0)
  616.             return ret;
  617.  
  618.         c->last_rgb_pic = NULL;
  619.     }
  620.     c->rgb_pic    = frame->data[0] +
  621.                     frame->linesize[0] * (avctx->height - 1);
  622.     c->rgb_stride = -frame->linesize[0];
  623.  
  624.     frame->key_frame = keyframe;
  625.     frame->pict_type = keyframe ? AV_PICTURE_TYPE_I : AV_PICTURE_TYPE_P;
  626.  
  627.     if (is_555) {
  628.         bytestream2_init(&gB, buf, buf_size);
  629.  
  630.         if (decode_555(&gB, (uint16_t *)c->rgb_pic, c->rgb_stride >> 1,
  631.                        keyframe, avctx->width, avctx->height))
  632.             return AVERROR_INVALIDDATA;
  633.  
  634.         buf_size -= bytestream2_tell(&gB);
  635.     } else {
  636.         if (keyframe) {
  637.             c->corrupted = 0;
  638.             ff_mss12_slicecontext_reset(&ctx->sc[0]);
  639.             if (c->slice_split)
  640.                 ff_mss12_slicecontext_reset(&ctx->sc[1]);
  641.         }
  642.         if (is_rle) {
  643.             init_get_bits(&gb, buf, buf_size * 8);
  644.             if (ret = decode_rle(&gb, c->pal_pic, c->pal_stride,
  645.                                  c->rgb_pic, c->rgb_stride, c->pal, keyframe,
  646.                                  ctx->split_position, 0,
  647.                                  avctx->width, avctx->height))
  648.                 return ret;
  649.             align_get_bits(&gb);
  650.  
  651.             if (c->slice_split)
  652.                 if (ret = decode_rle(&gb, c->pal_pic, c->pal_stride,
  653.                                      c->rgb_pic, c->rgb_stride, c->pal, keyframe,
  654.                                      ctx->split_position, 1,
  655.                                      avctx->width, avctx->height))
  656.                     return ret;
  657.  
  658.             align_get_bits(&gb);
  659.             buf      += get_bits_count(&gb) >> 3;
  660.             buf_size -= get_bits_count(&gb) >> 3;
  661.         } else if (!implicit_rect || wmv9_mask != -1) {
  662.             if (c->corrupted)
  663.                 return AVERROR_INVALIDDATA;
  664.             bytestream2_init(&gB, buf, buf_size + ARITH2_PADDING);
  665.             arith2_init(&acoder, &gB);
  666.             c->keyframe = keyframe;
  667.             if (c->corrupted = ff_mss12_decode_rect(&ctx->sc[0], &acoder, 0, 0,
  668.                                                     avctx->width,
  669.                                                     ctx->split_position))
  670.                 return AVERROR_INVALIDDATA;
  671.  
  672.             buf      += arith2_get_consumed_bytes(&acoder);
  673.             buf_size -= arith2_get_consumed_bytes(&acoder);
  674.             if (c->slice_split) {
  675.                 if (buf_size < 1)
  676.                     return AVERROR_INVALIDDATA;
  677.                 bytestream2_init(&gB, buf, buf_size + ARITH2_PADDING);
  678.                 arith2_init(&acoder, &gB);
  679.                 if (c->corrupted = ff_mss12_decode_rect(&ctx->sc[1], &acoder, 0,
  680.                                                         ctx->split_position,
  681.                                                         avctx->width,
  682.                                                         avctx->height - ctx->split_position))
  683.                     return AVERROR_INVALIDDATA;
  684.  
  685.                 buf      += arith2_get_consumed_bytes(&acoder);
  686.                 buf_size -= arith2_get_consumed_bytes(&acoder);
  687.             }
  688.         } else
  689.             memset(c->pal_pic, 0, c->pal_stride * avctx->height);
  690.     }
  691.  
  692.     if (has_wmv9) {
  693.         for (i = 0; i < used_rects; i++) {
  694.             int x = wmv9rects[i].x;
  695.             int y = wmv9rects[i].y;
  696.             int w = wmv9rects[i].w;
  697.             int h = wmv9rects[i].h;
  698.             if (wmv9rects[i].coded) {
  699.                 int WMV9codedFrameSize;
  700.                 if (buf_size < 4 || !(WMV9codedFrameSize = AV_RL24(buf)))
  701.                     return AVERROR_INVALIDDATA;
  702.                 if (ret = decode_wmv9(avctx, buf + 3, buf_size - 3,
  703.                                       x, y, w, h, wmv9_mask))
  704.                     return ret;
  705.                 buf      += WMV9codedFrameSize + 3;
  706.                 buf_size -= WMV9codedFrameSize + 3;
  707.             } else {
  708.                 uint8_t *dst = c->rgb_pic + y * c->rgb_stride + x * 3;
  709.                 if (wmv9_mask != -1) {
  710.                     ctx->dsp.mss2_gray_fill_masked(dst, c->rgb_stride,
  711.                                                    wmv9_mask,
  712.                                                    c->pal_pic + y * c->pal_stride + x,
  713.                                                    c->pal_stride,
  714.                                                    w, h);
  715.                 } else {
  716.                     do {
  717.                         memset(dst, 0x80, w * 3);
  718.                         dst += c->rgb_stride;
  719.                     } while (--h);
  720.                 }
  721.             }
  722.         }
  723.     }
  724.  
  725.     if (buf_size)
  726.         av_log(avctx, AV_LOG_WARNING, "buffer not fully consumed\n");
  727.  
  728.     if (c->mvX < 0 || c->mvY < 0) {
  729.         av_frame_unref(ctx->last_pic);
  730.         ret = av_frame_ref(ctx->last_pic, frame);
  731.         if (ret < 0)
  732.             return ret;
  733.     }
  734.  
  735.     *got_frame       = 1;
  736.  
  737.     return avpkt->size;
  738. }
  739.  
  740. static av_cold int wmv9_init(AVCodecContext *avctx)
  741. {
  742.     VC1Context *v = avctx->priv_data;
  743.     int ret;
  744.  
  745.     v->s.avctx    = avctx;
  746.     avctx->flags |= CODEC_FLAG_EMU_EDGE;
  747.     v->s.flags   |= CODEC_FLAG_EMU_EDGE;
  748.  
  749.     if ((ret = ff_vc1_init_common(v)) < 0)
  750.         return ret;
  751.     ff_vc1dsp_init(&v->vc1dsp);
  752.  
  753.     v->profile = PROFILE_MAIN;
  754.  
  755.     v->zz_8x4     = ff_wmv2_scantableA;
  756.     v->zz_4x8     = ff_wmv2_scantableB;
  757.     v->res_y411   = 0;
  758.     v->res_sprite = 0;
  759.  
  760.     v->frmrtq_postproc = 7;
  761.     v->bitrtq_postproc = 31;
  762.  
  763.     v->res_x8          = 0;
  764.     v->multires        = 0;
  765.     v->res_fasttx      = 1;
  766.  
  767.     v->fastuvmc        = 0;
  768.  
  769.     v->extended_mv     = 0;
  770.  
  771.     v->dquant          = 1;
  772.     v->vstransform     = 1;
  773.  
  774.     v->res_transtab    = 0;
  775.  
  776.     v->overlap         = 0;
  777.  
  778.     v->s.resync_marker = 0;
  779.     v->rangered        = 0;
  780.  
  781.     v->s.max_b_frames = avctx->max_b_frames = 0;
  782.     v->quantizer_mode = 0;
  783.  
  784.     v->finterpflag = 0;
  785.  
  786.     v->res_rtm_flag = 1;
  787.  
  788.     ff_vc1_init_transposed_scantables(v);
  789.  
  790.     if ((ret = ff_msmpeg4_decode_init(avctx)) < 0 ||
  791.         (ret = ff_vc1_decode_init_alloc_tables(v)) < 0)
  792.         return ret;
  793.  
  794.     /* error concealment */
  795.     v->s.me.qpel_put = v->s.dsp.put_qpel_pixels_tab;
  796.     v->s.me.qpel_avg = v->s.dsp.avg_qpel_pixels_tab;
  797.  
  798.     return 0;
  799. }
  800.  
  801. static av_cold int mss2_decode_end(AVCodecContext *avctx)
  802. {
  803.     MSS2Context *const ctx = avctx->priv_data;
  804.  
  805.     av_frame_free(&ctx->last_pic);
  806.  
  807.     ff_mss12_decode_end(&ctx->c);
  808.     av_freep(&ctx->c.pal_pic);
  809.     av_freep(&ctx->c.last_pal_pic);
  810.     ff_vc1_decode_end(avctx);
  811.  
  812.     return 0;
  813. }
  814.  
  815. static av_cold int mss2_decode_init(AVCodecContext *avctx)
  816. {
  817.     MSS2Context * const ctx = avctx->priv_data;
  818.     MSS12Context *c = &ctx->c;
  819.     int ret;
  820.     c->avctx = avctx;
  821.     if (ret = ff_mss12_decode_init(c, 1, &ctx->sc[0], &ctx->sc[1]))
  822.         return ret;
  823.     ctx->last_pic   = av_frame_alloc();
  824.     c->pal_stride   = c->mask_stride;
  825.     c->pal_pic      = av_mallocz(c->pal_stride * avctx->height);
  826.     c->last_pal_pic = av_mallocz(c->pal_stride * avctx->height);
  827.     if (!c->pal_pic || !c->last_pal_pic || !ctx->last_pic) {
  828.         mss2_decode_end(avctx);
  829.         return AVERROR(ENOMEM);
  830.     }
  831.     if (ret = wmv9_init(avctx)) {
  832.         mss2_decode_end(avctx);
  833.         return ret;
  834.     }
  835.     ff_mss2dsp_init(&ctx->dsp);
  836.  
  837.     avctx->pix_fmt = c->free_colours == 127 ? AV_PIX_FMT_RGB555
  838.                                             : AV_PIX_FMT_RGB24;
  839.  
  840.     return 0;
  841. }
  842.  
  843. AVCodec ff_mss2_decoder = {
  844.     .name           = "mss2",
  845.     .long_name      = NULL_IF_CONFIG_SMALL("MS Windows Media Video V9 Screen"),
  846.     .type           = AVMEDIA_TYPE_VIDEO,
  847.     .id             = AV_CODEC_ID_MSS2,
  848.     .priv_data_size = sizeof(MSS2Context),
  849.     .init           = mss2_decode_init,
  850.     .close          = mss2_decode_end,
  851.     .decode         = mss2_decode_frame,
  852.     .capabilities   = CODEC_CAP_DR1,
  853. };
  854.