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

 - subfile protocol

 - Phantom Cine demuxer

 - replaygain data export

+- VP7 video decoder

 version 2.2:

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

     @tab fourcc: VP50

 @item On2 VP6                @tab     @tab  X

     @tab fourcc: VP60,VP61,VP62

+@item On2 VP7                @tab     @tab  X

+    @tab fourcc: VP70,VP71

 @item VP8                    @tab  E  @tab  X

     @tab fourcc: VP80, encoding supported through external library libvpx

 @item VP9                    @tab  E  @tab  X

@@ -466,6 +466,7 @@ OBJS-$(CONFIG_VP5_DECODER)             += vp5.o vp56.o vp56data.o vp56dsp.o \

                                           vp56rac.o

 OBJS-$(CONFIG_VP6_DECODER)             += vp6.o vp56.o vp56data.o vp56dsp.o \

                                           vp6dsp.o vp56rac.o

+OBJS-$(CONFIG_VP7_DECODER)             += vp8.o vp8dsp.o vp56rac.o

 OBJS-$(CONFIG_VP8_DECODER)             += vp8.o vp8dsp.o vp56rac.o

 OBJS-$(CONFIG_VP9_DECODER)             += vp9.o vp9dsp.o vp56rac.o

 OBJS-$(CONFIG_VPLAYER_DECODER)         += textdec.o ass.o

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

     REGISTER_DECODER(VP6,               vp6);

     REGISTER_DECODER(VP6A,              vp6a);

     REGISTER_DECODER(VP6F,              vp6f);

+    REGISTER_DECODER(VP7,               vp7);

     REGISTER_DECODER(VP8,               vp8);

     REGISTER_DECODER(VP9,               vp9);

     REGISTER_DECODER(VQA,               vqa);

@@ -57,10 +57,10 @@ static av_cold void h264_pred_init_neon(H264PredContext *h, int codec_id,

     if(chroma_format_idc == 1){

     h->pred8x8[VERT_PRED8x8     ] = ff_pred8x8_vert_neon;

     h->pred8x8[HOR_PRED8x8      ] = ff_pred8x8_hor_neon;

-    if (codec_id != AV_CODEC_ID_VP8)

+    if (codec_id != AV_CODEC_ID_VP7 && codec_id != AV_CODEC_ID_VP8)

         h->pred8x8[PLANE_PRED8x8] = ff_pred8x8_plane_neon;

     h->pred8x8[DC_128_PRED8x8   ] = ff_pred8x8_128_dc_neon;

-    if (codec_id != AV_CODEC_ID_RV40 && codec_id != AV_CODEC_ID_VP8) {

+    if (codec_id != AV_CODEC_ID_RV40 && codec_id != AV_CODEC_ID_VP7 && codec_id != AV_CODEC_ID_VP8) {

         h->pred8x8[DC_PRED8x8     ] = ff_pred8x8_dc_neon;

         h->pred8x8[LEFT_DC_PRED8x8] = ff_pred8x8_left_dc_neon;

         h->pred8x8[TOP_DC_PRED8x8 ] = ff_pred8x8_top_dc_neon;

@@ -77,7 +77,7 @@ static av_cold void h264_pred_init_neon(H264PredContext *h, int codec_id,

     h->pred16x16[LEFT_DC_PRED8x8] = ff_pred16x16_left_dc_neon;

     h->pred16x16[TOP_DC_PRED8x8 ] = ff_pred16x16_top_dc_neon;

     h->pred16x16[DC_128_PRED8x8 ] = ff_pred16x16_128_dc_neon;

-    if (codec_id != AV_CODEC_ID_SVQ3 && codec_id != AV_CODEC_ID_RV40 && codec_id != AV_CODEC_ID_VP8)

+    if (codec_id != AV_CODEC_ID_SVQ3 && codec_id != AV_CODEC_ID_RV40 && codec_id != AV_CODEC_ID_VP7 && codec_id != AV_CODEC_ID_VP8)

         h->pred16x16[PLANE_PRED8x8  ] = ff_pred16x16_plane_neon;

 #endif // HAVE_NEON

 }

@@ -26,7 +26,7 @@

 #include "libavcodec/vp8.h"

 #if HAVE_ARMV6_EXTERNAL

-#define decode_block_coeffs_internal ff_decode_block_coeffs_armv6

+#define vp8_decode_block_coeffs_internal ff_decode_block_coeffs_armv6

 int ff_decode_block_coeffs_armv6(VP56RangeCoder *rc, int16_t block[16],

                                  uint8_t probs[8][3][NUM_DCT_TOKENS-1],

                                  int i, uint8_t *token_prob, int16_t qmul[2]);

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

     AV_CODEC_ID_SMVJPEG    = MKBETAG('S','M','V','J'),

     AV_CODEC_ID_HEVC       = MKBETAG('H','2','6','5'),

 #define AV_CODEC_ID_H265 AV_CODEC_ID_HEVC

+    AV_CODEC_ID_VP7        = MKBETAG('V','P','7','0'),

     /* various PCM "codecs" */

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

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

         .long_name = NULL_IF_CONFIG_SMALL("Mirillis FIC"),

         .props     = AV_CODEC_PROP_LOSSY,

     },

+    {

+        .id        = AV_CODEC_ID_VP7,

+        .type      = AVMEDIA_TYPE_VIDEO,

+        .name      = "vp7",

+        .long_name = NULL_IF_CONFIG_SMALL("On2 VP7"),

+        .props     = AV_CODEC_PROP_LOSSY,

+    },

     /* image codecs */

     {

@@ -420,7 +420,7 @@ av_cold void ff_h264_pred_init(H264PredContext *h, int codec_id,

 #define H264_PRED(depth) \

     if(codec_id != AV_CODEC_ID_RV40){\

-        if(codec_id == AV_CODEC_ID_VP8) {\

+        if(codec_id == AV_CODEC_ID_VP7 || codec_id == AV_CODEC_ID_VP8) {\

             h->pred4x4[VERT_PRED       ]= FUNCD(pred4x4_vertical_vp8);\

             h->pred4x4[HOR_PRED        ]= FUNCD(pred4x4_horizontal_vp8);\

         } else {\

@@ -435,15 +435,14 @@ av_cold void ff_h264_pred_init(H264PredContext *h, int codec_id,

         h->pred4x4[DIAG_DOWN_RIGHT_PRED]= FUNCC(pred4x4_down_right        , depth);\

         h->pred4x4[VERT_RIGHT_PRED     ]= FUNCC(pred4x4_vertical_right    , depth);\

         h->pred4x4[HOR_DOWN_PRED       ]= FUNCC(pred4x4_horizontal_down   , depth);\

-        if (codec_id == AV_CODEC_ID_VP8) {\

+        if (codec_id == AV_CODEC_ID_VP7 || codec_id == AV_CODEC_ID_VP8) {\

             h->pred4x4[VERT_LEFT_PRED  ]= FUNCD(pred4x4_vertical_left_vp8);\

         } else\

             h->pred4x4[VERT_LEFT_PRED  ]= FUNCC(pred4x4_vertical_left     , depth);\

         h->pred4x4[HOR_UP_PRED         ]= FUNCC(pred4x4_horizontal_up     , depth);\

-        if(codec_id != AV_CODEC_ID_VP8) {\

+        if(codec_id != AV_CODEC_ID_VP7 && codec_id != AV_CODEC_ID_VP8) {\

             h->pred4x4[LEFT_DC_PRED    ]= FUNCC(pred4x4_left_dc           , depth);\

             h->pred4x4[TOP_DC_PRED     ]= FUNCC(pred4x4_top_dc            , depth);\

-            h->pred4x4[DC_128_PRED     ]= FUNCC(pred4x4_128_dc            , depth);\

         } else {\

             h->pred4x4[TM_VP8_PRED     ]= FUNCD(pred4x4_tm_vp8);\

             h->pred4x4[DC_127_PRED     ]= FUNCC(pred4x4_127_dc            , depth);\

@@ -451,6 +450,8 @@ av_cold void ff_h264_pred_init(H264PredContext *h, int codec_id,

             h->pred4x4[VERT_VP8_PRED   ]= FUNCC(pred4x4_vertical          , depth);\

             h->pred4x4[HOR_VP8_PRED    ]= FUNCC(pred4x4_horizontal        , depth);\

         }\

+        if (codec_id != AV_CODEC_ID_VP8)\

+            h->pred4x4[DC_128_PRED     ]= FUNCC(pred4x4_128_dc            , depth);\

     }else{\

         h->pred4x4[VERT_PRED           ]= FUNCC(pred4x4_vertical          , depth);\

         h->pred4x4[HOR_PRED            ]= FUNCC(pred4x4_horizontal        , depth);\

@@ -489,7 +490,7 @@ av_cold void ff_h264_pred_init(H264PredContext *h, int codec_id,

         h->pred8x8[VERT_PRED8x8   ]= FUNCC(pred8x16_vertical              , depth);\

         h->pred8x8[HOR_PRED8x8    ]= FUNCC(pred8x16_horizontal            , depth);\

     }\

-    if (codec_id != AV_CODEC_ID_VP8) {\

+    if (codec_id != AV_CODEC_ID_VP7 && codec_id != AV_CODEC_ID_VP8) {\

         if (chroma_format_idc <= 1) {\

             h->pred8x8[PLANE_PRED8x8]= FUNCC(pred8x8_plane                , depth);\

         } else {\

@@ -497,7 +498,7 @@ av_cold void ff_h264_pred_init(H264PredContext *h, int codec_id,

         }\

     } else\

         h->pred8x8[PLANE_PRED8x8]= FUNCD(pred8x8_tm_vp8);\

-    if(codec_id != AV_CODEC_ID_RV40 && codec_id != AV_CODEC_ID_VP8){\

+    if(codec_id != AV_CODEC_ID_RV40 && codec_id != AV_CODEC_ID_VP7 && codec_id != AV_CODEC_ID_VP8){\

         if (chroma_format_idc <= 1) {\

             h->pred8x8[DC_PRED8x8     ]= FUNCC(pred8x8_dc                     , depth);\

             h->pred8x8[LEFT_DC_PRED8x8]= FUNCC(pred8x8_left_dc                , depth);\

@@ -519,7 +520,7 @@ av_cold void ff_h264_pred_init(H264PredContext *h, int codec_id,

         h->pred8x8[DC_PRED8x8     ]= FUNCD(pred8x8_dc_rv40);\

         h->pred8x8[LEFT_DC_PRED8x8]= FUNCD(pred8x8_left_dc_rv40);\

         h->pred8x8[TOP_DC_PRED8x8 ]= FUNCD(pred8x8_top_dc_rv40);\

-        if (codec_id == AV_CODEC_ID_VP8) {\

+        if (codec_id == AV_CODEC_ID_VP7 || codec_id == AV_CODEC_ID_VP8) {\

             h->pred8x8[DC_127_PRED8x8]= FUNCC(pred8x8_127_dc              , depth);\

             h->pred8x8[DC_129_PRED8x8]= FUNCC(pred8x8_129_dc              , depth);\

         }\

@@ -540,6 +541,7 @@ av_cold void ff_h264_pred_init(H264PredContext *h, int codec_id,

     case AV_CODEC_ID_RV40:\

        h->pred16x16[PLANE_PRED8x8  ]= FUNCD(pred16x16_plane_rv40);\

        break;\

+    case AV_CODEC_ID_VP7:\

     case AV_CODEC_ID_VP8:\

        h->pred16x16[PLANE_PRED8x8  ]= FUNCD(pred16x16_tm_vp8);\

        h->pred16x16[DC_127_PRED8x8]= FUNCC(pred16x16_127_dc               , depth);\

@@ -1,10 +1,11 @@

 /*

- * VP8 compatible video decoder

+ * VP7/VP8 compatible video decoder

  *

  * Copyright (C) 2010 David Conrad

  * Copyright (C) 2010 Ronald S. Bultje

  * Copyright (C) 2010 Jason Garrett-Glaser

  * Copyright (C) 2012 Daniel Kang

+ * Copyright (C) 2014 Peter Ross

  *

  * This file is part of FFmpeg.

  *

@@ -35,6 +36,14 @@

 #   include "arm/vp8.h"

 #endif

+#if CONFIG_VP7_DECODER && CONFIG_VP8_DECODER

+#define VPX(vp7, f) (vp7 ? vp7_ ## f : vp8_ ## f)

+#elif CONFIG_VP7_DECODER

+#define VPX(vp7, f) vp7_ ## f

+#else // CONFIG_VP8_DECODER

+#define VPX(vp7, f) vp8_ ## f

+#endif

+

 static void free_buffers(VP8Context *s)

 {

     int i;

@@ -74,6 +83,7 @@ static void vp8_release_frame(VP8Context *s, VP8Frame *f)

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

 }

+#if CONFIG_VP8_DECODER

 static int vp8_ref_frame(VP8Context *s, VP8Frame *dst, VP8Frame *src)

 {

     int ret;

@@ -90,6 +100,7 @@ static int vp8_ref_frame(VP8Context *s, VP8Frame *dst, VP8Frame *src)

     return 0;

 }

+#endif

 static void vp8_decode_flush_impl(AVCodecContext *avctx, int free_mem)

@@ -151,7 +162,7 @@ static int update_dimensions(VP8Context *s, int width, int height)

     s->mb_width  = (s->avctx->coded_width +15) / 16;

     s->mb_height = (s->avctx->coded_height+15) / 16;

-    s->mb_layout = (avctx->active_thread_type == FF_THREAD_SLICE) && (FFMIN(s->num_coeff_partitions, avctx->thread_count) > 1);

+    s->mb_layout = s->vp7 || (avctx->active_thread_type == FF_THREAD_SLICE) && (FFMIN(s->num_coeff_partitions, avctx->thread_count) > 1);

     if (!s->mb_layout) { // Frame threading and one thread

         s->macroblocks_base       = av_mallocz((s->mb_width+s->mb_height*2+1)*sizeof(*s->macroblocks));

         s->intra4x4_pred_mode_top = av_mallocz(s->mb_width*4);

@@ -179,6 +190,8 @@ static int update_dimensions(VP8Context *s, int width, int height)

     return 0;

 }

+

+#if CONFIG_VP8_DECODER

 static void parse_segment_info(VP8Context *s)

 {

     VP56RangeCoder *c = &s->c;

@@ -249,8 +262,31 @@ static int setup_partitions(VP8Context *s, const uint8_t *buf, int buf_size)

     return 0;

 }

+#endif

+

+#if CONFIG_VP7_DECODER

+static void vp7_get_quants(VP8Context *s)

+{

+    VP56RangeCoder *c = &s->c;

+

+    int yac_qi  = vp8_rac_get_uint(c, 7);

+    int ydc_qi  = vp8_rac_get(c) ? vp8_rac_get_uint(c, 7) : yac_qi;

+    int y2dc_qi = vp8_rac_get(c) ? vp8_rac_get_uint(c, 7) : yac_qi;

+    int y2ac_qi = vp8_rac_get(c) ? vp8_rac_get_uint(c, 7) : yac_qi;

+    int uvdc_qi = vp8_rac_get(c) ? vp8_rac_get_uint(c, 7) : yac_qi;

+    int uvac_qi = vp8_rac_get(c) ? vp8_rac_get_uint(c, 7) : yac_qi;

+

+    s->qmat[0].luma_qmul[0]    =       vp7_ydc_qlookup[ydc_qi];

+    s->qmat[0].luma_qmul[1]    =       vp7_yac_qlookup[yac_qi];

+    s->qmat[0].luma_dc_qmul[0] =       vp7_y2dc_qlookup[y2dc_qi];

+    s->qmat[0].luma_dc_qmul[1] =       vp7_y2ac_qlookup[y2ac_qi];

+    s->qmat[0].chroma_qmul[0]  = FFMIN(vp7_ydc_qlookup[uvdc_qi], 132);

+    s->qmat[0].chroma_qmul[1]  =       vp7_yac_qlookup[uvac_qi];

+}

+#endif

-static void get_quants(VP8Context *s)

+#if CONFIG_VP8_DECODER

+static void vp8_get_quants(VP8Context *s)

 {

     VP56RangeCoder *c = &s->c;

     int i, base_qi;

@@ -311,7 +347,53 @@ static VP56Frame ref_to_update(VP8Context *s, int update, VP56Frame ref)

     }

     return VP56_FRAME_NONE;

 }

+#endif

+

+static void vp78_reset_probability_tables(VP8Context *s)

+{

+    int i, j;

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

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

+            memcpy(s->prob->token[i][j], vp8_token_default_probs[i][vp8_coeff_band[j]],

+                   sizeof(s->prob->token[i][j]));

+}

+

+static void vp78_update_probability_tables(VP8Context *s)

+{

+    VP56RangeCoder *c = &s->c;

+    int i, j, k, l, m;

+

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

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

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

+                for (l = 0; l < NUM_DCT_TOKENS-1; l++)

+                    if (vp56_rac_get_prob_branchy(c, vp8_token_update_probs[i][j][k][l])) {

+                        int prob = vp8_rac_get_uint(c, 8);

+                        for (m = 0; vp8_coeff_band_indexes[j][m] >= 0; m++)

+                            s->prob->token[i][vp8_coeff_band_indexes[j][m]][k][l] = prob;

+                    }

+}

+

+static void vp78_update_pred16x16_pred8x8_mvc_probabilities(VP8Context *s)

+{

+    VP56RangeCoder *c = &s->c;

+    int i, j;

+

+    if (vp8_rac_get(c))

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

+            s->prob->pred16x16[i] = vp8_rac_get_uint(c, 8);

+    if (vp8_rac_get(c))

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

+            s->prob->pred8x8c[i]  = vp8_rac_get_uint(c, 8);

+

+    // 17.2 MV probability update

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

+        for (j = 0; j < (s->vp7 ? 17 : 19); j++)

+            if (vp56_rac_get_prob_branchy(c, vp8_mv_update_prob[i][j]))

+                s->prob->mvc[i][j] = vp8_rac_get_nn(c);

+}

+#if CONFIG_VP8_DECODER

 static void update_refs(VP8Context *s)

 {

     VP56RangeCoder *c = &s->c;

@@ -322,11 +404,182 @@ static void update_refs(VP8Context *s)

     s->update_golden = ref_to_update(s, update_golden, VP56_FRAME_GOLDEN);

     s->update_altref = ref_to_update(s, update_altref, VP56_FRAME_GOLDEN2);

 }

+#endif

+

+#if CONFIG_VP7_DECODER

+static void fade(uint8_t *dst, int dst_linesize, const uint8_t *src, int src_linesize, int width, int height, int alpha, int beta)

+{

+    int i, j;

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

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

+            uint8_t y = src[j*src_linesize + i];

+            dst[j*dst_linesize + i] = av_clip_uint8(y + ((y * beta) >> 8) + alpha);

+        }

+}

+

+static int vp7_decode_frame_header(VP8Context *s, const uint8_t *buf, int buf_size)

+{

+    VP56RangeCoder *c = &s->c;

+    int part1_size, hscale, vscale, i, j, ret;

+    int width  = s->avctx->width;

+    int height = s->avctx->height;

+

+    s->profile   =  (buf[0]>>1) & 7;

+    if (s->profile > 1) {

+        avpriv_request_sample(s->avctx, "Unknown profile %d", s->profile);

+        return AVERROR_INVALIDDATA;

+    }

+

+    s->keyframe  = !(buf[0] & 1);

+    s->invisible = 0;

+    part1_size   = AV_RL24(buf) >> 4;

+

+    buf      += 4 - s->profile;

+    buf_size -= 4 - s->profile;

+

+    memcpy(s->put_pixels_tab, s->vp8dsp.put_vp8_epel_pixels_tab, sizeof(s->put_pixels_tab));

+

+    ff_vp56_init_range_decoder(c, buf, part1_size);

+    buf      += part1_size;

+    buf_size -= part1_size;

+

+    /* A. Dimension information (keyframes only) */

+    if (s->keyframe) {

+        width  = vp8_rac_get_uint(c, 12);

+        height = vp8_rac_get_uint(c, 12);

+        hscale = vp8_rac_get_uint(c, 2);

+        vscale = vp8_rac_get_uint(c, 2);

+        if (hscale || vscale)

+            avpriv_request_sample(s->avctx, "Upscaling");

+

+        s->update_golden = s->update_altref = VP56_FRAME_CURRENT;

+        vp78_reset_probability_tables(s);

+        memcpy(s->prob->pred16x16, vp8_pred16x16_prob_inter, sizeof(s->prob->pred16x16));

+        memcpy(s->prob->pred8x8c , vp8_pred8x8c_prob_inter , sizeof(s->prob->pred8x8c));

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

+            memcpy(s->prob->mvc[i], vp7_mv_default_prob[i], sizeof(vp7_mv_default_prob[i]));

+        memset(&s->segmentation, 0, sizeof(s->segmentation));

+        memset(&s->lf_delta, 0, sizeof(s->lf_delta));

+        memcpy(s->prob[0].scan, zigzag_scan, sizeof(s->prob[0].scan));

+    }

+

+    if (s->keyframe || s->profile > 0)

+        memset(s->inter_dc_pred, 0 , sizeof(s->inter_dc_pred));

+

+    /* B. Decoding information for all four macroblock-level features */

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

+        s->feature_enabled[i] = vp8_rac_get(c);

+        if (s->feature_enabled[i]) {

+             s->feature_present_prob[i] = vp8_rac_get_uint(c, 8);

+

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

+                 s->feature_index_prob[i][j] = vp8_rac_get(c) ? vp8_rac_get_uint(c, 8) : 255;

+

+             if (vp7_feature_value_size[i])

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

+                     s->feature_value[i][j] = vp8_rac_get(c) ? vp8_rac_get_uint(c, vp7_feature_value_size[s->profile][i]) : 0;

+        }

+    }

+

+    s->segmentation.enabled = 0;

+    s->segmentation.update_map = 0;

+    s->lf_delta.enabled = 0;

+

+    s->num_coeff_partitions = 1;

+    ff_vp56_init_range_decoder(&s->coeff_partition[0], buf, buf_size);

+

+    if (!s->macroblocks_base || /* first frame */

+        width != s->avctx->width || height != s->avctx->height || (width+15)/16 != s->mb_width || (height+15)/16 != s->mb_height) {

+        if ((ret = update_dimensions(s, width, height)) < 0)

+            return ret;

+    }

+

+    /* C. Dequantization indices */

+    vp7_get_quants(s);

+

+    /* D. Golden frame update flag (a Flag) for interframes only */

+    if (!s->keyframe) {

+        s->update_golden = vp8_rac_get(c) ? VP56_FRAME_CURRENT : VP56_FRAME_NONE;

+        s->sign_bias[VP56_FRAME_GOLDEN] = 0;

+    }

+

+    s->update_last = 1;

+    s->update_probabilities = 1;

+    s->fade_present         = 1;

+

+    if (s->profile > 0) {

+        s->update_probabilities = vp8_rac_get(c);

+        if (!s->update_probabilities)

+            s->prob[1] = s->prob[0];

+

+        if (!s->keyframe)

+            s->fade_present = vp8_rac_get(c);

+    }

+

+    /* E. Fading information for previous frame */

+    if (s->fade_present && vp8_rac_get(c)) {

+        int alpha = (int8_t)vp8_rac_get_uint(c, 8);

+        int beta  = (int8_t)vp8_rac_get_uint(c, 8);

+        if (!s->keyframe && (alpha || beta)) {

+            /* preserve the golden frame */

+            if (s->framep[VP56_FRAME_GOLDEN] == s->framep[VP56_FRAME_PREVIOUS]) {

+                AVFrame *gold = s->framep[VP56_FRAME_GOLDEN]->tf.f;

+                AVFrame *prev;

+                int i, j;

+

+                s->framep[VP56_FRAME_PREVIOUS] = vp8_find_free_buffer(s);

+                if ((ret = vp8_alloc_frame(s, s->framep[VP56_FRAME_PREVIOUS], 1)) < 0)

+                   return ret;

+                prev = s->framep[VP56_FRAME_PREVIOUS]->tf.f;

+

+                fade(prev->data[0], prev->linesize[0], gold->data[0], gold->linesize[0], s->mb_width * 16, s->mb_height * 16, alpha, beta);

+                for (j = 1; j < 3; j++)

+                    for (i = 0; i < s->mb_height * 8; i++)

+                        memcpy(prev->data[j] + i * prev->linesize[j], gold->data[j] + i * gold->linesize[j], s->mb_width * 8);

+            } else {

+                AVFrame *prev = s->framep[VP56_FRAME_PREVIOUS]->tf.f;

+                fade(prev->data[0], prev->linesize[0], prev->data[0], prev->linesize[0], s->mb_width * 16, s->mb_height * 16, alpha, beta);

+            }

+

+        }

+    }

+

+    /* F. Loop filter type */

+    if (!s->profile)

+        s->filter.simple = vp8_rac_get(c);

+

+    /* G. DCT coefficient ordering specification */

+    if (vp8_rac_get(c))

+        for (i = 1; i < 16; i++)

+            s->prob[0].scan[i] = zigzag_scan[vp8_rac_get_uint(c, 4)];

+

+    /* H. Loop filter levels  */

+    if (s->profile > 0)

+        s->filter.simple = vp8_rac_get(c);

+    s->filter.level     = vp8_rac_get_uint(c, 6);

+    s->filter.sharpness = vp8_rac_get_uint(c, 3);

+

+    /* I. DCT coefficient probability update; 13.3 Token Probability Updates */

+    vp78_update_probability_tables(s);

+

+    s->mbskip_enabled = 0;

+

+    /* J. The remaining frame header data occurs ONLY FOR INTERFRAMES */

+    if (!s->keyframe) {

+        s->prob->intra  = vp8_rac_get_uint(c, 8);

+        s->prob->last   = vp8_rac_get_uint(c, 8);

+        vp78_update_pred16x16_pred8x8_mvc_probabilities(s);

+    }

+

+    return 0;

+}

+#endif

-static int decode_frame_header(VP8Context *s, const uint8_t *buf, int buf_size)

+#if CONFIG_VP8_DECODER

+static int vp8_decode_frame_header(VP8Context *s, const uint8_t *buf, int buf_size)

 {

     VP56RangeCoder *c = &s->c;

-    int header_size, hscale, vscale, i, j, k, l, m, ret;

+    int header_size, hscale, vscale, ret;

     int width  = s->avctx->width;

     int height = s->avctx->height;

@@ -366,10 +619,7 @@ static int decode_frame_header(VP8Context *s, const uint8_t *buf, int buf_size)

             avpriv_request_sample(s->avctx, "Upscaling");

         s->update_golden = s->update_altref = VP56_FRAME_CURRENT;

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

-            for (j = 0; j < 16; j++)

-                memcpy(s->prob->token[i][j], vp8_token_default_probs[i][vp8_coeff_band[j]],

-                       sizeof(s->prob->token[i][j]));

+        vp78_reset_probability_tables(s);

         memcpy(s->prob->pred16x16, vp8_pred16x16_prob_inter, sizeof(s->prob->pred16x16));

         memcpy(s->prob->pred8x8c , vp8_pred8x8c_prob_inter , sizeof(s->prob->pred8x8c));

         memcpy(s->prob->mvc      , vp8_mv_default_prob     , sizeof(s->prob->mvc));

@@ -411,7 +661,7 @@ static int decode_frame_header(VP8Context *s, const uint8_t *buf, int buf_size)

             return ret;

     }

-    get_quants(s);

+    vp8_get_quants(s);

     if (!s->keyframe) {

         update_refs(s);

@@ -426,15 +676,7 @@ static int decode_frame_header(VP8Context *s, const uint8_t *buf, int buf_size)

     s->update_last = s->keyframe || vp8_rac_get(c);

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

-        for (j = 0; j < 8; j++)

-            for (k = 0; k < 3; k++)

-                for (l = 0; l < NUM_DCT_TOKENS-1; l++)

-                    if (vp56_rac_get_prob_branchy(c, vp8_token_update_probs[i][j][k][l])) {

-                        int prob = vp8_rac_get_uint(c, 8);

-                        for (m = 0; vp8_coeff_band_indexes[j][m] >= 0; m++)

-                            s->prob->token[i][vp8_coeff_band_indexes[j][m]][k][l] = prob;

-                    }

+    vp78_update_probability_tables(s);

     if ((s->mbskip_enabled = vp8_rac_get(c)))

         s->prob->mbskip = vp8_rac_get_uint(c, 8);

@@ -443,23 +685,12 @@ static int decode_frame_header(VP8Context *s, const uint8_t *buf, int buf_size)

         s->prob->intra  = vp8_rac_get_uint(c, 8);

         s->prob->last   = vp8_rac_get_uint(c, 8);

         s->prob->golden = vp8_rac_get_uint(c, 8);

-

-        if (vp8_rac_get(c))

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

-                s->prob->pred16x16[i] = vp8_rac_get_uint(c, 8);

-        if (vp8_rac_get(c))

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

-                s->prob->pred8x8c[i]  = vp8_rac_get_uint(c, 8);

-

-        // 17.2 MV probability update

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

-            for (j = 0; j < 19; j++)

-                if (vp56_rac_get_prob_branchy(c, vp8_mv_update_prob[i][j]))

-                    s->prob->mvc[i][j] = vp8_rac_get_nn(c);

+        vp78_update_pred16x16_pred8x8_mvc_probabilities(s);

     }

     return 0;

 }

+#endif

 static av_always_inline void clamp_mv(VP8Context *s, VP56mv *dst, const VP56mv *src)

 {

@@ -470,7 +701,7 @@ static av_always_inline void clamp_mv(VP8Context *s, VP56mv *dst, const VP56mv *

 /**

  * Motion vector coding, 17.1.

  */

-static int read_mv_component(VP56RangeCoder *c, const uint8_t *p)

+static av_always_inline int read_mv_component(VP56RangeCoder *c, const uint8_t *p, int vp7)

 {

     int bit, x = 0;

@@ -479,9 +710,9 @@ static int read_mv_component(VP56RangeCoder *c, const uint8_t *p)

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

             x += vp56_rac_get_prob(c, p[9 + i]) << i;

-        for (i = 9; i > 3; i--)

+        for (i = (vp7 ? 7 : 9); i > 3; i--)

             x += vp56_rac_get_prob(c, p[9 + i]) << i;

-        if (!(x & 0xFFF0) || vp56_rac_get_prob(c, p[12]))

+        if (!(x & (vp7 ? 0xF0 : 0xFFF0)) || vp56_rac_get_prob(c, p[12]))

             x += 8;

     } else {

         // small_mvtree

@@ -498,6 +729,16 @@ static int read_mv_component(VP56RangeCoder *c, const uint8_t *p)

     return (x && vp56_rac_get_prob(c, p[1])) ? -x : x;

 }

+static int vp7_read_mv_component(VP56RangeCoder *c, const uint8_t *p)

+{

+    return read_mv_component(c, p, 1);

+}

+

+static int vp8_read_mv_component(VP56RangeCoder *c, const uint8_t *p)

+{

+    return read_mv_component(c, p, 0);

+}

+

 static av_always_inline

 const uint8_t *get_submv_prob(uint32_t left, uint32_t top)

 {

@@ -513,7 +754,7 @@ const uint8_t *get_submv_prob(uint32_t left, uint32_t top)

  * @returns the number of motion vectors parsed (2, 4 or 16)

  */

 static av_always_inline

-int decode_splitmvs(VP8Context *s, VP56RangeCoder *c, VP8Macroblock *mb, int layout)

+int decode_splitmvs(VP8Context *s, VP56RangeCoder *c, VP8Macroblock *mb, int layout, int vp7)

 {

     int part_idx;

     int n, num;

@@ -562,13 +803,13 @@ int decode_splitmvs(VP8Context *s, VP56RangeCoder *c, VP8Macroblock *mb, int lay

         else

             above = AV_RN32A(&cur_mv[mbsplits_cur[k - 4]]);

-        submv_prob = get_submv_prob(left, above);

+        submv_prob = vp7 ? vp7_submv_prob : get_submv_prob(left, above);

         if (vp56_rac_get_prob_branchy(c, submv_prob[0])) {

             if (vp56_rac_get_prob_branchy(c, submv_prob[1])) {

                 if (vp56_rac_get_prob_branchy(c, submv_prob[2])) {

-                    mb->bmv[n].y = mb->mv.y + read_mv_component(c, s->prob->mvc[0]);

-                    mb->bmv[n].x = mb->mv.x + read_mv_component(c, s->prob->mvc[1]);

+                    mb->bmv[n].y = mb->mv.y + VPX(vp7, read_mv_component)(c, s->prob->mvc[0]);

+                    mb->bmv[n].x = mb->mv.x + VPX(vp7, read_mv_component)(c, s->prob->mvc[1]);

                 } else {

                     AV_ZERO32(&mb->bmv[n]);

                 }

@@ -583,8 +824,120 @@ int decode_splitmvs(VP8Context *s, VP56RangeCoder *c, VP8Macroblock *mb, int lay

     return num;

 }

+/**

+ * the vp7 reference decoder uses a padding macroblock column (added to right

+ * edge of the frame) to guard against illegal macroblock offsets. The algorithm

+ * has bugs that permit offsets to straddle the padding column. This function

+ * replicates those bugs.

+ * @param[out] edge_x macroblock x address

+ * @param[out] edge_y macroblock y address

+ * @return macroblock offset legal (boolean)

+ */

+static int vp7_calculate_mb_offset(int mb_x, int mb_y, int mb_width, int xoffset, int yoffset, int boundary, int *edge_x, int *edge_y)

+{

+    int vwidth = mb_width + 1;

+    int new = (mb_y + yoffset) * vwidth + mb_x + xoffset;

+    if (new < boundary || new % vwidth == vwidth - 1)

+        return 0;

+    *edge_y = new / vwidth;

+    *edge_x = new % vwidth;

+    return 1;

+}

+

+static const VP56mv * get_bmv_ptr(const VP8Macroblock *mb, int subblock)

+{

+    return &mb->bmv[mb->mode == VP8_MVMODE_SPLIT ? vp8_mbsplits[mb->partitioning][subblock] : 0];

+}

+

 static av_always_inline

-void decode_mvs(VP8Context *s, VP8Macroblock *mb, int mb_x, int mb_y, int layout)

+void vp7_decode_mvs(VP8Context *s, VP8Macroblock *mb, int mb_x, int mb_y, int layout)

+{

+    VP8Macroblock *mb_edge[12];

+    enum { CNT_ZERO, CNT_NEAREST, CNT_NEAR };

+    enum { VP8_EDGE_TOP, VP8_EDGE_LEFT, VP8_EDGE_TOPLEFT };

+    int idx = CNT_ZERO;

+    VP56mv near_mv[3];

+    uint8_t cnt[3] = { 0 };

+    VP56RangeCoder *c = &s->c;

+    int i;

+

+    AV_ZERO32(&near_mv[0]);

+    AV_ZERO32(&near_mv[1]);

+    AV_ZERO32(&near_mv[2]);

+

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

+        const VP7MVPred * pred = &vp7_mv_pred[i];

+        int edge_x, edge_y;

+

+        if (vp7_calculate_mb_offset(mb_x, mb_y, s->mb_width, pred->xoffset, pred->yoffset, !s->profile, &edge_x, &edge_y)) {

+            VP8Macroblock *edge = mb_edge[i] = (s->mb_layout == 1) ?

+                                                   s->macroblocks_base + (s->mb_width+1)*(edge_y + 1) + 1 + edge_x :

+                                                   s->macroblocks + (s->mb_height - edge_y - 1)*2 + edge_x;

+            uint32_t mv = AV_RN32A(get_bmv_ptr(edge, vp7_mv_pred[i].subblock));

+            if (mv) {

+                if (AV_RN32A(&near_mv[CNT_NEAREST])) {

+                    if (mv == AV_RN32A(&near_mv[CNT_NEAREST])) {

+                        idx = CNT_NEAREST;

+                    } else if (AV_RN32A(&near_mv[CNT_NEAR])) {

+                        if (mv != AV_RN32A(&near_mv[CNT_NEAR]))

+                            continue;

+                        idx = CNT_NEAR;

+                    } else {

+                        AV_WN32A(&near_mv[CNT_NEAR], mv);

+                        idx = CNT_NEAR;

+                    }

+                } else {

+                    AV_WN32A(&near_mv[CNT_NEAREST], mv);

+                    idx = CNT_NEAREST;

+                }

+            } else {

+                idx = CNT_ZERO;

+            }

+        } else {

+            idx = CNT_ZERO;

+        }

+        cnt[idx] += vp7_mv_pred[i].score;

+    }

+

+    mb->partitioning = VP8_SPLITMVMODE_NONE;

+

+    if (vp56_rac_get_prob_branchy(c, vp7_mode_contexts[cnt[CNT_ZERO]][0])) {

+        mb->mode = VP8_MVMODE_MV;

+

+        if (vp56_rac_get_prob_branchy(c, vp7_mode_contexts[cnt[CNT_NEAREST]][1])) {

+

+            if (vp56_rac_get_prob_branchy(c, vp7_mode_contexts[cnt[CNT_NEAR]][2])) {

+

+                if (cnt[CNT_NEAREST] > cnt[CNT_NEAR])

+                    AV_WN32A(&mb->mv, cnt[CNT_ZERO] > cnt[CNT_NEAREST] ? 0 : AV_RN32A(&near_mv[CNT_NEAREST]));

+                else

+                    AV_WN32A(&mb->mv, cnt[CNT_ZERO] > cnt[CNT_NEAR]    ? 0 : AV_RN32A(&near_mv[CNT_NEAR]));

+

+                if (vp56_rac_get_prob_branchy(c, vp7_mode_contexts[cnt[CNT_NEAR]][3])) {

+                    mb->mode = VP8_MVMODE_SPLIT;

+                    mb->mv = mb->bmv[decode_splitmvs(s, c, mb, layout, 1) - 1];

+                } else {

+                    mb->mv.y += vp7_read_mv_component(c, s->prob->mvc[0]);

+                    mb->mv.x += vp7_read_mv_component(c, s->prob->mvc[1]);

+                    mb->bmv[0] = mb->mv;

+                }

+            } else {

+                mb->mv = near_mv[CNT_NEAR];

+                mb->bmv[0] = mb->mv;

+            }

+        } else {

+            mb->mv = near_mv[CNT_NEAREST];

+            mb->bmv[0] = mb->mv;

+        }

+    } else {

+        mb->mode = VP8_MVMODE_ZERO;

+        AV_ZERO32(&mb->mv);

+        mb->bmv[0] = mb->mv;

+    }

+}

+

+static av_always_inline

+void vp8_decode_mvs(VP8Context *s, VP8Macroblock *mb, int mb_x, int mb_y, int layout)

 {

     VP8Macroblock *mb_edge[3] = { 0 /* top */,

                                   mb - 1 /* left */,

@@ -661,10 +1014,10 @@ void decode_mvs(VP8Context *s, VP8Macroblock *mb, int mb_x, int mb_y, int layout

                 if (vp56_rac_get_prob_branchy(c, vp8_mode_contexts[cnt[CNT_SPLITMV]][3])) {

                     mb->mode = VP8_MVMODE_SPLIT;

-                    mb->mv = mb->bmv[decode_splitmvs(s, c, mb, layout) - 1];

+                    mb->mv = mb->bmv[decode_splitmvs(s, c, mb, layout, 0) - 1];

                 } else {

-                    mb->mv.y += read_mv_component(c, s->prob->mvc[0]);

-                    mb->mv.x += read_mv_component(c, s->prob->mvc[1]);

+                    mb->mv.y += vp8_read_mv_component(c, s->prob->mvc[0]);

+                    mb->mv.x += vp8_read_mv_component(c, s->prob->mvc[1]);

                     mb->bmv[0] = mb->mv;

                 }

             } else {

@@ -716,17 +1069,32 @@ void decode_intra4x4_modes(VP8Context *s, VP56RangeCoder *c, VP8Macroblock *mb,

     }

 }

+static const char * vp7_feature_name[] = { "q-index", "lf-delta", "partial-golden-update", "blit-pitch" };

+

 static av_always_inline

 void decode_mb_mode(VP8Context *s, VP8Macroblock *mb, int mb_x, int mb_y,

-                    uint8_t *segment, uint8_t *ref, int layout)

+                    uint8_t *segment, uint8_t *ref, int layout, int vp7)

 {

     VP56RangeCoder *c = &s->c;

-    if (s->segmentation.update_map) {

-        int bit  = vp56_rac_get_prob(c, s->prob->segmentid[0]);

-        *segment = vp56_rac_get_prob(c, s->prob->segmentid[1+bit]) + 2*bit;

-    } else if (s->segmentation.enabled)

-        *segment = ref ? *ref : *segment;

+    if (vp7) {

+        int i;

+        *segment = 0;

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

+            if (s->feature_enabled[i]) {

+                if (vp56_rac_get_prob(c, s->feature_present_prob[i])) {

+                      int index = vp8_rac_get_tree(c, vp7_feature_index_tree, s->feature_index_prob[i]);

+                      av_log(s->avctx, AV_LOG_WARNING, "Feature %s present in macroblock (value 0x%x)\n", vp7_feature_name[i], s->feature_value[i][index]);

+                }

+            }

+        }

+    } else {

+        if (s->segmentation.update_map) {

+            int bit  = vp56_rac_get_prob(c, s->prob->segmentid[0]);

+            *segment = vp56_rac_get_prob(c, s->prob->segmentid[1+bit]) + 2*bit;

+        } else if (s->segmentation.enabled)

+            *segment = ref ? *ref : *segment;

+    }

     mb->segment = *segment;

     mb->skip = s->mbskip_enabled ? vp56_rac_get_prob(c, s->prob->mbskip) : 0;

@@ -737,7 +1105,7 @@ void decode_mb_mode(VP8Context *s, VP8Macroblock *mb, int mb_x, int mb_y,

         if (mb->mode == MODE_I4x4) {

             decode_intra4x4_modes(s, c, mb, mb_x, 1, layout);

         } else {

-            const uint32_t modes = vp8_pred4x4_mode[mb->mode] * 0x01010101u;

+            const uint32_t modes = VPX(vp7, pred4x4_mode)[mb->mode] * 0x01010101u;

             if (s->mb_layout)

                 AV_WN32A(mb->intra4x4_pred_mode_top, modes);

             else

@@ -750,14 +1118,17 @@ void decode_mb_mode(VP8Context *s, VP8Macroblock *mb, int mb_x, int mb_y,

     } else if (vp56_rac_get_prob_branchy(c, s->prob->intra)) {

         // inter MB, 16.2

         if (vp56_rac_get_prob_branchy(c, s->prob->last))

-            mb->ref_frame = vp56_rac_get_prob(c, s->prob->golden) ?

+            mb->ref_frame = (!vp7 && vp56_rac_get_prob(c, s->prob->golden)) ?

                 VP56_FRAME_GOLDEN2 /* altref */ : VP56_FRAME_GOLDEN;

         else

             mb->ref_frame = VP56_FRAME_PREVIOUS;

         s->ref_count[mb->ref_frame-1]++;

         // motion vectors, 16.3

-        decode_mvs(s, mb, mb_x, mb_y, layout);

+        if (vp7)

+            vp7_decode_mvs(s, mb, mb_x, mb_y, layout);

+        else

+            vp8_decode_mvs(s, mb, mb_x, mb_y, layout);

     } else {

         // intra MB, 16.1

         mb->mode = vp8_rac_get_tree(c, vp8_pred16x16_tree_inter, s->prob->pred16x16);

@@ -772,7 +1143,28 @@ void decode_mb_mode(VP8Context *s, VP8Macroblock *mb, int mb_x, int mb_y,

     }

 }

-#ifndef decode_block_coeffs_internal

+static av_always_inline int inter_predict_dc(int16_t block[16], int16_t pred[2])

+{

+    int16_t dc = block[0];

+    int ret = 0;

+

+    if (pred[1] > 3) {

+        dc += pred[0];

+        ret = 1;

+    }

+

+    if (!pred[0] || !dc || FFSIGN(pred[0]) != FFSIGN(dc)) {

+        block[0] = pred[0] = dc;

+        pred[1] = 0;

+    } else {

+        if (pred[0] == dc)

+            pred[1]++;

+        block[0] = pred[0] = dc;

+    }

+

+    return ret;

+}

+

 /**

  * @param r arithmetic bitstream reader context

  * @param block destination for block coefficients

@@ -782,14 +1174,17 @@ void decode_mb_mode(VP8Context *s, VP8Macroblock *mb, int mb_x, int mb_y,

  * @return 0 if no coeffs were decoded

  *         otherwise, the index of the last coeff decoded plus one

  */

-static int decode_block_coeffs_internal(VP56RangeCoder *r, int16_t block[16],

+static av_always_inline

+int decode_block_coeffs_internal(VP56RangeCoder *r, int16_t block[16],

                                         uint8_t probs[16][3][NUM_DCT_TOKENS-1],

-                                        int i, uint8_t *token_prob, int16_t qmul[2])

+                                        int i, uint8_t *token_prob, int16_t qmul[2],

+                                        const uint8_t scan[16], int vp7)

 {

     VP56RangeCoder c = *r;

     goto skip_eob;

     do {

         int coeff;

+restart:

         if (!vp56_rac_get_prob_branchy(&c, token_prob[0]))   // DCT_EOB

             break;

@@ -798,6 +1193,8 @@ skip_eob:

             if (++i == 16)

                 break; // invalid input; blocks should end with EOB

             token_prob = probs[i][0];

+            if (vp7)

+                goto restart;

             goto skip_eob;

         }