@@ -45,6 +45,7 @@ version <next>:

 - avconv -shortest option is now per-output file,

   -pass and -passlogfile are now per-output stream

 - Ut Video encoder

+- Microsoft Screen 2 decoder

 version 0.8:

@@ -1479,6 +1479,7 @@ msmpeg4v2_decoder_select="h263_decoder"

 msmpeg4v2_encoder_select="h263_encoder"

 msmpeg4v3_decoder_select="h263_decoder"

 msmpeg4v3_encoder_select="h263_encoder"

+mss2_decoder_select="vc1_decoder"

 nellymoser_decoder_select="mdct sinewin"

 nellymoser_encoder_select="mdct sinewin"

 png_decoder_select="zlib"

@@ -547,6 +547,8 @@ following image formats are supported:

 @item Microsoft RLE          @tab     @tab  X

 @item Microsoft Screen 1     @tab     @tab  X

     @tab Also known as Windows Media Video V7 Screen.

+@item Microsoft Screen 2     @tab     @tab  X

+    @tab Also known as Windows Media Video V9 Screen.

 @item Microsoft Video 1      @tab     @tab  X

 @item Mimic                  @tab     @tab  X

     @tab Used in MSN Messenger Webcam streams.

@@ -271,6 +271,7 @@ OBJS-$(CONFIG_MSMPEG4V3_ENCODER)       += msmpeg4.o msmpeg4enc.o msmpeg4data.o \

 OBJS-$(CONFIG_MSRLE_DECODER)           += msrle.o msrledec.o

 OBJS-$(CONFIG_MSA1_DECODER)            += mss3.o mss34dsp.o

 OBJS-$(CONFIG_MSS1_DECODER)            += mss1.o mss12.o

+OBJS-$(CONFIG_MSS2_DECODER)            += mss2.o mss12.o mss2dsp.o

 OBJS-$(CONFIG_MSVIDEO1_DECODER)        += msvideo1.o

 OBJS-$(CONFIG_MSZH_DECODER)            += lcldec.o

 OBJS-$(CONFIG_MTS2_DECODER)            += mss4.o mss34dsp.o

@@ -160,6 +160,7 @@ void avcodec_register_all(void)

     REGISTER_ENCDEC  (MSMPEG4V3, msmpeg4v3);

     REGISTER_DECODER (MSRLE, msrle);

     REGISTER_DECODER (MSS1, mss1);

+    REGISTER_DECODER (MSS2, mss2);

     REGISTER_DECODER (MSVIDEO1, msvideo1);

     REGISTER_DECODER (MSZH, mszh);

     REGISTER_DECODER (MTS2, mts2);

@@ -264,6 +264,7 @@ enum AVCodecID {

     AV_CODEC_ID_TSCC2,

     AV_CODEC_ID_MTS2,

     AV_CODEC_ID_CLLC,

+    AV_CODEC_ID_MSS2,

     /* various PCM "codecs" */

     AV_CODEC_ID_FIRST_AUDIO = 0x10000,     ///< A dummy id pointing at the start of audio codecs

@@ -1200,6 +1200,13 @@ static const AVCodecDescriptor codec_descriptors[] = {

         .long_name = NULL_IF_CONFIG_SMALL("Canopus Lossless Codec"),

         .props     = AV_CODEC_PROP_INTRA_ONLY | AV_CODEC_PROP_LOSSLESS,

     },

+    {

+        .id        = AV_CODEC_ID_MSS2,

+        .type      = AVMEDIA_TYPE_VIDEO,

+        .name      = "mss2",

+        .long_name = NULL_IF_CONFIG_SMALL("MS Windows Media Video V9 Screen"),

+        .props     = AV_CODEC_PROP_INTRA_ONLY | AV_CODEC_PROP_LOSSY,

+    },

     /* various PCM "codecs" */

     {

@@ -58,7 +58,10 @@ av_cold int ff_h263_decode_init(AVCodecContext *avctx)

     s->quant_precision=5;

     s->decode_mb= ff_h263_decode_mb;

     s->low_delay= 1;

-    avctx->pix_fmt= avctx->get_format(avctx, avctx->codec->pix_fmts);

+    if (avctx->codec->id == AV_CODEC_ID_MSS2)

+        avctx->pix_fmt = PIX_FMT_YUV420P;

+    else

+        avctx->pix_fmt = avctx->get_format(avctx, avctx->codec->pix_fmts);

     s->unrestricted_mv= 1;

     /* select sub codec */

@@ -93,6 +96,7 @@ av_cold int ff_h263_decode_init(AVCodecContext *avctx)

     case AV_CODEC_ID_WMV3:

     case AV_CODEC_ID_VC1IMAGE:

     case AV_CODEC_ID_WMV3IMAGE:

+    case AV_CODEC_ID_MSS2:

         s->h263_pred = 1;

         s->msmpeg4_version=6;

         avctx->chroma_sample_location = AVCHROMA_LOC_LEFT;

@@ -226,10 +226,11 @@ void ff_copy_picture(Picture *dst, Picture *src)

  */

 static void free_frame_buffer(MpegEncContext *s, Picture *pic)

 {

-    /* Windows Media Image codecs allocate internal buffers with different

-     * dimensions; ignore user defined callbacks for these

-     */

-    if (s->codec_id != AV_CODEC_ID_WMV3IMAGE && s->codec_id != AV_CODEC_ID_VC1IMAGE)

+    /* WM Image / Screen codecs allocate internal buffers with different

+     * dimensions / colorspaces; ignore user-defined callbacks for these. */

+    if (s->codec_id != AV_CODEC_ID_WMV3IMAGE &&

+        s->codec_id != AV_CODEC_ID_VC1IMAGE  &&

+        s->codec_id != AV_CODEC_ID_MSS2)

         ff_thread_release_buffer(s->avctx, &pic->f);

     else

         avcodec_default_release_buffer(s->avctx, &pic->f);

@@ -254,7 +255,9 @@ static int alloc_frame_buffer(MpegEncContext *s, Picture *pic)

         }

     }

-    if (s->codec_id != AV_CODEC_ID_WMV3IMAGE && s->codec_id != AV_CODEC_ID_VC1IMAGE)

+    if (s->codec_id != AV_CODEC_ID_WMV3IMAGE &&

+        s->codec_id != AV_CODEC_ID_VC1IMAGE  &&

+        s->codec_id != AV_CODEC_ID_MSS2)

         r = ff_thread_get_buffer(s->avctx, &pic->f);

     else

         r = avcodec_default_get_buffer(s->avctx, &pic->f);

@@ -24,14 +24,13 @@

  * Microsoft Screen 1 (aka Windows Media Video V7 Screen) decoder

  */

-#include "libavutil/intfloat.h"

-#include "libavutil/intreadwrite.h"

 #include "avcodec.h"

 #include "mss12.h"

 typedef struct MSS1Context {

     MSS12Context   ctx;

     AVFrame        pic;

+    SliceContext   sc[2];

 } MSS1Context;

 static void arith_normalise(ArithCoder *c)

@@ -56,24 +55,11 @@ static void arith_normalise(ArithCoder *c)

         c->low   <<= 1;

         c->high  <<= 1;

         c->high   |= 1;

-        c->value  |= get_bits1(c->gb);

+        c->value  |= get_bits1(c->gbc.gb);

     }

 }

-static int arith_get_bit(ArithCoder *c)

-{

-    int range = c->high - c->low + 1;

-    int bit   = (((c->value - c->low) << 1) + 1) / range;

-

-    if (bit)

-        c->low += range >> 1;

-    else

-        c->high = c->low + (range >> 1) - 1;

-

-    arith_normalise(c);

-

-    return bit;

-}

+ARITH_GET_BIT()

 static int arith_get_bits(ArithCoder *c, int bits)

 {

@@ -118,40 +104,27 @@ static int arith_get_prob(ArithCoder *c, int *probs)

     return sym;

 }

-static int arith_get_model_sym(ArithCoder *c, Model *m)

-{

-    int idx, val;

-

-    idx = arith_get_prob(c, m->cum_prob);

-

-    val = m->idx2sym[idx];

-    ff_mss12_model_update(m, idx);

-

-    arith_normalise(c);

-

-    return val;

-}

+ARITH_GET_MODEL_SYM()

 static void arith_init(ArithCoder *c, GetBitContext *gb)

 {

-    c->low   = 0;

-    c->high  = 0xFFFF;

-    c->value = get_bits(gb, 16);

-    c->gb    = gb;

-

+    c->low           = 0;

+    c->high          = 0xFFFF;

+    c->value         = get_bits(gb, 16);

+    c->gbc.gb        = gb;

     c->get_model_sym = arith_get_model_sym;

     c->get_number    = arith_get_number;

 }

-static int decode_pal(MSS1Context *ctx, ArithCoder *acoder)

+static int decode_pal(MSS12Context *ctx, ArithCoder *acoder)

 {

     int i, ncol, r, g, b;

-    uint32_t *pal = ctx->ctx.pal + 256 - ctx->ctx.free_colours;

+    uint32_t *pal = ctx->pal + 256 - ctx->free_colours;

-    if (!ctx->ctx.free_colours)

+    if (!ctx->free_colours)

         return 0;

-    ncol = arith_get_number(acoder, ctx->ctx.free_colours + 1);

+    ncol = arith_get_number(acoder, ctx->free_colours + 1);

     for (i = 0; i < ncol; i++) {

         r = arith_get_bits(acoder, 8);

         g = arith_get_bits(acoder, 8);

@@ -167,7 +140,8 @@ static int mss1_decode_frame(AVCodecContext *avctx, void *data, int *data_size,

 {

     const uint8_t *buf = avpkt->data;

     int buf_size = avpkt->size;

-    MSS1Context *c = avctx->priv_data;

+    MSS1Context *ctx = avctx->priv_data;

+    MSS12Context *c = &ctx->ctx;

     GetBitContext gb;

     ArithCoder acoder;

     int pal_changed = 0;

@@ -176,37 +150,37 @@ static int mss1_decode_frame(AVCodecContext *avctx, void *data, int *data_size,

     init_get_bits(&gb, buf, buf_size * 8);

     arith_init(&acoder, &gb);

-    c->pic.reference    = 3;

-    c->pic.buffer_hints = FF_BUFFER_HINTS_VALID | FF_BUFFER_HINTS_PRESERVE |

-                          FF_BUFFER_HINTS_REUSABLE;

-    if ((ret = avctx->reget_buffer(avctx, &c->pic)) < 0) {

+    ctx->pic.reference    = 3;

+    ctx->pic.buffer_hints = FF_BUFFER_HINTS_VALID | FF_BUFFER_HINTS_READABLE |

+                            FF_BUFFER_HINTS_PRESERVE | FF_BUFFER_HINTS_REUSABLE;

+    if ((ret = avctx->reget_buffer(avctx, &ctx->pic)) < 0) {

         av_log(avctx, AV_LOG_ERROR, "reget_buffer() failed\n");

         return ret;

     }

-    c->ctx.pic_start  = c->pic.data[0] + c->pic.linesize[0] * (avctx->height - 1);

-    c->ctx.pic_stride = -c->pic.linesize[0];

-    c->ctx.keyframe   = !arith_get_bit(&acoder);

-    if (c->ctx.keyframe) {

-        ff_mss12_codec_reset(&c->ctx);

-        pal_changed      = decode_pal(c, &acoder);

-        c->pic.key_frame = 1;

-        c->pic.pict_type = AV_PICTURE_TYPE_I;

+    c->pal_pic    =  ctx->pic.data[0] + ctx->pic.linesize[0] * (avctx->height - 1);

+    c->pal_stride = -ctx->pic.linesize[0];

+    c->keyframe   = !arith_get_bit(&acoder);

+    if (c->keyframe) {

+        ff_mss12_codec_reset(c);

+        pal_changed        = decode_pal(c, &acoder);

+        ctx->pic.key_frame = 1;

+        ctx->pic.pict_type = AV_PICTURE_TYPE_I;

     } else {

-        if (c->ctx.corrupted)

+        if (c->corrupted)

             return AVERROR_INVALIDDATA;

-        c->pic.key_frame = 0;

-        c->pic.pict_type = AV_PICTURE_TYPE_P;

+        ctx->pic.key_frame = 0;

+        ctx->pic.pict_type = AV_PICTURE_TYPE_P;

     }

-    c->ctx.corrupted = ff_mss12_decode_rect(&c->ctx, &acoder, 0, 0,

-                                            avctx->width, avctx->height);

-    if (c->ctx.corrupted)

+    c->corrupted = ff_mss12_decode_rect(&c->sc[0], &acoder, 0, 0,

+                                        avctx->width, avctx->height);

+    if (c->corrupted)

         return AVERROR_INVALIDDATA;

-    memcpy(c->pic.data[1], c->ctx.pal, AVPALETTE_SIZE);

-    c->pic.palette_has_changed = pal_changed;

+    memcpy(ctx->pic.data[1], c->pal, AVPALETTE_SIZE);

+    ctx->pic.palette_has_changed = pal_changed;

     *data_size = sizeof(AVFrame);

-    *(AVFrame*)data = c->pic;

+    *(AVFrame*)data = ctx->pic;

     /* always report that the buffer was completely consumed */

     return buf_size;

@@ -219,16 +193,16 @@ static av_cold int mss1_decode_init(AVCodecContext *avctx)

     c->ctx.avctx       = avctx;

     avctx->coded_frame = &c->pic;

-    return ff_mss12_decode_init(avctx, 0);

+    return ff_mss12_decode_init(&c->ctx, 0);

 }

 static av_cold int mss1_decode_end(AVCodecContext *avctx)

 {

-    MSS1Context * const c = avctx->priv_data;

+    MSS1Context * const ctx = avctx->priv_data;

-    if (c->pic.data[0])

-        avctx->release_buffer(avctx, &c->pic);

-    ff_mss12_decode_end(avctx);

+    if (ctx->pic.data[0])

+        avctx->release_buffer(avctx, &ctx->pic);

+    ff_mss12_decode_end(&ctx->ctx);

     return 0;

 }

@@ -47,12 +47,8 @@ static int model_calc_threshold(Model *m)

 {

     int thr;

-    if (m->thr_weight == -1) {

-        thr = 2 * m->weights[m->num_syms] - 1;

-        thr = ((thr >> 1) + 4 * m->cum_prob[0]) / thr;

-    } else {

-        thr = m->num_syms * m->thr_weight;

-    }

+    thr = 2 * m->weights[m->num_syms] - 1;

+    thr = ((thr >> 1) + 4 * m->cum_prob[0]) / thr;

     return FFMIN(thr, 0x3FFF);

 }

@@ -78,7 +74,7 @@ static av_cold void model_init(Model *m, int num_syms, int thr_weight)

 {

     m->num_syms   = num_syms;

     m->thr_weight = thr_weight;

-    m->threshold  = model_calc_threshold(m);

+    m->threshold  = num_syms * thr_weight;

     model_reset(m);

 }

@@ -87,7 +83,7 @@ static void model_rescale_weights(Model *m)

     int i;

     int cum_prob;

-    if (m->thr_weight == -1)

+    if (m->thr_weight == THRESH_ADAPTIVE)

         m->threshold = model_calc_threshold(m);

     while (m->cum_prob[0] > m->threshold) {

         cum_prob = 0;

@@ -129,8 +125,14 @@ static void pixctx_reset(PixContext *ctx)

 {

     int i, j, k;

-    for (i = 0; i < ctx->cache_size; i++)

-        ctx->cache[i] = i;

+    if (!ctx->special_initial_cache)

+        for (i = 0; i < ctx->cache_size; i++)

+            ctx->cache[i] = i;

+    else {

+        ctx->cache[0] = 1;

+        ctx->cache[1] = 2;

+        ctx->cache[2] = 4;

+    }

     model_reset(&ctx->cache_model);

     model_reset(&ctx->full_model);

@@ -141,27 +143,23 @@ static void pixctx_reset(PixContext *ctx)

                 model_reset(&ctx->sec_models[i][j][k]);

 }

-static av_cold void pixctx_init(PixContext *ctx, int cache_size)

+static av_cold void pixctx_init(PixContext *ctx, int cache_size,

+                                int full_model_syms, int special_initial_cache)

 {

     int i, j, k;

-    ctx->cache_size = cache_size + 4;

-    ctx->num_syms   = cache_size;

-

-    for (i = 0; i < ctx->cache_size; i++)

-        ctx->cache[i] = i;

+    ctx->cache_size            = cache_size + 4;

+    ctx->num_syms              = cache_size;

+    ctx->special_initial_cache = special_initial_cache;

     model_init(&ctx->cache_model, ctx->num_syms + 1, THRESH_LOW);

-    model_init(&ctx->full_model, 256, THRESH_HIGH);

+    model_init(&ctx->full_model, full_model_syms, THRESH_HIGH);

-    for (i = 0; i < 4; i++) {

-        for (j = 0; j < sec_order_sizes[i]; j++) {

-            for (k = 0; k < 4; k++) {

+    for (i = 0; i < 4; i++)

+        for (j = 0; j < sec_order_sizes[i]; j++)

+            for (k = 0; k < 4; k++)

                 model_init(&ctx->sec_models[i][j][k], 2 + i,

                            i ? THRESH_LOW : THRESH_ADAPTIVE);

-            }

-        }

-    }

 }

 static int decode_top_left_pixel(ArithCoder *acoder, PixContext *pctx)

@@ -196,7 +194,6 @@ static int decode_pixel(ArithCoder *acoder, PixContext *pctx,

     if (val < pctx->num_syms) {

         int idx, j;

-

         idx = 0;

         for (i = 0; i < pctx->cache_size; i++) {

             for (j = 0; j < num_ngb; j++)

@@ -309,195 +306,288 @@ static int decode_pixel_in_context(ArithCoder *acoder, PixContext *pctx,

         break;

     }

-    pix = acoder->get_model_sym(acoder, &pctx->sec_models[nlen - 1][layer][sub]);

+    pix = acoder->get_model_sym(acoder,

+                                &pctx->sec_models[nlen - 1][layer][sub]);

     if (pix < nlen)

         return ref_pix[pix];

     else

         return decode_pixel(acoder, pctx, ref_pix, nlen);

 }

-static int decode_region(MSS12Context *ctx, ArithCoder *acoder, uint8_t *dst,

+static int decode_region(ArithCoder *acoder, uint8_t *dst, uint8_t *rgb_pic,

                          int x, int y, int width, int height, int stride,

-                         PixContext *pctx)

+                         int rgb_stride, PixContext *pctx, const uint32_t *pal)

 {

-    int i, j;

+    int i, j, p;

+    uint8_t *rgb_dst = rgb_pic + x * 3 + y * rgb_stride;

     dst += x + y * stride;

-    dst[0] = decode_top_left_pixel(acoder, pctx);

     for (j = 0; j < height; j++) {

         for (i = 0; i < width; i++) {

             if (!i && !j)

-                continue;

+                p = decode_top_left_pixel(acoder, pctx);

+            else

+                p = decode_pixel_in_context(acoder, pctx, dst + i, stride,

+                                            i, j, width - i - 1);

+            dst[i] = p;

-            dst[i] = decode_pixel_in_context(acoder, pctx, dst + i, stride,

-                                             i, j, width - i - 1);

+            if (rgb_pic)

+                AV_WB24(rgb_dst + i * 3, pal[p]);

         }

-        dst += stride;

+        dst     += stride;

+        rgb_dst += rgb_stride;

     }

     return 0;

 }

-static int decode_region_masked(MSS12Context *ctx, ArithCoder *acoder,

+static void copy_rectangles(MSS12Context const *c,

+                            int x, int y, int width, int height)

+{

+    int j;

+

+    if (c->last_rgb_pic)

+        for (j = y; j < y + height; j++) {

+            memcpy(c->rgb_pic      + j * c->rgb_stride + x * 3,

+                   c->last_rgb_pic + j * c->rgb_stride + x * 3,

+                   width * 3);

+            memcpy(c->pal_pic      + j * c->pal_stride + x,

+                   c->last_pal_pic + j * c->pal_stride + x,

+                   width);

+        }

+}

+

+static int motion_compensation(MSS12Context const *c,

+                               int x, int y, int width, int height)

+{

+    if (x + c->mvX < 0 || x + c->mvX + width  > c->avctx->width  ||

+        y + c->mvY < 0 || y + c->mvY + height > c->avctx->height ||

+        !c->rgb_pic)

+        return -1;

+    else {

+        uint8_t *dst     = c->pal_pic + x     + y * c->pal_stride;

+        uint8_t *rgb_dst = c->rgb_pic + x * 3 + y * c->rgb_stride;

+        uint8_t *src;

+        uint8_t *rgb_src;

+        int j;

+        x += c->mvX;

+        y += c->mvY;

+        if (c->last_rgb_pic) {

+            src     = c->last_pal_pic + x +     y * c->pal_stride;

+            rgb_src = c->last_rgb_pic + x * 3 + y * c->rgb_stride;

+        } else {

+            src     = c->pal_pic + x     + y * c->pal_stride;

+            rgb_src = c->rgb_pic + x * 3 + y * c->rgb_stride;

+        }

+        for (j = 0; j < height; j++) {

+            memmove(dst, src, width);

+            memmove(rgb_dst, rgb_src, width * 3);

+            dst     += c->pal_stride;

+            src     += c->pal_stride;

+            rgb_dst += c->rgb_stride;

+            rgb_src += c->rgb_stride;

+        }

+    }

+    return 0;

+}

+

+static int decode_region_masked(MSS12Context const *c, ArithCoder *acoder,

                                 uint8_t *dst, int stride, uint8_t *mask,

                                 int mask_stride, int x, int y,

                                 int width, int height,

                                 PixContext *pctx)

 {

-    int i, j;

+    int i, j, p;

+    uint8_t *rgb_dst = c->rgb_pic + x * 3 + y * c->rgb_stride;

     dst  += x + y * stride;

     mask += x + y * mask_stride;

-    if (mask[0] == 0xFF)

-        dst[0] = decode_top_left_pixel(acoder, pctx);

     for (j = 0; j < height; j++) {

         for (i = 0; i < width; i++) {

-            if (!i && !j || mask[i] != 0xFF)

-                continue;

-

-            dst[i] = decode_pixel_in_context(acoder, pctx, dst + i, stride,

-                                             i, j, width - i - 1);

+            if (c->avctx->err_recognition & AV_EF_EXPLODE &&

+                ( c->rgb_pic && mask[i] != 0x01 && mask[i] != 0x02 && mask[i] != 0x04 ||

+                 !c->rgb_pic && mask[i] != 0x80 && mask[i] != 0xFF))

+                return -1;

+

+            if (mask[i] == 0x02) {

+                copy_rectangles(c, x + i, y + j, 1, 1);

+            } else if (mask[i] == 0x04) {

+                if (motion_compensation(c, x + i, y + j, 1, 1))

+                    return -1;

+            } else if (mask[i] != 0x80) {

+                if (!i && !j)

+                    p = decode_top_left_pixel(acoder, pctx);

+                else

+                    p = decode_pixel_in_context(acoder, pctx, dst + i, stride,

+                                                i, j, width - i - 1);

+                dst[i] = p;

+                if (c->rgb_pic)

+                    AV_WB24(rgb_dst + i * 3, c->pal[p]);

+            }

         }

-        dst  += stride;

-        mask += mask_stride;

+        dst     += stride;

+        mask    += mask_stride;

+        rgb_dst += c->rgb_stride;

     }

     return 0;

 }

-static av_cold void codec_init(MSS12Context *ctx)

+static av_cold void codec_init(MSS12Context *c, int version)

 {

-    model_init(&ctx->intra_region, 2, THRESH_ADAPTIVE);

-    model_init(&ctx->inter_region, 2, THRESH_ADAPTIVE);

-    model_init(&ctx->split_mode,   3, THRESH_HIGH);

-    model_init(&ctx->edge_mode,    2, THRESH_HIGH);

-    model_init(&ctx->pivot,        3, THRESH_LOW);

-    pixctx_init(&ctx->intra_pix_ctx, 8);

-    pixctx_init(&ctx->inter_pix_ctx, 2);

-    ctx->corrupted = 1;

+    int i;

+    for (i = 0; i < (c->slice_split ? 2 : 1); i++) {

+        c->sc[i].c = c;

+        model_init(&c->sc[i].intra_region, 2, THRESH_ADAPTIVE);

+        model_init(&c->sc[i].inter_region, 2, THRESH_ADAPTIVE);

+        model_init(&c->sc[i].split_mode,   3, THRESH_HIGH);

+        model_init(&c->sc[i].edge_mode,    2, THRESH_HIGH);

+        model_init(&c->sc[i].pivot,        3, THRESH_LOW);

+

+        pixctx_init(&c->sc[i].intra_pix_ctx, 8, c->full_model_syms, 0);

+

+        pixctx_init(&c->sc[i].inter_pix_ctx, version ? 3 : 2,

+                    c->full_model_syms, version ? 1 : 0);

+    }

+    c->corrupted = 1;

 }

-void ff_mss12_codec_reset(MSS12Context *ctx)

+void ff_mss12_codec_reset(MSS12Context *c)

 {

-    model_reset(&ctx->intra_region);

-    model_reset(&ctx->inter_region);

-    model_reset(&ctx->split_mode);

-    model_reset(&ctx->edge_mode);

-    model_reset(&ctx->pivot);

-    pixctx_reset(&ctx->intra_pix_ctx);

-    pixctx_reset(&ctx->inter_pix_ctx);

-

-    ctx->corrupted = 0;

+    int i;

+    for (i = 0; i < (c->slice_split ? 2 : 1); i++) {

+        model_reset(&c->sc[i].intra_region);

+        model_reset(&c->sc[i].inter_region);

+        model_reset(&c->sc[i].split_mode);

+        model_reset(&c->sc[i].edge_mode);

+        model_reset(&c->sc[i].pivot);

+        pixctx_reset(&c->sc[i].intra_pix_ctx);

+        pixctx_reset(&c->sc[i].inter_pix_ctx);

+    }

+

+    c->corrupted = 0;

 }

-static int decode_pivot(MSS12Context *ctx, ArithCoder *acoder, int base)

+static int decode_pivot(SliceContext *sc, ArithCoder *acoder, int base)

 {

     int val, inv;

-    inv = acoder->get_model_sym(acoder, &ctx->edge_mode);

-    val = acoder->get_model_sym(acoder, &ctx->pivot) + 1;

+    inv = acoder->get_model_sym(acoder, &sc->edge_mode);

+    val = acoder->get_model_sym(acoder, &sc->pivot) + 1;

     if (val > 2) {

-        if ((base + 1) / 2 - 2 <= 0) {

-            ctx->corrupted = 1;

-            return 0;

-        }

+        if ((base + 1) / 2 - 2 <= 0)

+            return -1;

+

         val = acoder->get_number(acoder, (base + 1) / 2 - 2) + 3;

     }

-    if (val == base) {

-        ctx->corrupted = 1;

-        return 0;

-    }

+    if (val >= base)

+        return -1;

     return inv ? base - val : val;

 }

-static int decode_region_intra(MSS12Context *ctx, ArithCoder *acoder,

+static int decode_region_intra(SliceContext *sc, ArithCoder *acoder,

                                int x, int y, int width, int height)

 {

+    MSS12Context const *c = sc->c;

     int mode;

-    mode = acoder->get_model_sym(acoder, &ctx->intra_region);

+    mode = acoder->get_model_sym(acoder, &sc->intra_region);

     if (!mode) {

-        int i, pix;

-        int stride = ctx->pic_stride;

-        uint8_t *dst = ctx->pic_start + x + y * stride;

-

-        pix = decode_top_left_pixel(acoder, &ctx->intra_pix_ctx);

-        for (i = 0; i < height; i++, dst += stride)

+        int i, j, pix, rgb_pix;

+        int stride       = c->pal_stride;

+        int rgb_stride   = c->rgb_stride;

+        uint8_t *dst     = c->pal_pic + x     + y * stride;

+        uint8_t *rgb_dst = c->rgb_pic + x * 3 + y * rgb_stride;

+

+        pix     = decode_top_left_pixel(acoder, &sc->intra_pix_ctx);

+        rgb_pix = c->pal[pix];

+        for (i = 0; i < height; i++, dst += stride, rgb_dst += rgb_stride) {

             memset(dst, pix, width);

+            if (c->rgb_pic)

+                for (j = 0; j < width * 3; j += 3)

+                    AV_WB24(rgb_dst + j, rgb_pix);

+        }

     } else {

-        return decode_region(ctx, acoder, ctx->pic_start,

-                             x, y, width, height, ctx->pic_stride,

-                             &ctx->intra_pix_ctx);

+        return decode_region(acoder, c->pal_pic, c->rgb_pic,

+                             x, y, width, height, c->pal_stride, c->rgb_stride,

+                             &sc->intra_pix_ctx, &c->pal[0]);

     }

     return 0;

 }

-static int decode_region_inter(MSS12Context *ctx, ArithCoder *acoder,

+static int decode_region_inter(SliceContext *sc, ArithCoder *acoder,

                                int x, int y, int width, int height)

 {

+    MSS12Context const *c = sc->c;

     int mode;

-    mode = acoder->get_model_sym(acoder, &ctx->inter_region);

+    mode = acoder->get_model_sym(acoder, &sc->inter_region);

     if (!mode) {

-        mode = decode_top_left_pixel(acoder, &ctx->inter_pix_ctx);

-        if (mode != 0xFF) {

-            return 0;

-        } else {

-            return decode_region_intra(ctx, acoder, x, y, width, height);

-        }

+        mode = decode_top_left_pixel(acoder, &sc->inter_pix_ctx);

+

+        if (c->avctx->err_recognition & AV_EF_EXPLODE &&

+            ( c->rgb_pic && mode != 0x01 && mode != 0x02 && mode != 0x04 ||

+             !c->rgb_pic && mode != 0x80 && mode != 0xFF))

+            return -1;

+

+        if (mode == 0x02)

+            copy_rectangles(c, x, y, width, height);

+        else if (mode == 0x04)

+            return motion_compensation(c, x, y, width, height);

+        else if (mode != 0x80)

+            return decode_region_intra(sc, acoder, x, y, width, height);

     } else {

-        if (decode_region(ctx, acoder, ctx->mask,

-                          x, y, width, height, ctx->mask_linesize,

-                          &ctx->inter_pix_ctx) < 0)

+        if (decode_region(acoder, c->mask, NULL,

+                          x, y, width, height, c->mask_stride, 0,

+                          &sc->inter_pix_ctx, &c->pal[0]) < 0)

             return -1;

-        return decode_region_masked(ctx, acoder, ctx->pic_start,

-                                    ctx->pic_stride, ctx->mask,

-                                    ctx->mask_linesize,

+        return decode_region_masked(c, acoder, c->pal_pic,

+                                    c->pal_stride, c->mask,

+                                    c->mask_stride,

                                     x, y, width, height,

-                                    &ctx->intra_pix_ctx);

+                                    &sc->intra_pix_ctx);

     }

     return 0;

 }

-int ff_mss12_decode_rect(MSS12Context *ctx, ArithCoder *acoder,

+int ff_mss12_decode_rect(SliceContext *sc, ArithCoder *acoder,

                          int x, int y, int width, int height)

 {

     int mode, pivot;

-    if (ctx->corrupted)

-        return -1;

-

-    mode = acoder->get_model_sym(acoder, &ctx->split_mode);

+    mode = acoder->get_model_sym(acoder, &sc->split_mode);

     switch (mode) {

     case SPLIT_VERT:

-        pivot = decode_pivot(ctx, acoder, height);

-        if (ff_mss12_decode_rect(ctx, acoder, x, y, width, pivot))

+        if ((pivot = decode_pivot(sc, acoder, height)) < 1)

             return -1;

-        if (ff_mss12_decode_rect(ctx, acoder, x, y + pivot, width, height - pivot))

+        if (ff_mss12_decode_rect(sc, acoder, x, y, width, pivot))

+            return -1;

+        if (ff_mss12_decode_rect(sc, acoder, x, y + pivot, width, height - pivot))

             return -1;

         break;

     case SPLIT_HOR:

-        pivot = decode_pivot(ctx, acoder, width);

-        if (ff_mss12_decode_rect(ctx, acoder, x, y, pivot, height))

+        if ((pivot = decode_pivot(sc, acoder, width)) < 1)

+            return -1;

+        if (ff_mss12_decode_rect(sc, acoder, x, y, pivot, height))

             return -1;

-        if (ff_mss12_decode_rect(ctx, acoder, x + pivot, y, width - pivot, height))

+        if (ff_mss12_decode_rect(sc, acoder, x + pivot, y, width - pivot, height))

             return -1;

         break;

     case SPLIT_NONE:

-        if (ctx->keyframe)

-            return decode_region_intra(ctx, acoder, x, y, width, height);

+        if (sc->c->keyframe)

+            return decode_region_intra(sc, acoder, x, y, width, height);

         else

-            return decode_region_inter(ctx, acoder, x, y, width, height);

+            return decode_region_inter(sc, acoder, x, y, width, height);

     default:

         return -1;

     }

@@ -505,13 +595,11 @@ int ff_mss12_decode_rect(MSS12Context *ctx, ArithCoder *acoder,

     return 0;

 }

-av_cold int ff_mss12_decode_init(AVCodecContext *avctx, int version)

+av_cold int ff_mss12_decode_init(MSS12Context *c, int version)

 {

-    MSS12Context * const c = avctx->priv_data;

+    AVCodecContext *avctx = c->avctx;

     int i;

-    c->avctx = avctx;

-

     if (avctx->extradata_size < 52 + 256 * 3) {

         av_log(avctx, AV_LOG_ERROR, "Insufficient extradata size %d\n",

                avctx->extradata_size);

@@ -526,9 +614,23 @@ av_cold int ff_mss12_decode_init(AVCodecContext *avctx, int version)

         return AVERROR_INVALIDDATA;

     }

+    avctx->coded_width  = AV_RB32(avctx->extradata + 20);

+    avctx->coded_height = AV_RB32(avctx->extradata + 24);

+    if (avctx->coded_width > 4096 || avctx->coded_height > 4096) {

+        av_log(avctx, AV_LOG_ERROR, "Frame dimensions %dx%d too large",

+               avctx->coded_width, avctx->coded_height);

+        return AVERROR_INVALIDDATA;

+    }

+

     av_log(avctx, AV_LOG_DEBUG, "Encoder version %d.%d\n",

            AV_RB32(avctx->extradata + 4), AV_RB32(avctx->extradata + 8));

-    c->free_colours     = AV_RB32(avctx->extradata + 48);

+    if (version != AV_RB32(avctx->extradata + 4) > 1) {

+        av_log(avctx, AV_LOG_ERROR,

+               "Header version doesn't match codec tag\n");

+        return -1;

+    }

+

+    c->free_colours = AV_RB32(avctx->extradata + 48);

     if ((unsigned)c->free_colours > 256) {

         av_log(avctx, AV_LOG_ERROR,

                "Incorrect number of changeable palette entries: %d\n",

@@ -536,8 +638,6 @@ av_cold int ff_mss12_decode_init(AVCodecContext *avctx, int version)

         return AVERROR_INVALIDDATA;

     }

     av_log(avctx, AV_LOG_DEBUG, "%d free colour(s)\n", c->free_colours);

-    avctx->coded_width  = AV_RB32(avctx->extradata + 20);

-    avctx->coded_height = AV_RB32(avctx->extradata + 24);

     av_log(avctx, AV_LOG_DEBUG, "Display dimensions %dx%d\n",

            AV_RB32(avctx->extradata + 12), AV_RB32(avctx->extradata + 16));

@@ -554,27 +654,53 @@ av_cold int ff_mss12_decode_init(AVCodecContext *avctx, int version)

     av_log(avctx, AV_LOG_DEBUG, "Max. seek time %g ms\n",

            av_int2float(AV_RB32(avctx->extradata + 44)));

-    for (i = 0; i < 256; i++)

-        c->pal[i] = AV_RB24(avctx->extradata + 52 + i * 3);

+    if (version) {

+        if (avctx->extradata_size < 60 + 256 * 3) {

+            av_log(avctx, AV_LOG_ERROR,

+                   "Insufficient extradata size %d for v2\n",

+                   avctx->extradata_size);

+            return AVERROR_INVALIDDATA;

+        }

+

+        c->slice_split = AV_RB32(avctx->extradata + 52);

+        av_log(avctx, AV_LOG_DEBUG, "Slice split %d\n", c->slice_split);

-    avctx->pix_fmt = PIX_FMT_PAL8;

+        c->full_model_syms = AV_RB32(avctx->extradata + 56);

+        if (c->full_model_syms < 2 || c->full_model_syms > 256) {

+            av_log(avctx, AV_LOG_ERROR,

+                   "Incorrect number of used colours %d\n",

+                   c->full_model_syms);

+            return AVERROR_INVALIDDATA;

+        }

+        av_log(avctx, AV_LOG_DEBUG, "Used colours %d\n",

+               c->full_model_syms);

+    } else {

+        c->slice_split     = 0;

+        c->full_model_syms = 256;

+    }

-    c->mask_linesize = FFALIGN(avctx->width, 16);

-    c->mask          = av_malloc(c->mask_linesize * avctx->height);

+    for (i = 0; i < 256; i++)

+        c->pal[i] = AV_RB24(avctx->extradata + 52 +

+                            (version ? 8 : 0) + i * 3);

+

+    c->mask_stride = FFALIGN(avctx->width, 16);

+    c->mask        = av_malloc(c->mask_stride * avctx->height);

     if (!c->mask) {

         av_log(avctx, AV_LOG_ERROR, "Cannot allocate mask plane\n");

         return AVERROR(ENOMEM);

     }

-    codec_init(c);

+    avctx->pix_fmt = version ? c->free_colours == 127 ? PIX_FMT_RGB555

+                                                      : PIX_FMT_RGB24

+                             : PIX_FMT_PAL8;

+

+    codec_init(c, version);

     return 0;