@@ -11,6 +11,7 @@ version next:

 - ffprobe -show_data option

 - RTMPT protocol support

 - iLBC encoding/decoding via libilbc

+- Microsoft Screen 1 decoder

 - showwaves filter

@@ -1206,7 +1206,9 @@ HAVE_LIST="

     GetProcessAffinityMask

     GetProcessMemoryInfo

     GetProcessTimes

+    GetSystemTimeAsFileTime

     getrusage

+    gettimeofday

     glob

     gnu_as

     ibm_asm

@@ -3142,6 +3144,7 @@ check_func  getaddrinfo $network_extralibs

 check_func  gethrtime

 check_func  getrusage

 check_struct "sys/time.h sys/resource.h" "struct rusage" ru_maxrss

+check_func  gettimeofday

 check_func  inet_aton $network_extralibs

 check_func  isatty

 check_func  localtime_r

@@ -3163,6 +3166,7 @@ check_func_headers lzo/lzo1x.h lzo1x_999_compress

 check_lib2 "windows.h psapi.h" GetProcessMemoryInfo -lpsapi

 check_func_headers windows.h GetProcessAffinityMask

 check_func_headers windows.h GetProcessTimes

+check_func_headers windows.h GetSystemTimeAsFileTime

 check_func_headers windows.h MapViewOfFile

 check_func_headers windows.h VirtualAlloc

 check_func_headers glob.h glob

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

 @item LOCO                   @tab     @tab  X

 @item lossless MJPEG         @tab  X  @tab  X

 @item Microsoft RLE          @tab     @tab  X

+@item Microsoft Screen 1     @tab     @tab  X

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

 @item Microsoft Video 1      @tab     @tab  X

 @item Mimic                  @tab     @tab  X

     @tab Used in MSN Messenger Webcam streams.

@@ -63,7 +63,6 @@

 #if HAVE_SYS_RESOURCE_H

 #include <sys/types.h>

-#include <sys/time.h>

 #include <sys/resource.h>

 #elif HAVE_GETPROCESSTIMES

 #include <windows.h>

@@ -55,7 +55,6 @@

 #include <poll.h>

 #endif

 #include <errno.h>

-#include <sys/time.h>

 #include <time.h>

 #include <sys/wait.h>

 #include <signal.h>

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

                                           h263dec.o h263.o ituh263dec.o        \

                                           mpeg4videodec.o

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

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

 OBJS-$(CONFIG_MSVIDEO1_DECODER)        += msvideo1.o

 OBJS-$(CONFIG_MSVIDEO1_ENCODER)        += msvideo1enc.o elbg.o

 OBJS-$(CONFIG_MSZH_DECODER)            += lcldec.o

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

     REGISTER_ENCDEC  (MSMPEG4V2, msmpeg4v2);

     REGISTER_ENCDEC  (MSMPEG4V3, msmpeg4v3);

     REGISTER_DECODER (MSRLE, msrle);

+    REGISTER_DECODER (MSS1, mss1);

     REGISTER_ENCDEC  (MSVIDEO1, msvideo1);

     REGISTER_DECODER (MSZH, mszh);

     REGISTER_DECODER (MXPEG, mxpeg);

@@ -257,6 +257,7 @@ enum CodecID {

     CODEC_ID_CDXL,

     CODEC_ID_XBM,

     CODEC_ID_ZEROCODEC,

+    CODEC_ID_MSS1,

     CODEC_ID_Y41P       = MKBETAG('Y','4','1','P'),

     CODEC_ID_ESCAPE130  = MKBETAG('E','1','3','0'),

     CODEC_ID_EXR        = MKBETAG('0','E','X','R'),

@@ -28,13 +28,13 @@

 #include <stdlib.h>

 #include <stdio.h>

 #include <string.h>

-#include <sys/time.h>

 #include <unistd.h>

 #include <math.h>

 #include "libavutil/cpu.h"

 #include "libavutil/common.h"

 #include "libavutil/lfg.h"

+#include "libavutil/time.h"

 #include "simple_idct.h"

 #include "aandcttab.h"

@@ -163,13 +163,6 @@ static const struct algo idct_tab[] = {

 #define AANSCALE_BITS 12

-static int64_t gettime(void)

-{

-    struct timeval tv;

-    gettimeofday(&tv, NULL);

-    return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;

-}

-

 #define NB_ITS 20000

 #define NB_ITS_SPEED 50000

@@ -201,14 +194,6 @@ static void idct_mmx_init(void)

 DECLARE_ALIGNED(16, static DCTELEM, block)[64];

 DECLARE_ALIGNED(8,  static DCTELEM, block1)[64];

-static inline void mmx_emms(void)

-{

-#if HAVE_MMX

-    if (cpu_flags & AV_CPU_FLAG_MMX)

-        __asm__ volatile ("emms\n\t" ::: "memory");

-#endif

-}

-

 static void init_block(DCTELEM block[64], int test, int is_idct, AVLFG *prng, int vals)

 {

     int i, j;

@@ -287,7 +272,7 @@ static int dct_error(const struct algo *dct, int test, int is_idct, int speed, c

         permute(block, block1, dct->format);

         dct->func(block);

-        mmx_emms();

+        emms_c();

         if (dct->format == SCALE_PERM) {

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

@@ -345,16 +330,16 @@ static int dct_error(const struct algo *dct, int test, int is_idct, int speed, c

     init_block(block, test, is_idct, &prng, vals);

     permute(block1, block, dct->format);

-    ti = gettime();

+    ti = av_gettime();

     it1 = 0;

     do {

         for (it = 0; it < NB_ITS_SPEED; it++) {

             memcpy(block, block1, sizeof(block));

             dct->func(block);

         }

-        mmx_emms();

+        emms_c();

         it1 += NB_ITS_SPEED;

-        ti1 = gettime() - ti;

+        ti1 = av_gettime() - ti;

     } while (ti1 < 1000000);

     printf("%s %s: %0.1f kdct/s\n", is_idct ? "IDCT" : "DCT", dct->name,

@@ -505,7 +490,7 @@ static void idct248_error(const char *name,

     if (!speed)

         return;

-    ti = gettime();

+    ti = av_gettime();

     it1 = 0;

     do {

         for (it = 0; it < NB_ITS_SPEED; it++) {

@@ -513,9 +498,9 @@ static void idct248_error(const char *name,

                 block[i] = block1[i];

             idct248_put(img_dest, 8, block);

         }

-        mmx_emms();

+        emms_c();

         it1 += NB_ITS_SPEED;

-        ti1 = gettime() - ti;

+        ti1 = av_gettime() - ti;

     } while (ti1 < 1000000);

     printf("%s %s: %0.1f kdct/s\n", 1 ? "IDCT248" : "DCT248", name,

@@ -27,6 +27,7 @@

 #include "libavutil/mathematics.h"

 #include "libavutil/lfg.h"

 #include "libavutil/log.h"

+#include "libavutil/time.h"

 #include "fft.h"

 #if CONFIG_FFT_FLOAT

 #include "dct.h"

@@ -34,7 +35,6 @@

 #endif

 #include <math.h>

 #include <unistd.h>

-#include <sys/time.h>

 #include <stdlib.h>

 #include <string.h>

@@ -186,13 +186,6 @@ static FFTSample frandom(AVLFG *prng)

     return (int16_t)av_lfg_get(prng) / 32768.0 * RANGE;

 }

-static int64_t gettime(void)

-{

-    struct timeval tv;

-    gettimeofday(&tv,NULL);

-    return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;

-}

-

 static int check_diff(FFTSample *tab1, FFTSample *tab2, int n, double scale)

 {

     int i;

@@ -430,7 +423,7 @@ int main(int argc, char **argv)

         /* we measure during about 1 seconds */

         nb_its = 1;

         for(;;) {

-            time_start = gettime();

+            time_start = av_gettime();

             for (it = 0; it < nb_its; it++) {

                 switch (transform) {

                 case TRANSFORM_MDCT:

@@ -456,7 +449,7 @@ int main(int argc, char **argv)

 #endif

                 }

             }

-            duration = gettime() - time_start;

+            duration = av_gettime() - time_start;

             if (duration >= 1000000)

                 break;

             nb_its *= 2;

@@ -32,6 +32,7 @@

 #include "config.h"

 #include "dsputil.h"

 #include "libavutil/lfg.h"

+#include "libavutil/time.h"

 #undef printf

@@ -58,13 +59,6 @@ static void help(void)

            "test motion implementations\n");

 }

-static int64_t gettime(void)

-{

-    struct timeval tv;

-    gettimeofday(&tv,NULL);

-    return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;

-}

-

 #define NB_ITS 500

 int dummy;

@@ -97,7 +91,7 @@ static void test_motion(const char *name,

     emms_c();

     /* speed test */

-    ti = gettime();

+    ti = av_gettime();

     d1 = 0;

     for(it=0;it<NB_ITS;it++) {

         for(y=0;y<HEIGHT-17;y++) {

@@ -109,7 +103,7 @@ static void test_motion(const char *name,

     }

     emms_c();

     dummy = d1; /* avoid optimization */

-    ti = gettime() - ti;

+    ti = av_gettime() - ti;

     printf("  %0.0f kop/s\n",

            (double)NB_ITS * (WIDTH - 16) * (HEIGHT - 16) /

new file mode 100644

@@ -0,0 +1,845 @@

+/*

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

+ * Copyright (c) 2012 Konstantin Shishkov

+ *

+ * This file is part of FFmpeg.

+ *

+ * FFmpeg is free software; you can redistribute it and/or

+ * modify it under the terms of the GNU Lesser General Public

+ * License as published by the Free Software Foundation; either

+ * version 2.1 of the License, or (at your option) any later version.

+ *

+ * FFmpeg is distributed in the hope that it will be useful,

+ * but WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

+ * Lesser General Public License for more details.

+ *

+ * You should have received a copy of the GNU Lesser General Public

+ * License along with FFmpeg; if not, write to the Free Software

+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

+ */

+

+/**

+ * @file

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

+ */

+

+#include "libavutil/intfloat.h"

+#include "libavutil/intreadwrite.h"

+#include "avcodec.h"

+#include "get_bits.h"

+

+enum SplitMode {

+    SPLIT_VERT = 0,

+    SPLIT_HOR,

+    SPLIT_NONE

+};

+

+typedef struct ArithCoder {

+    int low, high, value;

+    GetBitContext *gb;

+} ArithCoder;

+

+#define MODEL_MIN_SYMS    2

+#define MODEL_MAX_SYMS  256

+#define THRESH_ADAPTIVE  -1

+#define THRESH_LOW       15

+#define THRESH_HIGH      50

+

+typedef struct Model {

+    int cum_prob[MODEL_MAX_SYMS + 1];

+    int weights[MODEL_MAX_SYMS + 1];

+    int idx2sym[MODEL_MAX_SYMS + 1];

+    int sym2idx[MODEL_MAX_SYMS + 1];

+    int num_syms;

+    int thr_weight, threshold;

+} Model;

+

+static const int sec_order_sizes[4] = { 1, 7, 6, 1 };

+

+enum ContextDirection {

+    TOP_LEFT = 0,

+    TOP,

+    TOP_RIGHT,

+    LEFT

+};

+

+typedef struct PixContext {

+    int cache_size, num_syms;

+    uint8_t cache[12];

+    Model cache_model, full_model;

+    Model sec_models[4][8][4];

+} PixContext;

+

+typedef struct MSS1Context {

+    AVCodecContext *avctx;

+    AVFrame        pic;

+    uint8_t        *pic_start;

+    int            pic_stride;

+    uint8_t        *mask;

+    int            mask_linesize;

+    uint32_t       pal[256];

+    int            free_colours;

+    Model          intra_region, inter_region;

+    Model          pivot, edge_mode, split_mode;

+    PixContext     intra_pix_ctx, inter_pix_ctx;

+    int            corrupted;

+} MSS1Context;

+

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

+{

+    c->low   = 0;

+    c->high  = 0xFFFF;

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

+    c->gb    = gb;

+}

+

+static void arith_normalise(ArithCoder *c)

+{

+    for (;;) {

+        if (c->high >= 0x8000) {

+            if (c->low < 0x8000) {

+                if (c->low >= 0x4000 && c->high < 0xC000) {

+                    c->value -= 0x4000;

+                    c->low   -= 0x4000;

+                    c->high  -= 0x4000;

+                } else {

+                    return;

+                }

+            } else {

+                c->value -= 0x8000;

+                c->low   -= 0x8000;

+                c->high  -= 0x8000;

+            }

+        }

+        c->value <<= 1;

+        c->low   <<= 1;

+        c->high  <<= 1;

+        c->high   |= 1;

+        c->value  |= get_bits1(c->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;

+}

+

+static int arith_get_bits(ArithCoder *c, int bits)

+{

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

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

+    int prob  = range * val;

+

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

+    c->low   += prob >> bits;

+

+    arith_normalise(c);

+

+    return val;

+}

+

+static int arith_get_number(ArithCoder *c, int mod_val)

+{

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

+    int val   = ((c->value - c->low + 1) * mod_val - 1) / range;

+    int prob  = range * val;

+

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

+    c->low   += prob / mod_val;

+

+    arith_normalise(c);

+

+    return val;

+}

+

+static int arith_get_prob(ArithCoder *c, int *probs)

+{

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

+    int val   = ((c->value - c->low + 1) * probs[0] - 1) / range;

+    int sym   = 1;

+

+    while (probs[sym] > val)

+        sym++;

+

+    c->high = range * probs[sym - 1] / probs[0] + c->low - 1;

+    c->low += range * probs[sym]     / probs[0];

+

+    return sym;

+}

+

+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;

+    }

+

+    return FFMIN(thr, 0x3FFF);

+}

+

+static void model_reset(Model *m)

+{

+    int i;

+

+    for (i = 0; i <= m->num_syms; i++) {

+        m->weights[i]  = 1;

+        m->cum_prob[i] = m->num_syms - i;

+    }

+    m->weights[0]           = -1;

+    m->idx2sym[0]           = -1;

+    m->sym2idx[m->num_syms] = -1;

+    for (i = 0; i < m->num_syms; i++) {

+        m->sym2idx[i]     = i + 1;

+        m->idx2sym[i + 1] = i;

+    }

+}

+

+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);

+    model_reset(m);

+}

+

+static void model_rescale_weights(Model *m)

+{

+    int i;

+    int cum_prob;

+

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

+        m->threshold = model_calc_threshold(m);

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

+        cum_prob = 0;

+        for (i = m->num_syms; i >= 0; i--) {

+            m->cum_prob[i] = cum_prob;

+            m->weights[i]  = (m->weights[i] + 1) >> 1;

+            cum_prob      += m->weights[i];

+        }

+    }

+}

+

+static void model_update(Model *m, int val)

+{

+    int i;

+

+    if (m->weights[val] == m->weights[val - 1]) {

+        for (i = val; m->weights[i - 1] == m->weights[val]; i--);

+        if (i != val) {

+            int sym1, sym2;

+

+            sym1 = m->idx2sym[val];

+            sym2 = m->idx2sym[i];

+

+            m->idx2sym[val]  = sym2;

+            m->idx2sym[i]    = sym1;

+            m->sym2idx[sym1] = i;

+            m->sym2idx[sym2] = val;

+

+            val = i;

+        }

+    }

+    m->weights[val]++;

+    for (i = val - 1; i >= 0; i--)

+        m->cum_prob[i]++;

+    model_rescale_weights(m);

+}

+

+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];

+    model_update(m, idx);

+

+    arith_normalise(c);

+

+    return val;

+}

+

+static void pixctx_reset(PixContext *ctx)

+{

+    int i, j, k;

+

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

+        ctx->cache[i] = i;

+

+    model_reset(&ctx->cache_model);

+    model_reset(&ctx->full_model);

+

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

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

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

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

+}

+

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

+{

+    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;

+

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

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

+

+    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)

+{

+    int i, val, pix;

+

+    val = arith_get_model_sym(acoder, &pctx->cache_model);

+    if (val < pctx->num_syms) {

+        pix = pctx->cache[val];

+    } else {

+        pix = arith_get_model_sym(acoder, &pctx->full_model);

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

+            if (pctx->cache[i] == pix)

+                break;

+        val = i;

+    }

+    if (val) {

+        for (i = val; i > 0; i--)

+            pctx->cache[i] = pctx->cache[i - 1];

+        pctx->cache[0] = pix;

+    }

+

+    return pix;

+}

+

+static int decode_pixel(ArithCoder *acoder, PixContext *pctx,

+                        uint8_t *ngb, int num_ngb)

+{

+    int i, val, pix;

+

+    val = arith_get_model_sym(acoder, &pctx->cache_model);

+    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++)

+                if (pctx->cache[i] == ngb[j])

+                    break;

+            if (j == num_ngb) {

+                if (idx == val)

+                    break;

+                idx++;

+            }

+        }

+        val = FFMIN(i, pctx->cache_size - 1);

+        pix = pctx->cache[val];

+    } else {

+        pix = arith_get_model_sym(acoder, &pctx->full_model);

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

+            if (pctx->cache[i] == pix)

+                break;

+        val = i;

+    }

+    if (val) {

+        for (i = val; i > 0; i--)

+            pctx->cache[i] = pctx->cache[i - 1];

+        pctx->cache[0] = pix;

+    }

+

+    return pix;

+}

+

+static int decode_pixel_in_context(ArithCoder *acoder, PixContext *pctx,

+                                   uint8_t *src, int stride, int x, int y,

+                                   int has_right)

+{

+    uint8_t neighbours[4];

+    uint8_t ref_pix[4];

+    int nlen;

+    int layer = 0, sub;

+    int pix;

+    int i, j;

+

+    if (!y) {

+        memset(neighbours, src[-1], 4);

+    } else {

+        neighbours[TOP] = src[-stride];

+        if (!x) {

+            neighbours[TOP_LEFT] = neighbours[LEFT] = neighbours[TOP];

+        } else {

+            neighbours[TOP_LEFT] = src[-stride - 1];

+            neighbours[    LEFT] = src[-1];

+        }

+        if (has_right)

+            neighbours[TOP_RIGHT] = src[-stride + 1];

+        else

+            neighbours[TOP_RIGHT] = neighbours[TOP];

+    }

+

+    sub = 0;

+    if (x >= 2 && src[-2] == neighbours[LEFT])

+        sub  = 1;

+    if (y >= 2 && src[-2 * stride] == neighbours[TOP])

+        sub |= 2;

+

+    nlen = 1;

+    ref_pix[0] = neighbours[0];

+    for (i = 1; i < 4; i++) {

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

+            if (ref_pix[j] == neighbours[i])

+                break;

+        if (j == nlen)

+            ref_pix[nlen++] = neighbours[i];

+    }

+

+    switch (nlen) {

+    case 1:

+    case 4:

+        layer = 0;

+        break;

+    case 2:

+        if (neighbours[TOP] == neighbours[TOP_LEFT]) {

+            if (neighbours[TOP_RIGHT] == neighbours[TOP_LEFT])

+                layer = 3;

+            else if (neighbours[LEFT] == neighbours[TOP_LEFT])

+                layer = 2;

+            else

+                layer = 4;

+        } else if (neighbours[TOP_RIGHT] == neighbours[TOP_LEFT]) {

+            if (neighbours[LEFT] == neighbours[TOP_LEFT])

+                layer = 1;

+            else

+                layer = 5;

+        } else if (neighbours[LEFT] == neighbours[TOP_LEFT]) {

+            layer = 6;

+        } else {

+            layer = 0;

+        }

+        break;

+    case 3:

+        if (neighbours[TOP] == neighbours[TOP_LEFT])

+            layer = 0;

+        else if (neighbours[TOP_RIGHT] == neighbours[TOP_LEFT])

+            layer = 1;

+        else if (neighbours[LEFT] == neighbours[TOP_LEFT])

+            layer = 2;

+        else if (neighbours[TOP_RIGHT] == neighbours[TOP])

+            layer = 3;

+        else if (neighbours[TOP] == neighbours[LEFT])

+            layer = 4;

+        else

+            layer = 5;

+        break;

+    }

+

+    pix = arith_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(MSS1Context *ctx, ArithCoder *acoder, uint8_t *dst,

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

+                         PixContext *pctx)

+{

+    int i, j;

+

+    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;

+

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

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

+        }

+        dst += stride;

+    }

+

+    return 0;

+}

+

+static int decode_region_masked(MSS1Context *ctx, 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;

+

+    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);

+        }

+        dst  += stride;

+        mask += mask_stride;

+    }

+

+    return 0;

+}

+

+static av_cold void codec_init(MSS1Context *ctx)

+{

+    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;

+}

+

+static void codec_reset(MSS1Context *ctx)

+{

+    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;

+}

+

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

+{

+    int i, ncol, r, g, b;

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

+

+    if (!ctx->free_colours)

+        return 0;

+

+    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);

+        b = arith_get_bits(acoder, 8);

+        *pal++ = (r << 16) | (g << 8) | b;

+    }

+

+    return 0;

+}

+

+static int decode_pivot(MSS1Context *ctx, ArithCoder *acoder, int base)

+{

+    int val, inv;

+

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

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

+

+    if (val > 2) {

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

+            ctx->corrupted = 1;

+            return 0;

+        }

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

+    }

+

+    if (val == base) {

+        ctx->corrupted = 1;

+        return 0;

+    }

+

+    return inv ? base - val : val;

+}

+

+static int decode_region_intra(MSS1Context *ctx, ArithCoder *acoder,

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

+{