Merge commit '53c20f17c78d1d8a0fc2505868f201e69ff59cc5'
authorMichael Niedermayer <michaelni@gmx.at>
Sun, 30 Mar 2014 00:39:46 +0000 (01:39 +0100)
committerMichael Niedermayer <michaelni@gmx.at>
Sun, 30 Mar 2014 00:55:31 +0000 (01:55 +0100)
* commit '53c20f17c78d1d8a0fc2505868f201e69ff59cc5':
  vp8: K&R formatting cosmetics

Conflicts:
libavcodec/vp8.c
libavcodec/vp8.h
libavcodec/vp8data.h
libavcodec/vp8dsp.c

Merged-by: Michael Niedermayer <michaelni@gmx.at>
1  2 
libavcodec/vp8.c
libavcodec/vp8.h
libavcodec/vp8_parser.c
libavcodec/vp8data.h
libavcodec/vp8dsp.c
libavcodec/vp8dsp.h

@@@ -100,9 -91,7 +101,8 @@@ static int vp8_ref_frame(VP8Context *s
  
      return 0;
  }
 +#endif
  
  static void vp8_decode_flush_impl(AVCodecContext *avctx, int free_mem)
  {
      VP8Context *s = avctx->priv_data;
@@@ -159,22 -124,25 +159,25 @@@ static int update_dimensions(VP8Contex
              return ret;
      }
  
-     s->mb_width  = (s->avctx->coded_width +15) / 16;
-     s->mb_height = (s->avctx->coded_height+15) / 16;
+     s->mb_width  = (s->avctx->coded_width  + 15) / 16;
+     s->mb_height = (s->avctx->coded_height + 15) / 16;
  
-     s->mb_layout = s->vp7 || (avctx->active_thread_type == FF_THREAD_SLICE) && (FFMIN(s->num_coeff_partitions, avctx->thread_count) > 1);
 -    s->mb_layout = (avctx->active_thread_type == FF_THREAD_SLICE) &&
++    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);
-     }
-     else // Sliced threading
-         s->macroblocks_base       = av_mallocz((s->mb_width+2)*(s->mb_height+2)*sizeof(*s->macroblocks));
-     s->top_nnz                    = av_mallocz(s->mb_width*sizeof(*s->top_nnz));
-     s->top_border                 = av_mallocz((s->mb_width+1)*sizeof(*s->top_border));
-     s->thread_data                = av_mallocz(MAX_THREADS*sizeof(VP8ThreadData));
+         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);
+     } else // Sliced threading
+         s->macroblocks_base = av_mallocz((s->mb_width + 2) * (s->mb_height + 2) *
+                                          sizeof(*s->macroblocks));
+     s->top_nnz     = av_mallocz(s->mb_width * sizeof(*s->top_nnz));
+     s->top_border  = av_mallocz((s->mb_width + 1) * sizeof(*s->top_border));
+     s->thread_data = av_mallocz(MAX_THREADS * sizeof(VP8ThreadData));
  
      for (i = 0; i < MAX_THREADS; i++) {
-         s->thread_data[i].filter_strength = av_mallocz(s->mb_width*sizeof(*s->thread_data[0].filter_strength));
+         s->thread_data[i].filter_strength =
+             av_mallocz(s->mb_width * sizeof(*s->thread_data[0].filter_strength));
  #if HAVE_THREADS
          pthread_mutex_init(&s->thread_data[i].lock, NULL);
          pthread_cond_init(&s->thread_data[i].cond, NULL);
@@@ -347,53 -290,7 +350,54 @@@ static VP56Frame ref_to_update(VP8Conte
      }
      return VP56_FRAME_NONE;
  }
-             memcpy(s->prob->token[i][j], vp8_token_default_probs[i][vp8_coeff_band[j]],
 +#endif
 +
 +static void vp78_reset_probability_tables(VP8Context *s)
 +{
 +    int i, j;
 +    for (i = 0; i < 4; i++)
 +        for (j = 0; j < 16; j++)
-                 for (l = 0; l < NUM_DCT_TOKENS-1; l++)
++            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;
@@@ -631,10 -348,17 +638,13 @@@ static int vp8_decode_frame_header(VP8C
              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));
+         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));
          memset(&s->segmentation, 0, sizeof(s->segmentation));
          memset(&s->lf_delta, 0, sizeof(s->lf_delta));
      }
      }
  
      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) {
 -        width != s->avctx->width || height != s->avctx->height)
++        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;
-     }
  
 -    get_quants(s);
 +    vp8_get_quants(s);
  
      if (!s->keyframe) {
          update_refs(s);
  
      return 0;
  }
 +#endif
  
- static av_always_inline void clamp_mv(VP8Context *s, VP56mv *dst, const VP56mv *src)
+ static av_always_inline
+ void clamp_mv(VP8Context *s, VP56mv *dst, const VP56mv *src)
  {
      dst->x = av_clip(src->x, s->mv_min.x, s->mv_max.x);
      dst->y = av_clip(src->y, s->mv_min.y, s->mv_max.y);
@@@ -836,124 -567,13 +845,125 @@@ int decode_splitmvs(VP8Context *s, VP56
      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 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)
 -void decode_mvs(VP8Context *s, VP8Macroblock *mb,
 -                int mb_x, int mb_y, int layout)
++void vp8_decode_mvs(VP8Context *s, VP8Macroblock *mb,
++                    int mb_x, int mb_y, int layout)
  {
-     VP8Macroblock *mb_edge[3] = { 0 /* top */,
+     VP8Macroblock *mb_edge[3] = { 0      /* top */,
                                    mb - 1 /* left */,
-                                   0 /* top-left */ };
+                                   0      /* top-left */ };
      enum { CNT_ZERO, CNT_NEAREST, CNT_NEAR, CNT_SPLITMV };
      enum { VP8_EDGE_TOP, VP8_EDGE_LEFT, VP8_EDGE_TOPLEFT };
      int idx = CNT_ZERO;
  
                  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, 0) - 1];
 -                    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 += vp8_read_mv_component(c, s->prob->mvc[0]);
-                     mb->mv.x += vp8_read_mv_component(c, s->prob->mvc[1]);
 -                    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 {
@@@ -1059,9 -679,9 +1069,9 @@@ void decode_intra4x4_modes(VP8Context *
      }
      if (keyframe) {
          int x, y;
-         uint8_ttop;
-         uint8_tconst left = s->intra4x4_pred_mode_left;
+         uint8_t *top;
+         uint8_t *const left = s->intra4x4_pred_mode_left;
 -        if (layout == 1)
 +        if (layout)
              top = mb->intra4x4_pred_mode_top;
          else
              top = s->intra4x4_pred_mode_top + 4 * mb_x;
@@@ -1130,17 -737,15 +1143,19 @@@ void decode_mb_mode(VP8Context *s, VP8M
      } 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 = (!vp7 && vp56_rac_get_prob(c, s->prob->golden)) ?
-                 VP56_FRAME_GOLDEN2 /* altref */ : VP56_FRAME_GOLDEN;
+             mb->ref_frame =
 -                vp56_rac_get_prob(c, s->prob->golden) ? VP56_FRAME_GOLDEN2 /* altref */
++                (!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]++;
+         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);
      }
  }
  
 -#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 r     arithmetic bitstream reader context
   * @param block destination for block coefficients
   * @param probs probabilities to use when reading trees from the bitstream
-  * @param i initial coeff index, 0 unless a separate DC block is coded
-  * @param qmul array holding the dc/ac dequant factor at position 0/1
+  * @param i     initial coeff index, 0 unless a separate DC block is coded
+  * @param qmul  array holding the dc/ac dequant factor at position 0/1
+  *
   * @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],
+                                         uint8_t probs[16][3][NUM_DCT_TOKENS - 1],
+                                         int i, uint8_t *token_prob,
 -                                        int16_t qmul[2])
++                                        int16_t qmul[2],
 +                                        const uint8_t scan[16], int vp7)
  {
      VP56RangeCoder c = *r;
      goto skip_eob;
@@@ -1237,49 -819,32 +1255,50 @@@ skip_eob
                      coeff += vp8_rac_get_coeff(&c, ff_vp8_dct_cat_prob[cat]);
                  }
              }
-             token_prob = probs[i+1][2];
+             token_prob = probs[i + 1][2];
          }
 -        block[zigzag_scan[i]] = (vp8_rac_get(&c) ? -coeff : coeff) * qmul[!!i];
 +        block[scan[i]] = (vp8_rac_get(&c) ? -coeff : coeff) * qmul[!!i];
      } while (++i < 16);
  
      *r = c;
      return i;
  }
-                                         uint8_t probs[16][3][NUM_DCT_TOKENS-1],
 +
 +static int vp7_decode_block_coeffs_internal(VP56RangeCoder *r, int16_t block[16],
-                                         uint8_t probs[16][3][NUM_DCT_TOKENS-1],
++                                        uint8_t probs[16][3][NUM_DCT_TOKENS - 1],
 +                                        int i, uint8_t *token_prob, int16_t qmul[2],
 +                                        const uint8_t scan[16])
 +{
 +    return decode_block_coeffs_internal(r, block, probs, i, token_prob, qmul, scan, 1);
 +}
 +
 +#ifndef vp8_decode_block_coeffs_internal
 +static int vp8_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])
 +{
 +    return decode_block_coeffs_internal(r, block, probs, i, token_prob, qmul, zigzag_scan, 0);
 +}
  #endif
  
  /**
-  * @param c arithmetic bitstream reader context
-  * @param block destination for block coefficients
-  * @param probs probabilities to use when reading trees from the bitstream
-  * @param i initial coeff index, 0 unless a separate DC block is coded
+  * @param c          arithmetic bitstream reader context
+  * @param block      destination for block coefficients
+  * @param probs      probabilities to use when reading trees from the bitstream
+  * @param i          initial coeff index, 0 unless a separate DC block is coded
   * @param zero_nhood the initial prediction context for number of surrounding
   *                   all-zero blocks (only left/top, so 0-2)
-  * @param qmul array holding the dc/ac dequant factor at position 0/1
-  * @param scan scan pattern (VP7 only)
+  * @param qmul       array holding the dc/ac dequant factor at position 0/1
++ * @param scan       scan pattern (VP7 only)
+  *
   * @return 0 if no coeffs were decoded
   *         otherwise, the index of the last coeff decoded plus one
   */
  static av_always_inline
  int decode_block_coeffs(VP56RangeCoder *c, int16_t block[16],
-                         uint8_t probs[16][3][NUM_DCT_TOKENS-1],
+                         uint8_t probs[16][3][NUM_DCT_TOKENS - 1],
 -                        int i, int zero_nhood, int16_t qmul[2])
 +                        int i, int zero_nhood, int16_t qmul[2],
 +                        const uint8_t scan[16], int vp7)
  {
      uint8_t *token_prob = probs[i][zero_nhood];
      if (!vp56_rac_get_prob_branchy(c, token_prob[0]))   // DCT_EOB
  }
  
  static av_always_inline
- void decode_mb_coeffs(VP8Context *s, VP8ThreadData *td, VP56RangeCoder *c, VP8Macroblock *mb,
-                       uint8_t t_nnz[9], uint8_t l_nnz[9], int vp7)
+ void decode_mb_coeffs(VP8Context *s, VP8ThreadData *td, VP56RangeCoder *c,
 -                      VP8Macroblock *mb, uint8_t t_nnz[9], uint8_t l_nnz[9])
++                      VP8Macroblock *mb, uint8_t t_nnz[9], uint8_t l_nnz[9],
++                      int vp7)
  {
      int i, x, y, luma_start = 0, luma_ctx = 3;
      int nnz_pred, nnz, nnz_total = 0;
          nnz_pred = t_nnz[8] + l_nnz[8];
  
          // decode DC values and do hadamard
-         nnz = decode_block_coeffs(c, td->block_dc, s->prob->token[1], 0, nnz_pred,
-                                   s->qmat[segment].luma_dc_qmul, zigzag_scan, vp7);
+         nnz = decode_block_coeffs(c, td->block_dc, s->prob->token[1], 0,
 -                                  nnz_pred, s->qmat[segment].luma_dc_qmul);
++                                  nnz_pred, s->qmat[segment].luma_dc_qmul,
++                                  zigzag_scan, vp7);
          l_nnz[8] = t_nnz[8] = !!nnz;
 +
 +        if (vp7 && mb->mode > MODE_I4x4)
 +            nnz |= inter_predict_dc(td->block_dc, s->inter_dc_pred[mb->ref_frame - 1]);
 +
          if (nnz) {
              nnz_total += nnz;
-             block_dc = 1;
+             block_dc   = 1;
              if (nnz == 1)
                  s->vp8dsp.vp8_luma_dc_wht_dc(td->block, td->block_dc);
              else
      for (y = 0; y < 4; y++)
          for (x = 0; x < 4; x++) {
              nnz_pred = l_nnz[y] + t_nnz[x];
-             nnz = decode_block_coeffs(c, td->block[y][x], s->prob->token[luma_ctx], luma_start,
-                                       nnz_pred, s->qmat[segment].luma_qmul, s->prob[0].scan, vp7);
-             // nnz+block_dc may be one more than the actual last index, but we don't care
+             nnz = decode_block_coeffs(c, td->block[y][x],
+                                       s->prob->token[luma_ctx],
+                                       luma_start, nnz_pred,
 -                                      s->qmat[segment].luma_qmul);
++                                      s->qmat[segment].luma_qmul,
++                                      s->prob[0].scan, vp7);
+             /* nnz+block_dc may be one more than the actual last index,
+              * but we don't care */
              td->non_zero_count_cache[y][x] = nnz + block_dc;
              t_nnz[x] = l_nnz[y] = !!nnz;
              nnz_total += nnz;
      for (i = 4; i < 6; i++)
          for (y = 0; y < 2; y++)
              for (x = 0; x < 2; x++) {
-                 nnz_pred = l_nnz[i+2*y] + t_nnz[i+2*x];
-                 nnz = decode_block_coeffs(c, td->block[i][(y<<1)+x], s->prob->token[2], 0,
-                                           nnz_pred, s->qmat[segment].chroma_qmul, s->prob[0].scan, vp7);
-                 td->non_zero_count_cache[i][(y<<1)+x] = nnz;
-                 t_nnz[i+2*x] = l_nnz[i+2*y] = !!nnz;
-                 nnz_total += nnz;
+                 nnz_pred = l_nnz[i + 2 * y] + t_nnz[i + 2 * x];
+                 nnz      = decode_block_coeffs(c, td->block[i][(y << 1) + x],
+                                                s->prob->token[2],
+                                                0, nnz_pred,
 -                                               s->qmat[segment].chroma_qmul);
++                                               s->qmat[segment].chroma_qmul, s->prob[0].scan, vp7);
+                 td->non_zero_count_cache[i][(y << 1) + x] = nnz;
+                 t_nnz[i + 2 * x] = l_nnz[i + 2 * y] = !!nnz;
+                 nnz_total       += nnz;
              }
  
      // if there were no coded coeffs despite the macroblock not being marked skip,
@@@ -1405,14 -974,12 +1436,12 @@@ int check_dc_pred8x8_mode(int mode, in
  }
  
  static av_always_inline
 -int check_tm_pred8x8_mode(int mode, int mb_x, int mb_y)
 +int check_tm_pred8x8_mode(int mode, int mb_x, int mb_y, int vp7)
  {
-     if (!mb_x) {
+     if (!mb_x)
 -        return mb_y ? VERT_PRED8x8 : DC_129_PRED8x8;
 +        return mb_y ? VERT_PRED8x8 : (vp7 ? DC_128_PRED8x8 : DC_129_PRED8x8);
-     } else {
+     else
          return mb_y ? mode : HOR_PRED8x8;
-     }
  }
  
  static av_always_inline
@@@ -1422,11 -989,11 +1451,11 @@@ int check_intra_pred8x8_mode_emuedge(in
      case DC_PRED8x8:
          return check_dc_pred8x8_mode(mode, mb_x, mb_y);
      case VERT_PRED8x8:
 -        return !mb_y ? DC_127_PRED8x8 : mode;
 +        return !mb_y ? (vp7 ? DC_128_PRED8x8 : DC_127_PRED8x8) : mode;
      case HOR_PRED8x8:
 -        return !mb_x ? DC_129_PRED8x8 : mode;
 +        return !mb_x ? (vp7 ? DC_128_PRED8x8 : DC_129_PRED8x8) : mode;
-     case PLANE_PRED8x8 /*TM*/:
+     case PLANE_PRED8x8: /* TM */
 -        return check_tm_pred8x8_mode(mode, mb_x, mb_y);
 +        return check_tm_pred8x8_mode(mode, mb_x, mb_y, vp7);
      }
      return mode;
  }
@@@ -1461,10 -1028,11 +1490,11 @@@ int check_intra_pred4x4_mode_emuedge(in
          }
          /* fall-through */
      case HOR_UP_PRED:
 -        return !mb_x ? DC_129_PRED : mode;
 +        return !mb_x ? (vp7 ? DC_128_PRED : DC_129_PRED) : mode;
      case TM_VP8_PRED:
 -        return check_tm_pred4x4_mode(mode, mb_x, mb_y);
 +        return check_tm_pred4x4_mode(mode, mb_x, mb_y, vp7);
-     case DC_PRED: // 4x4 DC doesn't use the same "H.264-style" exceptions as 16x16/8x8 DC
+     case DC_PRED: /* 4x4 DC doesn't use the same "H.264-style" exceptions
+                    * as 16x16/8x8 DC */
      case DIAG_DOWN_RIGHT_PRED:
      case VERT_RIGHT_PRED:
      case HOR_DOWN_PRED:
@@@ -1526,31 -1091,33 +1555,33 @@@ void intra_predict(VP8Context *s, VP8Th
                  } else if (x == 3)
                      topright = tr_right;
  
-                 mode = check_intra_pred4x4_mode_emuedge(intra4x4[x], mb_x + x, mb_y + y, &copy, vp7);
+                 mode = check_intra_pred4x4_mode_emuedge(intra4x4[x],
+                                                         mb_x + x, mb_y + y,
 -                                                        &copy);
++                                                        &copy, vp7);
                  if (copy) {
-                     dst = copy_dst + 12;
+                     dst      = copy_dst + 12;
                      linesize = 8;
                      if (!(mb_y + y)) {
 -                        copy_dst[3] = 127U;
 -                        AV_WN32A(copy_dst + 4, 127U * 0x01010101U);
 +                        copy_dst[3] = lo;
-                         AV_WN32A(copy_dst+4, lo * 0x01010101U);
++                        AV_WN32A(copy_dst + 4, lo * 0x01010101U);
                      } else {
-                         AV_COPY32(copy_dst+4, ptr+4*x-s->linesize);
+                         AV_COPY32(copy_dst + 4, ptr + 4 * x - s->linesize);
                          if (!(mb_x + x)) {
 -                            copy_dst[3] = 129U;
 +                            copy_dst[3] = hi;
                          } else {
-                             copy_dst[3] = ptr[4*x-s->linesize-1];
+                             copy_dst[3] = ptr[4 * x - s->linesize - 1];
                          }
                      }
                      if (!(mb_x + x)) {
                          copy_dst[11] =
                          copy_dst[19] =
                          copy_dst[27] =
 -                        copy_dst[35] = 129U;
 +                        copy_dst[35] = hi;
                      } else {
-                         copy_dst[11] = ptr[4*x              -1];
-                         copy_dst[19] = ptr[4*x+s->linesize  -1];
-                         copy_dst[27] = ptr[4*x+s->linesize*2-1];
-                         copy_dst[35] = ptr[4*x+s->linesize*3-1];
+                         copy_dst[11] = ptr[4 * x                   - 1];
+                         copy_dst[19] = ptr[4 * x + s->linesize     - 1];
+                         copy_dst[27] = ptr[4 * x + s->linesize * 2 - 1];
+                         copy_dst[35] = ptr[4 * x + s->linesize * 3 - 1];
                      }
                  }
                  s->hpc.pred4x4[mode](dst, topright, linesize);
@@@ -1902,7 -1489,8 +1955,8 @@@ chroma_idct_end
      }
  }
  
- static av_always_inline void filter_level_for_mb(VP8Context *s, VP8Macroblock *mb, VP8FilterStrength *f, int vp7)
+ static av_always_inline
 -void filter_level_for_mb(VP8Context *s, VP8Macroblock *mb, VP8FilterStrength *f)
++void filter_level_for_mb(VP8Context *s, VP8Macroblock *mb, VP8FilterStrength *f, int vp7)
  {
      int interior_limit, filter_level;
  
  
      f->filter_level = filter_level;
      f->inner_limit = interior_limit;
-     f->inner_filter = vp7 || !mb->skip || mb->mode == MODE_I4x4 || mb->mode == VP8_MVMODE_SPLIT;
 -    f->inner_filter = !mb->skip || mb->mode == MODE_I4x4 ||
++    f->inner_filter = vp7 || !mb->skip || mb->mode == MODE_I4x4 ||
+                       mb->mode == VP8_MVMODE_SPLIT;
  }
  
- static av_always_inline void filter_mb(VP8Context *s, uint8_t *dst[3], VP8FilterStrength *f, int mb_x, int mb_y, int vp7)
+ static av_always_inline
+ void filter_mb(VP8Context *s, uint8_t *dst[3], VP8FilterStrength *f,
 -               int mb_x, int mb_y)
++               int mb_x, int mb_y, int vp7)
  {
 -    int mbedge_lim, bedge_lim, hev_thresh;
 +    int mbedge_lim, bedge_lim_y, bedge_lim_uv, hev_thresh;
      int filter_level = f->filter_level;
      int inner_limit = f->inner_limit;
      int inner_filter = f->inner_filter;
      if (!filter_level)
          return;
  
 -    bedge_lim  = 2 * filter_level + inner_limit;
 -    mbedge_lim = bedge_lim + 4;
 +    if (vp7) {
-         bedge_lim_y  =   filter_level;
-         bedge_lim_uv = 2*filter_level;
-         mbedge_lim   =   filter_level + 2;
++        bedge_lim_y  =     filter_level;
++        bedge_lim_uv = 2 * filter_level;
++        mbedge_lim   =     filter_level + 2;
 +    } else {
 +        bedge_lim_y  =
-         bedge_lim_uv = 2*filter_level + inner_limit;
-         mbedge_lim   =   bedge_lim_y + 4;
++        bedge_lim_uv = 2 * filter_level + inner_limit;
++        mbedge_lim   =     bedge_lim_y + 4;
 +    }
  
      hev_thresh = hev_thresh_lut[s->keyframe][filter_level];
  
                                         mbedge_lim, inner_limit, hev_thresh);
      }
  
 -    if (inner_filter) {
 -        s->vp8dsp.vp8_h_loop_filter16y_inner(dst[0] +  4, linesize, bedge_lim,
 -                                             inner_limit, hev_thresh);
 -        s->vp8dsp.vp8_h_loop_filter16y_inner(dst[0] +  8, linesize, bedge_lim,
 -                                             inner_limit, hev_thresh);
 -        s->vp8dsp.vp8_h_loop_filter16y_inner(dst[0] + 12, linesize, bedge_lim,
 -                                             inner_limit, hev_thresh);
 -        s->vp8dsp.vp8_h_loop_filter8uv_inner(dst[1] +  4, dst[2] + 4,
 -                                             uvlinesize, bedge_lim,
 -                                             inner_limit, hev_thresh);
 +#define H_LOOP_FILTER_16Y_INNER(cond) \
 +    if (cond && inner_filter) {\
-         s->vp8dsp.vp8_h_loop_filter16y_inner(dst[0]+ 4, linesize, bedge_lim_y,\
++        s->vp8dsp.vp8_h_loop_filter16y_inner(dst[0] +  4, linesize, bedge_lim_y,\
 +                                             inner_limit, hev_thresh);\
-         s->vp8dsp.vp8_h_loop_filter16y_inner(dst[0]+ 8, linesize, bedge_lim_y,\
++        s->vp8dsp.vp8_h_loop_filter16y_inner(dst[0] +  8, linesize, bedge_lim_y,\
 +                                             inner_limit, hev_thresh);\
-         s->vp8dsp.vp8_h_loop_filter16y_inner(dst[0]+12, linesize, bedge_lim_y,\
++        s->vp8dsp.vp8_h_loop_filter16y_inner(dst[0] + 12, linesize, bedge_lim_y,\
 +                                             inner_limit, hev_thresh);\
-         s->vp8dsp.vp8_h_loop_filter8uv_inner(dst[1] + 4, dst[2] + 4,\
-                                              uvlinesize,  bedge_lim_uv,\
++        s->vp8dsp.vp8_h_loop_filter8uv_inner(dst[1] +  4, dst[2] + 4,\
++                                             uvlinesize, bedge_lim_uv,\
 +                                             inner_limit, hev_thresh);\
      }
  
 +    H_LOOP_FILTER_16Y_INNER(!vp7)
 +
      if (mb_y) {
-         s->vp8dsp.vp8_v_loop_filter16y(dst[0],     linesize,
+         s->vp8dsp.vp8_v_loop_filter16y(dst[0], linesize,
                                         mbedge_lim, inner_limit, hev_thresh);
-         s->vp8dsp.vp8_v_loop_filter8uv(dst[1],     dst[2],      uvlinesize,
+         s->vp8dsp.vp8_v_loop_filter8uv(dst[1], dst[2], uvlinesize,
                                         mbedge_lim, inner_limit, hev_thresh);
      }
  
      if (inner_filter) {
-         s->vp8dsp.vp8_v_loop_filter16y_inner(dst[0]+ 4*linesize,
-                                              linesize,    bedge_lim_y,
+         s->vp8dsp.vp8_v_loop_filter16y_inner(dst[0] +  4 * linesize,
 -                                             linesize, bedge_lim,
++                                             linesize, bedge_lim_y,
                                               inner_limit, hev_thresh);
-         s->vp8dsp.vp8_v_loop_filter16y_inner(dst[0]+ 8*linesize,
-                                              linesize,    bedge_lim_y,
+         s->vp8dsp.vp8_v_loop_filter16y_inner(dst[0] +  8 * linesize,
 -                                             linesize, bedge_lim,
++                                             linesize, bedge_lim_y,
                                               inner_limit, hev_thresh);
-         s->vp8dsp.vp8_v_loop_filter16y_inner(dst[0]+12*linesize,
-                                              linesize,    bedge_lim_y,
+         s->vp8dsp.vp8_v_loop_filter16y_inner(dst[0] + 12 * linesize,
 -                                             linesize, bedge_lim,
++                                             linesize, bedge_lim_y,
                                               inner_limit, hev_thresh);
-         s->vp8dsp.vp8_v_loop_filter8uv_inner(dst[1] + 4 * uvlinesize,
-                                              dst[2] + 4 * uvlinesize,
-                                              uvlinesize,  bedge_lim_uv,
+         s->vp8dsp.vp8_v_loop_filter8uv_inner(dst[1] +  4 * uvlinesize,
+                                              dst[2] +  4 * uvlinesize,
 -                                             uvlinesize, bedge_lim,
++                                             uvlinesize, bedge_lim_uv,
                                               inner_limit, hev_thresh);
      }
 +
 +    H_LOOP_FILTER_16Y_INNER(vp7)
  }
  
- static av_always_inline void filter_mb_simple(VP8Context *s, uint8_t *dst, VP8FilterStrength *f, int mb_x, int mb_y)
+ static av_always_inline
+ void filter_mb_simple(VP8Context *s, uint8_t *dst, VP8FilterStrength *f,
+                       int mb_x, int mb_y)
  {
      int mbedge_lim, bedge_lim;
      int filter_level = f->filter_level;
@@@ -2065,10 -1646,11 +2125,11 @@@ void decode_mv_mb_modes(AVCodecContext 
          s->mv_max.x = ((s->mb_width - 1) << 6) + MARGIN;
          for (mb_x = 0; mb_x < s->mb_width; mb_x++, mb_xy++, mb++) {
              if (mb_y == 0)
-                 AV_WN32A((mb-s->mb_width-1)->intra4x4_pred_mode_top, DC_PRED*0x01010101);
+                 AV_WN32A((mb - s->mb_width - 1)->intra4x4_pred_mode_top,
+                          DC_PRED * 0x01010101);
              decode_mb_mode(s, mb, mb_x, mb_y, curframe->seg_map->data + mb_xy,
                             prev_frame && prev_frame->seg_map ?
 -                           prev_frame->seg_map->data + mb_xy : NULL, 1);
 +                           prev_frame->seg_map->data + mb_xy : NULL, 1, vp7);
              s->mv_min.x -= 64;
              s->mv_max.x -= 64;
          }
      }
  }
  
 +#if CONFIG_VP7_DECODER
 +static void vp7_decode_mv_mb_modes(AVCodecContext *avctx, VP8Frame *curframe,
 +                                   VP8Frame *prev_frame)
 +{
 +    decode_mv_mb_modes(avctx, curframe, prev_frame, 1);
 +}
 +#endif
 +
 +#if CONFIG_VP8_DECODER
 +static void vp8_decode_mv_mb_modes(AVCodecContext *avctx, VP8Frame *curframe,
 +                                   VP8Frame *prev_frame)
 +{
 +    decode_mv_mb_modes(avctx, curframe, prev_frame, 0);
 +}
 +#endif
 +
  #if HAVE_THREADS
- #define check_thread_pos(td, otd, mb_x_check, mb_y_check)\
-     do {\
-         int tmp = (mb_y_check << 16) | (mb_x_check & 0xFFFF);\
-         if (otd->thread_mb_pos < tmp) {\
-             pthread_mutex_lock(&otd->lock);\
-             td->wait_mb_pos = tmp;\
-             do {\
-                 if (otd->thread_mb_pos >= tmp)\
-                     break;\
-                 pthread_cond_wait(&otd->cond, &otd->lock);\
-             } while (1);\
-             td->wait_mb_pos = INT_MAX;\
-             pthread_mutex_unlock(&otd->lock);\
-         }\
-     } while(0);
- #define update_pos(td, mb_y, mb_x)\
-     do {\
-     int pos              = (mb_y << 16) | (mb_x & 0xFFFF);\
-     int sliced_threading = (avctx->active_thread_type == FF_THREAD_SLICE) && (num_jobs > 1);\
-     int is_null          = (next_td == NULL) || (prev_td == NULL);\
-     int pos_check        = (is_null) ? 1 :\
-                             (next_td != td && pos >= next_td->wait_mb_pos) ||\
-                             (prev_td != td && pos >= prev_td->wait_mb_pos);\
-     td->thread_mb_pos = pos;\
-     if (sliced_threading && pos_check) {\
-         pthread_mutex_lock(&td->lock);\
-         pthread_cond_broadcast(&td->cond);\
-         pthread_mutex_unlock(&td->lock);\
-     }\
-     } while(0);
+ #define check_thread_pos(td, otd, mb_x_check, mb_y_check)                     \
+     do {                                                                      \
+         int tmp = (mb_y_check << 16) | (mb_x_check & 0xFFFF);                 \
+         if (otd->thread_mb_pos < tmp) {                                       \
+             pthread_mutex_lock(&otd->lock);                                   \
+             td->wait_mb_pos = tmp;                                            \
+             do {                                                              \
+                 if (otd->thread_mb_pos >= tmp)                                \
+                     break;                                                    \
+                 pthread_cond_wait(&otd->cond, &otd->lock);                    \
+             } while (1);                                                      \
+             td->wait_mb_pos = INT_MAX;                                        \
+             pthread_mutex_unlock(&otd->lock);                                 \
+         }                                                                     \
+     } while (0);
+ #define update_pos(td, mb_y, mb_x)                                            \
+     do {                                                                      \
+         int pos              = (mb_y << 16) | (mb_x & 0xFFFF);                \
+         int sliced_threading = (avctx->active_thread_type == FF_THREAD_SLICE) && \
+                                (num_jobs > 1);                                \
+         int is_null          = (next_td == NULL) || (prev_td == NULL);        \
+         int pos_check        = (is_null) ? 1                                  \
+                                          : (next_td != td &&                  \
+                                             pos >= next_td->wait_mb_pos) ||   \
+                                            (prev_td != td &&                  \
+                                             pos >= prev_td->wait_mb_pos);     \
+         td->thread_mb_pos = pos;                                              \
+         if (sliced_threading && pos_check) {                                  \
+             pthread_mutex_lock(&td->lock);                                    \
+             pthread_cond_broadcast(&td->cond);                                \
+             pthread_mutex_unlock(&td->lock);                                  \
+         }                                                                     \
+     } while (0);
  #else
  #define check_thread_pos(td, otd, mb_x_check, mb_y_check)
  #define update_pos(td, mb_y, mb_x)
@@@ -2158,24 -1731,24 +2226,25 @@@ static av_always_inline void decode_mb_
          if (prev_frame && s->segmentation.enabled &&
              !s->segmentation.update_map)
              ff_thread_await_progress(&prev_frame->tf, mb_y, 0);
-         mb = s->macroblocks + (s->mb_height - mb_y - 1)*2;
+         mb = s->macroblocks + (s->mb_height - mb_y - 1) * 2;
          memset(mb - 1, 0, sizeof(*mb)); // zero left macroblock
-         AV_WN32A(s->intra4x4_pred_mode_left, DC_PRED*0x01010101);
+         AV_WN32A(s->intra4x4_pred_mode_left, DC_PRED * 0x01010101);
      }
  
 -    memset(td->left_nnz, 0, sizeof(td->left_nnz));
 +    if (!vp7 || mb_y == 0)
 +        memset(td->left_nnz, 0, sizeof(td->left_nnz));
  
      s->mv_min.x = -MARGIN;
-     s->mv_max.x = ((s->mb_width  - 1) << 6) + MARGIN;
+     s->mv_max.x = ((s->mb_width - 1) << 6) + MARGIN;
  
      for (mb_x = 0; mb_x < s->mb_width; mb_x++, mb_xy++, mb++) {
          // Wait for previous thread to read mb_x+2, and reach mb_y-1.
          if (prev_td != td) {
              if (threadnr != 0) {
-                 check_thread_pos(td, prev_td, mb_x+(vp7?2:1), mb_y-(vp7?2:1));
 -                check_thread_pos(td, prev_td, mb_x + 1, mb_y - 1);
++                check_thread_pos(td, prev_td, mb_x + (vp7?2:1), mb_y - (vp7?2:1));
              } else {
-                 check_thread_pos(td, prev_td, (s->mb_width+3) + (mb_x+(vp7?2:1)), mb_y-(vp7?2:1));
+                 check_thread_pos(td, prev_td,
 -                                 (s->mb_width + 3) + (mb_x + 1), mb_y - 1);
++                                 (s->mb_width + 3) + (mb_x + (vp7?2:1)), mb_y - (vp7?2:1));
              }
          }
  
          }
  
          if (s->deblock_filter)
 -            filter_level_for_mb(s, mb, &td->filter_strength[mb_x]);
 +            filter_level_for_mb(s, mb, &td->filter_strength[mb_x], vp7);
  
-         if (s->deblock_filter && num_jobs != 1 && threadnr == num_jobs-1) {
+         if (s->deblock_filter && num_jobs != 1 && threadnr == num_jobs - 1) {
              if (s->filter.simple)
-                 backup_mb_border(s->top_border[mb_x+1], dst[0], NULL, NULL, s->linesize, 0, 1);
+                 backup_mb_border(s->top_border[mb_x + 1], dst[0],
+                                  NULL, NULL, s->linesize, 0, 1);
              else
-                 backup_mb_border(s->top_border[mb_x+1], dst[0], dst[1], dst[2], s->linesize, s->uvlinesize, 0);
+                 backup_mb_border(s->top_border[mb_x + 1], dst[0],
+                                  dst[1], dst[2], s->linesize, s->uvlinesize, 0);
          }
  
          prefetch_motion(s, mb, mb_x, mb_y, mb_xy, VP56_FRAME_GOLDEN2);
@@@ -2332,13 -1883,15 +2411,15 @@@ static int vp8_decode_mb_row_sliced(AVC
      VP8ThreadData *next_td = NULL, *prev_td = NULL;
      VP8Frame *curframe = s->curframe;
      int mb_y, num_jobs = s->num_jobs;
      td->thread_nr = threadnr;
      for (mb_y = jobnr; mb_y < s->mb_height; mb_y += num_jobs) {
-         if (mb_y >= s->mb_height) break;
-         td->thread_mb_pos = mb_y<<16;
+         if (mb_y >= s->mb_height)
+             break;
+         td->thread_mb_pos = mb_y << 16;
 -        vp8_decode_mb_row_no_filter(avctx, tdata, jobnr, threadnr);
 +        s->decode_mb_row_no_filter(avctx, tdata, jobnr, threadnr);
          if (s->deblock_filter)
 -            vp8_filter_mb_row(avctx, tdata, jobnr, threadnr);
 +            s->filter_mb_row(avctx, tdata, jobnr, threadnr);
          update_pos(td, mb_y, INT_MAX & 0xFFFF);
  
          s->mv_min.y -= 64;
@@@ -2386,41 -1940,60 +2468,44 @@@ int ff_vp8_decode_frame(AVCodecContext 
              &s->frames[i] != s->framep[VP56_FRAME_GOLDEN2])
              vp8_release_frame(s, &s->frames[i]);
  
 -    // find a free buffer
 -    for (i = 0; i < 5; i++)
 -        if (&s->frames[i] != prev_frame &&
 -            &s->frames[i] != s->framep[VP56_FRAME_PREVIOUS] &&
 -            &s->frames[i] != s->framep[VP56_FRAME_GOLDEN]   &&
 -            &s->frames[i] != s->framep[VP56_FRAME_GOLDEN2]) {
 -            curframe = s->framep[VP56_FRAME_CURRENT] = &s->frames[i];
 -            break;
 -        }
 -    if (i == 5) {
 -        av_log(avctx, AV_LOG_FATAL, "Ran out of free frames!\n");
 -        abort();
 -    }
 -    if (curframe->tf.f->data[0])
 -        vp8_release_frame(s, curframe);
 +    curframe = s->framep[VP56_FRAME_CURRENT] = vp8_find_free_buffer(s);
  
-     // Given that arithmetic probabilities are updated every frame, it's quite likely
-     // that the values we have on a random interframe are complete junk if we didn't
-     // start decode on a keyframe. So just don't display anything rather than junk.
+     /* Given that arithmetic probabilities are updated every frame, it's quite
+      * likely that the values we have on a random interframe are complete
+      * junk if we didn't start decode on a keyframe. So just don't display
+      * anything rather than junk. */
      if (!s->keyframe && (!s->framep[VP56_FRAME_PREVIOUS] ||
-                          !s->framep[VP56_FRAME_GOLDEN] ||
+                          !s->framep[VP56_FRAME_GOLDEN]   ||
                           !s->framep[VP56_FRAME_GOLDEN2])) {
-         av_log(avctx, AV_LOG_WARNING, "Discarding interframe without a prior keyframe!\n");
+         av_log(avctx, AV_LOG_WARNING,
+                "Discarding interframe without a prior keyframe!\n");
          ret = AVERROR_INVALIDDATA;
          goto err;
      }
  
      curframe->tf.f->key_frame = s->keyframe;
-     curframe->tf.f->pict_type = s->keyframe ? AV_PICTURE_TYPE_I : AV_PICTURE_TYPE_P;
+     curframe->tf.f->pict_type = s->keyframe ? AV_PICTURE_TYPE_I
+                                             : AV_PICTURE_TYPE_P;
 -    if ((ret = vp8_alloc_frame(s, curframe, referenced))) {
 -        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed!\n");
 +    if ((ret = vp8_alloc_frame(s, curframe, referenced)) < 0)
          goto err;
 -    }
  
      // check if golden and altref are swapped
-     if (s->update_altref != VP56_FRAME_NONE) {
-         s->next_framep[VP56_FRAME_GOLDEN2]  = s->framep[s->update_altref];
-     } else {
-         s->next_framep[VP56_FRAME_GOLDEN2]  = s->framep[VP56_FRAME_GOLDEN2];
-     }
-     if (s->update_golden != VP56_FRAME_NONE) {
-         s->next_framep[VP56_FRAME_GOLDEN]   = s->framep[s->update_golden];
-     } else {
-         s->next_framep[VP56_FRAME_GOLDEN]   = s->framep[VP56_FRAME_GOLDEN];
-     }
-     if (s->update_last) {
+     if (s->update_altref != VP56_FRAME_NONE)
+         s->next_framep[VP56_FRAME_GOLDEN2] = s->framep[s->update_altref];
+     else
+         s->next_framep[VP56_FRAME_GOLDEN2] = s->framep[VP56_FRAME_GOLDEN2];
+     if (s->update_golden != VP56_FRAME_NONE)
+         s->next_framep[VP56_FRAME_GOLDEN] = s->framep[s->update_golden];
+     else
+         s->next_framep[VP56_FRAME_GOLDEN] = s->framep[VP56_FRAME_GOLDEN];
+     if (s->update_last)
          s->next_framep[VP56_FRAME_PREVIOUS] = curframe;
-     } else {
+     else
          s->next_framep[VP56_FRAME_PREVIOUS] = s->framep[VP56_FRAME_PREVIOUS];
-     }
-     s->next_framep[VP56_FRAME_CURRENT]      = curframe;
+     s->next_framep[VP56_FRAME_CURRENT] = curframe;
  
      ff_thread_finish_setup(avctx);
  
  
  #include "libavutil/buffer.h"
  
- #include "vp56.h"
- #include "vp8dsp.h"
  #include "h264pred.h"
  #include "thread.h"
+ #include "vp56.h"
+ #include "vp8dsp.h"
  #if HAVE_PTHREADS
- #include <pthread.h>
+ #   include <pthread.h>
 +#elif HAVE_OS2THREADS
- #include "compat/os2threads.h"
++#   include "compat/os2threads.h"
  #elif HAVE_W32THREADS
- #include "compat/w32pthreads.h"
+ #   include "compat/w32pthreads.h"
  #endif
  
  #define VP8_MAX_QUANT 127
@@@ -236,9 -235,8 +237,9 @@@ typedef struct VP8Context 
          uint8_t golden;
          uint8_t pred16x16[4];
          uint8_t pred8x8c[3];
-         uint8_t token[4][16][3][NUM_DCT_TOKENS-1];
+         uint8_t token[4][16][3][NUM_DCT_TOKENS - 1];
          uint8_t mvc[2][19];
 +        uint8_t scan[16];
      } prob[2];
  
      VP8Macroblock *macroblocks_base;
Simple merge
  #include "vp8.h"
  #include "h264pred.h"
  
- static const uint8_t vp8_pred4x4_mode[] =
- {
 +static const uint8_t vp7_pred4x4_mode[] =
 +{
 +    [DC_PRED8x8]    = DC_PRED,
 +    [VERT_PRED8x8]  = TM_VP8_PRED,
 +    [HOR_PRED8x8]   = TM_VP8_PRED,
 +    [PLANE_PRED8x8] = TM_VP8_PRED,
 +};
 +
+ static const uint8_t vp8_pred4x4_mode[] = {
      [DC_PRED8x8]    = DC_PRED,
      [VERT_PRED8x8]  = VERT_PRED,
      [HOR_PRED8x8]   = HOR_PRED,
      [PLANE_PRED8x8] = TM_VP8_PRED,
  };
  
- static const int8_t vp8_pred16x16_tree_intra[4][2] =
- {
-     { -MODE_I4x4, 1 },                      // '0'
-      { 2, 3 },
-       {  -DC_PRED8x8,  -VERT_PRED8x8 },     // '100', '101'
-       { -HOR_PRED8x8, -PLANE_PRED8x8 },     // '110', '111'
+ static const int8_t vp8_pred16x16_tree_intra[4][2] = {
+     {   -MODE_I4x4,              1 }, // '0'
+     {            2,              3 },
+     {  -DC_PRED8x8,  -VERT_PRED8x8 }, // '100', '101'
+     { -HOR_PRED8x8, -PLANE_PRED8x8 }, // '110', '111'
  };
  
- static const int8_t vp8_pred16x16_tree_inter[4][2] =
- {
-     { -DC_PRED8x8, 1 },                     // '0'
-      { 2, 3 },
-       {  -VERT_PRED8x8, -HOR_PRED8x8 },     // '100', '101'
-       { -PLANE_PRED8x8, -MODE_I4x4 },       // '110', '111'
+ static const int8_t vp8_pred16x16_tree_inter[4][2] = {
+     {    -DC_PRED8x8,            1 }, // '0'
+     {              2,            3 },
+     {  -VERT_PRED8x8, -HOR_PRED8x8 }, // '100', '101'
+     { -PLANE_PRED8x8,   -MODE_I4x4 }, // '110', '111'
  };
  
 +typedef struct {
 +    int8_t  yoffset;
 +    int8_t  xoffset;
 +    uint8_t subblock;
 +    uint8_t score;
 +} VP7MVPred;
 +
 +#define VP7_MV_PRED_COUNT 12
 +static const VP7MVPred vp7_mv_pred[VP7_MV_PRED_COUNT] = {
 +    { -1,  0, 12, 8 },
 +    {  0, -1,  3, 8 },
 +    { -1, -1, 15, 2 },
 +    { -1,  1, 12, 2 },
 +    { -2,  0, 12, 2 },
 +    {  0, -2,  3, 2 },
 +    { -1, -2, 15, 1 },
 +    { -2, -1, 15, 1 },
 +    { -2,  1, 12, 1 },
 +    { -1,  2, 12, 1 },
 +    { -2, -2, 15, 1 },
 +    { -2,  2, 12, 1 },
 +};
 +
 +static const int vp7_mode_contexts[31][4] = {
 +    {   3,   3,   1, 246 },
 +    {   7,  89,  66, 239 },
 +    {  10,  90,  78, 238 },
 +    {  14, 118,  95, 241 },
 +    {  14, 123, 106, 238 },
 +    {  20, 140, 109, 240 },
 +    {  13, 155, 103, 238 },
 +    {  21, 158,  99, 240 },
 +    {  27,  82, 108, 232 },
 +    {  19,  99, 123, 217 },
 +    {  45, 139, 148, 236 },
 +    {  50, 117, 144, 235 },
 +    {  57, 128, 164, 238 },
 +    {  69, 139, 171, 239 },
 +    {  74, 154, 179, 238 },
 +    { 112, 165, 186, 242 },
 +    {  98, 143, 185, 245 },
 +    { 105, 153, 190, 250 },
 +    { 124, 167, 192, 245 },
 +    { 131, 186, 203, 246 },
 +    {  59, 184, 222, 224 },
 +    { 148, 215, 214, 213 },
 +    { 137, 211, 210, 219 },
 +    { 190, 227, 128, 228 },
 +    { 183, 228, 128, 228 },
 +    { 194, 234, 128, 228 },
 +    { 202, 236, 128, 228 },
 +    { 205, 240, 128, 228 },
 +    { 205, 244, 128, 228 },
 +    { 225, 246, 128, 228 },
 +    { 233, 251, 128, 228 },
 +};
 +
  static const int vp8_mode_contexts[6][4] = {
      {   7,   1,   1, 143 },
      {  14,  18,  14, 107 },
@@@ -142,16 -69,19 +134,21 @@@ static const uint8_t vp8_mbsplits[5][16
  };
  
  static const uint8_t vp8_mbfirstidx[4][16] = {
-     {  0,  8 }, {  0,  2 }, {  0,  2,  8,  10 },
-     {  0,  1,  2,  3,  4,  5,  6,  7,
-        8,  9, 10, 11, 12, 13, 14, 15 }
+     { 0, 8 },
+     { 0, 2 },
+     { 0, 2, 8, 10 },
+     { 0, 1, 2,  3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 }
  };
  
- static const uint8_t vp8_mbsplit_count[4] = {   2,   2,   4,  16 };
- static const uint8_t vp8_mbsplit_prob[3]  = { 110, 111, 150 };
+ static const uint8_t vp8_mbsplit_count[4] = {
+     2, 2, 4, 16
+ };
+ static const uint8_t vp8_mbsplit_prob[3] = {
+     110, 111, 150
+ };
  
 +static const uint8_t vp7_submv_prob[3] = { 180, 162, 25 };
 +
  static const uint8_t vp8_submv_prob[5][3] = {
      { 147, 136,  18 },
      { 106, 145,   1 },
   * VP8 compatible video decoder
   */
  
- #include "mathops.h"
- #include "vp8dsp.h"
  #include "libavutil/common.h"
 +#include "libavutil/intreadwrite.h"
  
-     name ## _idct_dc_add_c(dst+stride*0+0, block[0], stride);\
-     name ## _idct_dc_add_c(dst+stride*0+4, block[1], stride);\
-     name ## _idct_dc_add_c(dst+stride*4+0, block[2], stride);\
-     name ## _idct_dc_add_c(dst+stride*4+4, block[3], stride);\
+ #include "mathops.h"
+ #include "vp8dsp.h"
 +#define MK_IDCT_DC_ADD4_C(name) \
 +static void name ## _idct_dc_add4uv_c(uint8_t *dst, int16_t block[4][16], ptrdiff_t stride)\
 +{\
-     name ## _idct_dc_add_c(dst+ 0, block[0], stride);\
-     name ## _idct_dc_add_c(dst+ 4, block[1], stride);\
-     name ## _idct_dc_add_c(dst+ 8, block[2], stride);\
-     name ## _idct_dc_add_c(dst+12, block[3], stride);\
++    name ## _idct_dc_add_c(dst + stride * 0 + 0, block[0], stride);\
++    name ## _idct_dc_add_c(dst + stride * 0 + 4, block[1], stride);\
++    name ## _idct_dc_add_c(dst + stride * 4 + 0, block[2], stride);\
++    name ## _idct_dc_add_c(dst + stride * 4 + 4, block[3], stride);\
 +}\
 +\
 +static void name ## _idct_dc_add4y_c(uint8_t *dst, int16_t block[4][16], ptrdiff_t stride)\
 +{\
-         a1 = (dc[i*4+0] + dc[i*4+2]) * 23170;
-         b1 = (dc[i*4+0] - dc[i*4+2]) * 23170;
-         c1 = dc[i*4+1] * 12540 - dc[i*4+3] * 30274;
-         d1 = dc[i*4+1] * 30274 + dc[i*4+3] * 12540;
-         tmp[i*4+0] = (a1 + d1) >> 14;
-         tmp[i*4+3] = (a1 - d1) >> 14;
-         tmp[i*4+1] = (b1 + c1) >> 14;
-         tmp[i*4+2] = (b1 - c1) >> 14;
++    name ## _idct_dc_add_c(dst + 0, block[0], stride);\
++    name ## _idct_dc_add_c(dst + 4, block[1], stride);\
++    name ## _idct_dc_add_c(dst + 8, block[2], stride);\
++    name ## _idct_dc_add_c(dst + 12, block[3], stride);\
 +}
 +
 +#if CONFIG_VP7_DECODER
 +static void vp7_luma_dc_wht_c(int16_t block[4][4][16], int16_t dc[16])
 +{
 +    int i, a1, b1, c1, d1;
 +    int16_t tmp[16];
 +
 +    for (i = 0; i < 4; i++) {
-         AV_ZERO64(dc + i*4);
++        a1 = (dc[i * 4 + 0] + dc[i * 4 + 2]) * 23170;
++        b1 = (dc[i * 4 + 0] - dc[i * 4 + 2]) * 23170;
++        c1 = dc[i * 4 + 1] * 12540 - dc[i * 4 + 3] * 30274;
++        d1 = dc[i * 4 + 1] * 30274 + dc[i * 4 + 3] * 12540;
++        tmp[i * 4 + 0] = (a1 + d1) >> 14;
++        tmp[i * 4 + 3] = (a1 - d1) >> 14;
++        tmp[i * 4 + 1] = (b1 + c1) >> 14;
++        tmp[i * 4 + 2] = (b1 - c1) >> 14;
 +    }
 +
 +    for (i = 0; i < 4; i++) {
 +        a1 = (tmp[i + 0] + tmp[i + 8]) * 23170;
 +        b1 = (tmp[i + 0] - tmp[i + 8]) * 23170;
 +        c1 = tmp[i + 4] * 12540 - tmp[i + 12] * 30274;
 +        d1 = tmp[i + 4] * 30274 + tmp[i + 12] * 12540;
-         a1 = (block[i*4+0] + block[i*4+2]) * 23170;
-         b1 = (block[i*4+0] - block[i*4+2]) * 23170;
-         c1 = block[i*4+1] * 12540 - block[i*4+3] * 30274;
-         d1 = block[i*4+1] * 30274 + block[i*4+3] * 12540;
-         AV_ZERO64(block + i*4);
-         tmp[i*4+0] = (a1 + d1) >> 14;
-         tmp[i*4+3] = (a1 - d1) >> 14;
-         tmp[i*4+1] = (b1 + c1) >> 14;
-         tmp[i*4+2] = (b1 - c1) >> 14;
++        AV_ZERO64(dc + i * 4);
 +        block[0][i][0] = (a1 + d1 + 0x20000) >> 18;
 +        block[3][i][0] = (a1 - d1 + 0x20000) >> 18;
 +        block[1][i][0] = (b1 + c1 + 0x20000) >> 18;
 +        block[2][i][0] = (b1 - c1 + 0x20000) >> 18;
 +    }
 +}
 +
 +static void vp7_luma_dc_wht_dc_c(int16_t block[4][4][16], int16_t dc[16])
 +{
 +    int i, val = (23170 * (23170 * dc[0] >> 14) + 0x20000) >> 18;
 +    dc[0] = 0;
 +
 +    for (i = 0; i < 4; i++) {
 +        block[i][0][0] = val;
 +        block[i][1][0] = val;
 +        block[i][2][0] = val;
 +        block[i][3][0] = val;
 +    }
 +}
 +
 +static void vp7_idct_add_c(uint8_t *dst, int16_t block[16], ptrdiff_t stride)
 +{
 +    int i, a1, b1, c1, d1;
 +    int16_t tmp[16];
 +
 +    for (i = 0; i < 4; i++) {
-         dst[0*stride+i] = av_clip_uint8(dst[0*stride+i] + ((a1 + d1 + 0x20000) >> 18));
-         dst[3*stride+i] = av_clip_uint8(dst[3*stride+i] + ((a1 - d1 + 0x20000) >> 18));
-         dst[1*stride+i] = av_clip_uint8(dst[1*stride+i] + ((b1 + c1 + 0x20000) >> 18));
-         dst[2*stride+i] = av_clip_uint8(dst[2*stride+i] + ((b1 - c1 + 0x20000) >> 18));
++        a1 = (block[i * 4 + 0] + block[i * 4 + 2]) * 23170;
++        b1 = (block[i * 4 + 0] - block[i * 4 + 2]) * 23170;
++        c1 = block[i * 4 + 1] * 12540 - block[i * 4 + 3] * 30274;
++        d1 = block[i * 4 + 1] * 30274 + block[i * 4 + 3] * 12540;
++        AV_ZERO64(block + i * 4);
++        tmp[i * 4 + 0] = (a1 + d1) >> 14;
++        tmp[i * 4 + 3] = (a1 - d1) >> 14;
++        tmp[i * 4 + 1] = (b1 + c1) >> 14;
++        tmp[i * 4 + 2] = (b1 - c1) >> 14;
 +    }
 +
 +    for (i = 0; i < 4; i++) {
 +        a1 = (tmp[i + 0] + tmp[i + 8]) * 23170;
 +        b1 = (tmp[i + 0] - tmp[i + 8]) * 23170;
 +        c1 = tmp[i + 4] * 12540 - tmp[i + 12] * 30274;
 +        d1 = tmp[i + 4] * 30274 + tmp[i + 12] * 12540;
++        dst[0 * stride + i] = av_clip_uint8(dst[0 * stride + i] + ((a1 + d1 + 0x20000) >> 18));
++        dst[3 * stride + i] = av_clip_uint8(dst[3 * stride + i] + ((a1 - d1 + 0x20000) >> 18));
++        dst[1 * stride + i] = av_clip_uint8(dst[1 * stride + i] + ((b1 + c1 + 0x20000) >> 18));
++        dst[2 * stride + i] = av_clip_uint8(dst[2 * stride + i] + ((b1 - c1 + 0x20000) >> 18));
 +    }
 +}
 +
 +static void vp7_idct_dc_add_c(uint8_t *dst, int16_t block[16], ptrdiff_t stride)
 +{
 +    int i, dc = (23170 * (23170 * block[0] >> 14) + 0x20000) >> 18;
 +    block[0] = 0;
 +
 +    for (i = 0; i < 4; i++) {
 +        dst[0] = av_clip_uint8(dst[0] + dc);
 +        dst[1] = av_clip_uint8(dst[1] + dc);
 +        dst[2] = av_clip_uint8(dst[2] + dc);
 +        dst[3] = av_clip_uint8(dst[3] + dc);
 +        dst += stride;
 +    }
 +}
 +
 +MK_IDCT_DC_ADD4_C(vp7)
 +#endif
 +
  // TODO: Maybe add dequant
 +#if CONFIG_VP8_DECODER
  static void vp8_luma_dc_wht_c(int16_t block[4][4][16], int16_t dc[16])
  {
      int i, t0, t1, t2, t3;
      }
  
      for (i = 0; i < 4; i++) {
-         t0 = dc[i*4+0] + dc[i*4+3] + 3; // rounding
-         t1 = dc[i*4+1] + dc[i*4+2];
-         t2 = dc[i*4+1] - dc[i*4+2];
-         t3 = dc[i*4+0] - dc[i*4+3] + 3; // rounding
-         AV_ZERO64(dc + i*4);
+         t0 = dc[i * 4 + 0] + dc[i * 4 + 3] + 3; // rounding
+         t1 = dc[i * 4 + 1] + dc[i * 4 + 2];
+         t2 = dc[i * 4 + 1] - dc[i * 4 + 2];
+         t3 = dc[i * 4 + 0] - dc[i * 4 + 3] + 3; // rounding
 -        dc[i * 4 + 0] = 0;
 -        dc[i * 4 + 1] = 0;
 -        dc[i * 4 + 2] = 0;
 -        dc[i * 4 + 3] = 0;
++        AV_ZERO64(dc + i * 4);
  
          block[i][0][0] = (t0 + t1) >> 3;
          block[i][1][0] = (t3 + t2) >> 3;
@@@ -233,23 -128,39 +234,24 @@@ static void vp8_idct_dc_add_c(uint8_t *
      }
  }
  
 -static void vp8_idct_dc_add4uv_c(uint8_t *dst, int16_t block[4][16],
 -                                 ptrdiff_t stride)
 -{
 -    vp8_idct_dc_add_c(dst + stride * 0 + 0, block[0], stride);
 -    vp8_idct_dc_add_c(dst + stride * 0 + 4, block[1], stride);
 -    vp8_idct_dc_add_c(dst + stride * 4 + 0, block[2], stride);
 -    vp8_idct_dc_add_c(dst + stride * 4 + 4, block[3], stride);
 -}
 -
 -static void vp8_idct_dc_add4y_c(uint8_t *dst, int16_t block[4][16],
 -                                ptrdiff_t stride)
 -{
 -    vp8_idct_dc_add_c(dst +  0, block[0], stride);
 -    vp8_idct_dc_add_c(dst +  4, block[1], stride);
 -    vp8_idct_dc_add_c(dst +  8, block[2], stride);
 -    vp8_idct_dc_add_c(dst + 12, block[3], stride);
 -}
 +MK_IDCT_DC_ADD4_C(vp8)
 +#endif
  
  // because I like only having two parameters to pass functions...
- #define LOAD_PIXELS\
-     int av_unused p3 = p[-4*stride];\
-     int av_unused p2 = p[-3*stride];\
-     int av_unused p1 = p[-2*stride];\
-     int av_unused p0 = p[-1*stride];\
-     int av_unused q0 = p[ 0*stride];\
-     int av_unused q1 = p[ 1*stride];\
-     int av_unused q2 = p[ 2*stride];\
-     int av_unused q3 = p[ 3*stride];
- #define clip_int8(n) (cm[n+0x80]-0x80)
- static av_always_inline void filter_common(uint8_t *p, ptrdiff_t stride, int is4tap, int vpn)
+ #define LOAD_PIXELS                                                           \
+     int av_unused p3 = p[-4 * stride];                                        \
+     int av_unused p2 = p[-3 * stride];                                        \
+     int av_unused p1 = p[-2 * stride];                                        \
+     int av_unused p0 = p[-1 * stride];                                        \
+     int av_unused q0 = p[ 0 * stride];                                        \
+     int av_unused q1 = p[ 1 * stride];                                        \
+     int av_unused q2 = p[ 2 * stride];                                        \
+     int av_unused q3 = p[ 3 * stride];
+ #define clip_int8(n) (cm[n + 0x80] - 0x80)
+ static av_always_inline void filter_common(uint8_t *p, ptrdiff_t stride,
 -                                           int is4tap)
++                                           int is4tap, int vpn)
  {
      LOAD_PIXELS
      int a, f1, f2;
  
      // We deviate from the spec here with c(a+3) >> 3
      // since that's what libvpx does.
-     f1 = FFMIN(a+4, 127) >> 3;
+     f1 = FFMIN(a + 4, 127) >> 3;
 -    f2 = FFMIN(a + 3, 127) >> 3;
 +
 +    if (vpn == 7)
 +        f2 = f1 - ((a & 7) == 4);
 +    else
-         f2 = FFMIN(a+3, 127) >> 3;
++        f2 = FFMIN(a + 3, 127) >> 3;
  
      // Despite what the spec says, we do need to clamp here to
      // be bitexact with libvpx.
      }
  }
  
 -static av_always_inline int simple_limit(uint8_t *p, ptrdiff_t stride, int flim)
 +static av_always_inline int vp7_simple_limit(uint8_t *p, ptrdiff_t stride, int flim)
 +{
 +    LOAD_PIXELS
 +    return FFABS(p0-q0) <= flim;
 +}
 +
 +static av_always_inline int vp8_simple_limit(uint8_t *p, ptrdiff_t stride, int flim)
  {
      LOAD_PIXELS
-     return 2*FFABS(p0-q0) + (FFABS(p1-q1) >> 1) <= flim;
+     return 2 * FFABS(p0 - q0) + (FFABS(p1 - q1) >> 1) <= flim;
  }
  
  /**
   * E - limit at the macroblock edge
   * I - limit for interior difference
   */
 -static av_always_inline int normal_limit(uint8_t *p, ptrdiff_t stride,
 -                                         int E, int I)
 -{
 -    LOAD_PIXELS
 -    return simple_limit(p, stride, E) &&
 -           FFABS(p3 - p2) <= I &&
 -           FFABS(p2 - p1) <= I &&
 -           FFABS(p1 - p0) <= I &&
 -           FFABS(q3 - q2) <= I &&
 -           FFABS(q2 - q1) <= I &&
 -           FFABS(q1 - q0) <= I;
 +#define NORMAL_LIMIT(vpn) \
- static av_always_inline int vp ## vpn ## _normal_limit(uint8_t *p, ptrdiff_t stride, int E, int I)\
- {\
-     LOAD_PIXELS\
-     return vp ## vpn ## _simple_limit(p, stride, E)\
-         && FFABS(p3-p2) <= I && FFABS(p2-p1) <= I && FFABS(p1-p0) <= I\
-         && FFABS(q3-q2) <= I && FFABS(q2-q1) <= I && FFABS(q1-q0) <= I;\
++static av_always_inline int vp ## vpn ## _normal_limit(uint8_t *p, ptrdiff_t stride, \
++                                                       int E, int I)\
++{                                                      \
++    LOAD_PIXELS                                        \
++    return vp ## vpn ## _simple_limit(p, stride, E) && \
++           FFABS(p3 - p2) <= I &&                      \
++           FFABS(p2 - p1) <= I &&                      \
++           FFABS(p1 - p0) <= I &&                      \
++           FFABS(q3 - q2) <= I &&                      \
++           FFABS(q2 - q1) <= I &&                      \
++           FFABS(q1 - q0) <= I;                        \
  }
  
 +NORMAL_LIMIT(7)
 +NORMAL_LIMIT(8)
 +
  // high edge variance
  static av_always_inline int hev(uint8_t *p, ptrdiff_t stride, int thresh)
  {
@@@ -326,117 -228,116 +333,126 @@@ static av_always_inline void filter_mbe
  
      LOAD_PIXELS
  
-     w = clip_int8(p1-q1);
-     w = clip_int8(w + 3*(q0-p0));
+     w = clip_int8(p1 - q1);
+     w = clip_int8(w + 3 * (q0 - p0));
  
-     a0 = (27*w + 63) >> 7;
-     a1 = (18*w + 63) >> 7;
-     a2 = ( 9*w + 63) >> 7;
+     a0 = (27 * w + 63) >> 7;
+     a1 = (18 * w + 63) >> 7;
+     a2 =  (9 * w + 63) >> 7;
  
-     p[-3*stride] = cm[p2 + a2];
-     p[-2*stride] = cm[p1 + a1];
-     p[-1*stride] = cm[p0 + a0];
-     p[ 0*stride] = cm[q0 - a0];
-     p[ 1*stride] = cm[q1 - a1];
-     p[ 2*stride] = cm[q2 - a2];
+     p[-3 * stride] = cm[p2 + a2];
+     p[-2 * stride] = cm[p1 + a1];
+     p[-1 * stride] = cm[p0 + a0];
+     p[ 0 * stride] = cm[q0 - a0];
+     p[ 1 * stride] = cm[q1 - a1];
+     p[ 2 * stride] = cm[q2 - a2];
  }
  
- #define LOOP_FILTER(vpn, dir, size, stridea, strideb, maybe_inline) \
- static maybe_inline void vp ## vpn ## _ ## dir ## _loop_filter ## size ## _c(uint8_t *dst, ptrdiff_t stride,\
-                                      int flim_E, int flim_I, int hev_thresh)\
- {\
-     int i;\
- \
-     for (i = 0; i < size; i++)\
-         if (vp ## vpn ## _normal_limit(dst+i*stridea, strideb, flim_E, flim_I)) {\
-             if (hev(dst+i*stridea, strideb, hev_thresh))\
-                 filter_common(dst+i*stridea, strideb, 1, vpn);\
-             else\
-                 filter_mbedge(dst+i*stridea, strideb);\
-         }\
- }\
- \
- static maybe_inline void vp ## vpn ## _ ## dir ## _loop_filter ## size ## _inner_c(uint8_t *dst, ptrdiff_t stride,\
-                                       int flim_E, int flim_I, int hev_thresh)\
- {\
-     int i;\
- \
-     for (i = 0; i < size; i++)\
-         if (vp ## vpn ## _normal_limit(dst+i*stridea, strideb, flim_E, flim_I)) {\
-             int hv = hev(dst+i*stridea, strideb, hev_thresh);\
-             if (hv) \
-                 filter_common(dst+i*stridea, strideb, 1, vpn);\
-             else \
-                 filter_common(dst+i*stridea, strideb, 0, vpn);\
-         }\
 -#define LOOP_FILTER(dir, size, stridea, strideb, maybe_inline)                \
++#define LOOP_FILTER(vpn, dir, size, stridea, strideb, maybe_inline)           \
+ static maybe_inline                                                           \
 -void vp8_ ## dir ## _loop_filter ## size ## _c(uint8_t *dst,                  \
++void vp ## vpn ## _ ## dir ## _loop_filter ## size ## _c(uint8_t *dst,        \
+                                                ptrdiff_t stride,              \
+                                                int flim_E, int flim_I,        \
+                                                int hev_thresh)                \
+ {                                                                             \
+     int i;                                                                    \
+     for (i = 0; i < size; i++)                                                \
 -        if (normal_limit(dst + i * stridea, strideb, flim_E, flim_I)) {       \
++        if (vp ## vpn ## _normal_limit(dst + i * stridea, strideb, flim_E, flim_I)) {       \
+             if (hev(dst + i * stridea, strideb, hev_thresh))                  \
 -                filter_common(dst + i * stridea, strideb, 1);                 \
++                filter_common(dst + i * stridea, strideb, 1, vpn);            \
+             else                                                              \
+                 filter_mbedge(dst + i * stridea, strideb);                    \
+         }                                                                     \
+ }                                                                             \
+                                                                               \
+ static maybe_inline                                                           \
 -void vp8_ ## dir ## _loop_filter ## size ## _inner_c(uint8_t *dst,            \
++void vp ## vpn ## _ ## dir ## _loop_filter ## size ## _inner_c(uint8_t *dst,  \
+                                                      ptrdiff_t stride,        \
+                                                      int flim_E, int flim_I,  \
+                                                      int hev_thresh)          \
+ {                                                                             \
+     int i;                                                                    \
+     for (i = 0; i < size; i++)                                                \
 -        if (normal_limit(dst + i * stridea, strideb, flim_E, flim_I)) {       \
++        if (vp ## vpn ## _normal_limit(dst + i * stridea, strideb, flim_E, flim_I)) {       \
+             int hv = hev(dst + i * stridea, strideb, hev_thresh);             \
+             if (hv)                                                           \
 -                filter_common(dst + i * stridea, strideb, 1);                 \
++                filter_common(dst + i * stridea, strideb, 1, vpn);            \
+             else                                                              \
 -                filter_common(dst + i * stridea, strideb, 0);                 \
++                filter_common(dst + i * stridea, strideb, 0, vpn);            \
+         }                                                                     \
  }
  
 -LOOP_FILTER(v, 16, 1, stride, )
 -LOOP_FILTER(h, 16, stride, 1, )
 -
 -#define UV_LOOP_FILTER(dir, stridea, strideb)                                 \
 -LOOP_FILTER(dir, 8, stridea, strideb, av_always_inline)                       \
 -static void vp8_ ## dir ## _loop_filter8uv_c(uint8_t *dstU, uint8_t *dstV,    \
 -                                             ptrdiff_t stride, int fE,        \
 -                                             int fI, int hev_thresh)          \
 -{                                                                             \
 -    vp8_ ## dir ## _loop_filter8_c(dstU, stride, fE, fI, hev_thresh);         \
 -    vp8_ ## dir ## _loop_filter8_c(dstV, stride, fE, fI, hev_thresh);         \
 -}                                                                             \
 -                                                                              \
 -static void vp8_ ## dir ## _loop_filter8uv_inner_c(uint8_t *dstU,             \
 -                                                   uint8_t *dstV,             \
 -                                                   ptrdiff_t stride, int fE,  \
 -                                                   int fI, int hev_thresh)    \
 -{                                                                             \
 -    vp8_ ## dir ## _loop_filter8_inner_c(dstU, stride, fE, fI, hev_thresh);   \
 -    vp8_ ## dir ## _loop_filter8_inner_c(dstV, stride, fE, fI, hev_thresh);   \
 +#define UV_LOOP_FILTER(vpn, dir, stridea, strideb) \
 +LOOP_FILTER(vpn, dir, 8, stridea, strideb, av_always_inline) \
- static void vp ## vpn ## _ ## dir ## _loop_filter8uv_c(uint8_t *dstU, uint8_t *dstV, ptrdiff_t stride,\
-                                       int fE, int fI, int hev_thresh)\
++static void vp ## vpn ## _ ## dir ## _loop_filter8uv_c(uint8_t *dstU, uint8_t *dstV, \
++                                                       ptrdiff_t stride, int fE, \
++                                                       int fI, int hev_thresh)\
 +{\
 +  vp ## vpn ## _ ## dir ## _loop_filter8_c(dstU, stride, fE, fI, hev_thresh);\
 +  vp ## vpn ## _ ## dir ## _loop_filter8_c(dstV, stride, fE, fI, hev_thresh);\
 +}\
- static void vp ## vpn ## _ ## dir ## _loop_filter8uv_inner_c(uint8_t *dstU, uint8_t *dstV, ptrdiff_t stride,\
-                                       int fE, int fI, int hev_thresh)\
++static void vp ## vpn ## _ ## dir ## _loop_filter8uv_inner_c(uint8_t *dstU, \
++                                                             uint8_t *dstV, \
++                                                             ptrdiff_t stride, int fE, \
++                                                             int fI, int hev_thresh) \
 +{\
 +  vp ## vpn ## _ ## dir ## _loop_filter8_inner_c(dstU, stride, fE, fI, hev_thresh);\
 +  vp ## vpn ## _ ## dir ## _loop_filter8_inner_c(dstV, stride, fE, fI, hev_thresh);\
  }
  
 -UV_LOOP_FILTER(v, 1, stride)
 -UV_LOOP_FILTER(h, stride, 1)
 -
 -static void vp8_v_loop_filter_simple_c(uint8_t *dst, ptrdiff_t stride, int flim)
 -{
 -    int i;
 -
 -    for (i = 0; i < 16; i++)
 -        if (simple_limit(dst + i, stride, flim))
 -            filter_common(dst + i, stride, 1);
 +#define LOOP_FILTER_SIMPLE(vpn) \
 +static void vp ## vpn ## _v_loop_filter_simple_c(uint8_t *dst, ptrdiff_t stride, int flim)\
 +{\
 +    int i;\
 +\
 +    for (i = 0; i < 16; i++)\
-         if (vp ## vpn ## _simple_limit(dst+i, stride, flim))\
-             filter_common(dst+i, stride, 1, vpn);\
++        if (vp ## vpn ## _simple_limit(dst + i, stride, flim))\
++            filter_common(dst + i, stride, 1, vpn);\
 +}\
 +\
 +static void vp ## vpn ## _h_loop_filter_simple_c(uint8_t *dst, ptrdiff_t stride, int flim)\
 +{\
 +    int i;\
 +\
 +    for (i = 0; i < 16; i++)\
-         if (vp ## vpn ## _simple_limit(dst+i*stride, 1, flim))\
-             filter_common(dst+i*stride, 1, 1, vpn);\
++        if (vp ## vpn ## _simple_limit(dst + i * stride, 1, flim))\
++            filter_common(dst + i * stride, 1, 1, vpn);\
  }
  
 -static void vp8_h_loop_filter_simple_c(uint8_t *dst, ptrdiff_t stride, int flim)
 -{
 -    int i;
 -
 -    for (i = 0; i < 16; i++)
 -        if (simple_limit(dst + i * stride, 1, flim))
 -            filter_common(dst + i * stride, 1, 1);
 -}
 +#if CONFIG_VP7_DECODER
 +LOOP_FILTER(7, v, 16, 1, stride,)
 +LOOP_FILTER(7, h, 16, stride, 1,)
 +UV_LOOP_FILTER(7, v, 1, stride)
 +UV_LOOP_FILTER(7, h, stride, 1)
 +LOOP_FILTER_SIMPLE(7)
 +#endif
 +
 +#if CONFIG_VP8_DECODER
 +LOOP_FILTER(8, v, 16, 1, stride,)
 +LOOP_FILTER(8, h, 16, stride, 1,)
 +UV_LOOP_FILTER(8, v, 1, stride)
 +UV_LOOP_FILTER(8, h, stride, 1)
 +LOOP_FILTER_SIMPLE(8)
 +#endif
  
  static const uint8_t subpel_filters[7][6] = {
-     { 0,   6, 123,  12,   1,   0 },
-     { 2,  11, 108,  36,   8,   1 },
-     { 0,   9,  93,  50,   6,   0 },
-     { 3,  16,  77,  77,  16,   3 },
-     { 0,   6,  50,  93,   9,   0 },
-     { 1,   8,  36, 108,  11,   2 },
-     { 0,   1,  12, 123,   6,   0 },
+     { 0,  6, 123,  12,  1, 0 },
+     { 2, 11, 108,  36,  8, 1 },
+     { 0,  9,  93,  50,  6, 0 },
+     { 3, 16,  77,  77, 16, 3 },
+     { 0,  6,  50,  93,  9, 0 },
+     { 1,  8,  36, 108, 11, 2 },
+     { 0,  1,  12, 123,  6, 0 },
  };
  
- #define PUT_PIXELS(WIDTH) \
- static void put_vp8_pixels ## WIDTH ##_c(uint8_t *dst, ptrdiff_t dststride, uint8_t *src, ptrdiff_t srcstride, int h, int x, int y) { \
-     int i; \
-     for (i = 0; i < h; i++, dst+= dststride, src+= srcstride) { \
-         memcpy(dst, src, WIDTH); \
-     } \
+ #define PUT_PIXELS(WIDTH)                                                     \
+ static void put_vp8_pixels ## WIDTH ## _c(uint8_t *dst, ptrdiff_t dststride,  \
+                                           uint8_t *src, ptrdiff_t srcstride,  \
+                                           int h, int x, int y)                \
+ {                                                                             \
+     int i;                                                                    \
+     for (i = 0; i < h; i++, dst += dststride, src += srcstride)               \
+         memcpy(dst, src, WIDTH);                                              \
  }
  
  PUT_PIXELS(16)
Simple merge