libvpx: Add VP9 decoder.

source/libvpx/vp8/encoder/rdopt.c

 /*
  *  Copyright (c) 2010 The WebM project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 
 #include <stdio.h>
 #include <math.h>
 #include <limits.h>
 #include <assert.h>
 #include "vpx_config.h"
-#include "vpx_rtcd.h"
+#include "vp8_rtcd.h"
 #include "vp8/common/pragmas.h"
 #include "tokenize.h"
 #include "treewriter.h"
 #include "onyx_int.h"
 #include "modecosts.h"
 #include "encodeintra.h"
 #include "pickinter.h"
 #include "vp8/common/entropymode.h"
 #include "vp8/common/reconinter.h"
 #include "vp8/common/reconintra4x4.h"
@@ skipping 590 matching lines @@
 static void copy_predictor(unsigned char *dst, const unsigned char *predictor)
 {
     const unsigned int *p = (const unsigned int *)predictor;
     unsigned int *d = (unsigned int *)dst;
     d[0] = p[0];
     d[4] = p[4];
     d[8] = p[8];
     d[12] = p[12];
 }
 static int rd_pick_intra4x4block(
+    VP8_COMP *cpi,
     MACROBLOCK *x,
     BLOCK *be,
     BLOCKD *b,
     B_PREDICTION_MODE *best_mode,
     const int *bmode_costs,
     ENTROPY_CONTEXT *a,
     ENTROPY_CONTEXT *l,
 
     int *bestrate,
     int *bestratey,
@@ skipping 55 matching lines @@
             vpx_memcpy(best_dqcoeff, b->dqcoeff, 32);
         }
     }
     b->bmi.as_mode = *best_mode;
 
     vp8_short_idct4x4llm(best_dqcoeff, best_predictor, 16, dst, dst_stride);
 
     return best_rd;
 }
 
-static int rd_pick_intra4x4mby_modes(MACROBLOCK *mb, int *Rate,
+static int rd_pick_intra4x4mby_modes(VP8_COMP *cpi, MACROBLOCK *mb, int *Rate,
                                      int *rate_y, int *Distortion, int best_rd)
 {
     MACROBLOCKD *const xd = &mb->e_mbd;
     int i;
     int cost = mb->mbmode_cost [xd->frame_type] [B_PRED];
     int distortion = 0;
     int tot_rate_y = 0;
     int64_t total_rd = 0;
     ENTROPY_CONTEXT_PLANES t_above, t_left;
     ENTROPY_CONTEXT *ta;
@@ skipping 19 matching lines @@
 
         if (mb->e_mbd.frame_type == KEY_FRAME)
         {
             const B_PREDICTION_MODE A = above_block_mode(mic, i, mis);
             const B_PREDICTION_MODE L = left_block_mode(mic, i);
 
             bmode_costs  = mb->bmode_costs[A][L];
         }
 
         total_rd += rd_pick_intra4x4block(
-            mb, mb->block + i, xd->block + i, &best_mode, bmode_costs,
+            cpi, mb, mb->block + i, xd->block + i, &best_mode, bmode_costs,
             ta + vp8_block2above[i],
             tl + vp8_block2left[i], &r, &ry, &d);
 
         cost += r;
         distortion += d;
         tot_rate_y += ry;
 
         mic->bmi[i].as_mode = best_mode;
 
         if(total_rd >= (int64_t)best_rd)
             break;
     }
 
     if(total_rd >= (int64_t)best_rd)
         return INT_MAX;
 
     *Rate = cost;
     *rate_y = tot_rate_y;
     *Distortion = distortion;
 
     return RDCOST(mb->rdmult, mb->rddiv, cost, distortion);
 }
 
 
-static int rd_pick_intra16x16mby_mode(MACROBLOCK *x,
+static int rd_pick_intra16x16mby_mode(VP8_COMP *cpi,
+                                      MACROBLOCK *x,
                                       int *Rate,
                                       int *rate_y,
                                       int *Distortion)
 {
     MB_PREDICTION_MODE mode;
     MB_PREDICTION_MODE UNINITIALIZED_IS_SAFE(mode_selected);
     int rate, ratey;
     int distortion;
     int best_rd = INT_MAX;
     int this_rd;
@@ skipping 81 matching lines @@
 
     vp8_transform_mbuv(x);
     vp8_quantize_mbuv(x);
 
     *rate       = rd_cost_mbuv(x);
     *distortion = vp8_mbuverror(x) / 4;
 
     return RDCOST(x->rdmult, x->rddiv, *rate, *distortion);
 }
 
-static void rd_pick_intra_mbuv_mode(MACROBLOCK *x, int *rate,
-                                    int *rate_tokenonly, int *distortion)
+static void rd_pick_intra_mbuv_mode(VP8_COMP *cpi, MACROBLOCK *x, int *rate, int *rate_tokenonly, int *distortion)
 {
     MB_PREDICTION_MODE mode;
     MB_PREDICTION_MODE UNINITIALIZED_IS_SAFE(mode_selected);
     int best_rd = INT_MAX;
     int UNINITIALIZED_IS_SAFE(d), UNINITIALIZED_IS_SAFE(r);
     int rate_to;
     MACROBLOCKD *xd = &x->e_mbd;
 
     for (mode = DC_PRED; mode <= TM_PRED; mode++)
     {
@@ skipping 849 matching lines @@
 static void rd_update_mvcount(VP8_COMP *cpi, MACROBLOCK *x, int_mv *best_ref_mv)
 {
     if (x->e_mbd.mode_info_context->mbmi.mode == SPLITMV)
     {
         int i;
 
         for (i = 0; i < x->partition_info->count; i++)
         {
             if (x->partition_info->bmi[i].mode == NEW4X4)
             {
-                x->MVcount[0][mv_max+((x->partition_info->bmi[i].mv.as_mv.row
+                cpi->MVcount[0][mv_max+((x->partition_info->bmi[i].mv.as_mv.row
                                           - best_ref_mv->as_mv.row) >> 1)]++;
-                x->MVcount[1][mv_max+((x->partition_info->bmi[i].mv.as_mv.col
+                cpi->MVcount[1][mv_max+((x->partition_info->bmi[i].mv.as_mv.col
                                           - best_ref_mv->as_mv.col) >> 1)]++;
             }
         }
     }
     else if (x->e_mbd.mode_info_context->mbmi.mode == NEWMV)
     {
-        x->MVcount[0][mv_max+((x->e_mbd.mode_info_context->mbmi.mv.as_mv.row
+        cpi->MVcount[0][mv_max+((x->e_mbd.mode_info_context->mbmi.mv.as_mv.row
                                           - best_ref_mv->as_mv.row) >> 1)]++;
-        x->MVcount[1][mv_max+((x->e_mbd.mode_info_context->mbmi.mv.as_mv.col
+        cpi->MVcount[1][mv_max+((x->e_mbd.mode_info_context->mbmi.mv.as_mv.col
                                           - best_ref_mv->as_mv.col) >> 1)]++;
     }
 }
 
 static int evaluate_inter_mode_rd(int mdcounts[4],
                                   RATE_DISTORTION* rd,
                                   int* disable_skip,
                                   VP8_COMP *cpi, MACROBLOCK *x)
 {
     MB_PREDICTION_MODE this_mode = x->e_mbd.mode_info_context->mbmi.mode;
@@ skipping 349 matching lines @@
                     cpi->zbin_mode_boost = 0;
                 else
                     cpi->zbin_mode_boost = MV_ZBIN_BOOST;
             }
 
             vp8_update_zbin_extra(cpi, x);
         }
 
         if(!uv_intra_done && this_ref_frame == INTRA_FRAME)
         {
-            rd_pick_intra_mbuv_mode(x, &uv_intra_rate,
+            rd_pick_intra_mbuv_mode(cpi, x, &uv_intra_rate,
                                     &uv_intra_rate_tokenonly,
                                     &uv_intra_distortion);
             uv_intra_mode = x->e_mbd.mode_info_context->mbmi.uv_mode;
 
             /*
              * Total of the eobs is used later to further adjust rate2. Since uv
              * block's intra eobs will be overwritten when we check inter modes,
              * we need to save uv_intra_tteob here.
              */
             for (i = 16; i < 24; i++)
                 uv_intra_tteob += x->e_mbd.eobs[i];
 
             uv_intra_done = 1;
         }
 
         switch (this_mode)
         {
         case B_PRED:
         {
             int tmp_rd;
 
             /* Note the rate value returned here includes the cost of
              * coding the BPRED mode: x->mbmode_cost[x->e_mbd.frame_type][BPRED]
              */
             int distortion;
-            tmp_rd = rd_pick_intra4x4mby_modes(x, &rate, &rd.rate_y, &distortion, best_mode.yrd);
+            tmp_rd = rd_pick_intra4x4mby_modes(cpi, x, &rate, &rd.rate_y, &distortion, best_mode.yrd);
             rd.rate2 += rate;
             rd.distortion2 += distortion;
 
             if(tmp_rd < best_mode.yrd)
             {
                 rd.rate2 += uv_intra_rate;
                 rd.rate_uv = uv_intra_rate_tokenonly;
                 rd.distortion2 += uv_intra_distortion;
                 rd.distortion_uv = uv_intra_distortion;
             }
@@ skipping 428 matching lines @@
                                       x->partition_info->bmi[15].mv.as_int;
     }
 
     if (sign_bias
         != cpi->common.ref_frame_sign_bias[xd->mode_info_context->mbmi.ref_frame])
         best_ref_mv.as_int = best_ref_mv_sb[!sign_bias].as_int;
 
     rd_update_mvcount(cpi, x, &best_ref_mv);
 }
 
-void vp8_rd_pick_intra_mode(MACROBLOCK *x, int *rate_)
+void vp8_rd_pick_intra_mode(VP8_COMP *cpi, MACROBLOCK *x, int *rate_)
 {
     int error4x4, error16x16;
     int rate4x4, rate16x16 = 0, rateuv;
     int dist4x4, dist16x16, distuv;
     int rate;
     int rate4x4_tokenonly = 0;
     int rate16x16_tokenonly = 0;
     int rateuv_tokenonly = 0;
 
     x->e_mbd.mode_info_context->mbmi.ref_frame = INTRA_FRAME;
 
-    rd_pick_intra_mbuv_mode(x, &rateuv, &rateuv_tokenonly, &distuv);
+    rd_pick_intra_mbuv_mode(cpi, x, &rateuv, &rateuv_tokenonly, &distuv);
     rate = rateuv;
 
-    error16x16 = rd_pick_intra16x16mby_mode(x, &rate16x16, &rate16x16_tokenonly,
+    error16x16 = rd_pick_intra16x16mby_mode(cpi, x,
+                                            &rate16x16, &rate16x16_tokenonly,
                                             &dist16x16);
 
-    error4x4 = rd_pick_intra4x4mby_modes(x, &rate4x4, &rate4x4_tokenonly,
+    error4x4 = rd_pick_intra4x4mby_modes(cpi, x,
+                                         &rate4x4, &rate4x4_tokenonly,
                                          &dist4x4, error16x16);
 
     if (error4x4 < error16x16)
     {
         x->e_mbd.mode_info_context->mbmi.mode = B_PRED;
         rate += rate4x4;
     }
     else
     {
         rate += rate16x16;
     }
 
     *rate_ = rate;
 }