libvpx: Add VP9 decoder.

source/libvpx/vp8/encoder/encodeframe.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.
  */
 
@@ skipping 15 matching lines @@
 #include "vp8/common/findnearmv.h"
 #include <stdio.h>
 #include <limits.h>
 #include "vp8/common/invtrans.h"
 #include "vpx_ports/vpx_timer.h"
 #if CONFIG_REALTIME_ONLY & CONFIG_ONTHEFLY_BITPACKING
 #include "bitstream.h"
 #endif
 #include "encodeframe.h"
 
-extern void vp8_stuff_mb(VP8_COMP *cpi, MACROBLOCK *x, TOKENEXTRA **t) ;
+extern void vp8_stuff_mb(VP8_COMP *cpi, MACROBLOCKD *x, TOKENEXTRA **t) ;
 extern void vp8_calc_ref_frame_costs(int *ref_frame_cost,
                                      int prob_intra,
                                      int prob_last,
                                      int prob_garf
                                     );
 extern void vp8_convert_rfct_to_prob(VP8_COMP *const cpi);
 extern void vp8cx_initialize_me_consts(VP8_COMP *cpi, int QIndex);
 extern void vp8_auto_select_speed(VP8_COMP *cpi);
 extern void vp8cx_init_mbrthread_data(VP8_COMP *cpi,
                                       MACROBLOCK *x,
@@ skipping 589 matching lines @@
     vp8_setup_intra_recon(&cm->yv12_fb[cm->new_fb_idx]);
 
     vp8_build_block_offsets(x);
 
     xd->mode_info_context->mbmi.mode = DC_PRED;
     xd->mode_info_context->mbmi.uv_mode = DC_PRED;
 
     xd->left_context = &cm->left_context;
 
     vp8_zero(cpi->count_mb_ref_frame_usage)
+    vp8_zero(cpi->ymode_count)
+    vp8_zero(cpi->uv_mode_count)
 
     x->mvc = cm->fc.mvc;
 
     vpx_memset(cm->above_context, 0,
                sizeof(ENTROPY_CONTEXT_PLANES) * cm->mb_cols);
 
     /* Special case treatment when GF and ARF are not sensible options
      * for reference
      */
     if (cpi->ref_frame_flags == VP8_LAST_FRAME)
         vp8_calc_ref_frame_costs(x->ref_frame_cost,
                                  cpi->prob_intra_coded,255,128);
     else if ((cpi->oxcf.number_of_layers > 1) &&
                (cpi->ref_frame_flags == VP8_GOLD_FRAME))
         vp8_calc_ref_frame_costs(x->ref_frame_cost,
                                  cpi->prob_intra_coded,1,255);
     else if ((cpi->oxcf.number_of_layers > 1) &&
                 (cpi->ref_frame_flags == VP8_ALTR_FRAME))
         vp8_calc_ref_frame_costs(x->ref_frame_cost,
                                  cpi->prob_intra_coded,1,1);
     else
         vp8_calc_ref_frame_costs(x->ref_frame_cost,
                                  cpi->prob_intra_coded,
                                  cpi->prob_last_coded,
                                  cpi->prob_gf_coded);
 
     xd->fullpixel_mask = 0xffffffff;
     if(cm->full_pixel)
         xd->fullpixel_mask = 0xfffffff8;
-
-    vp8_zero(x->coef_counts);
-    vp8_zero(x->ymode_count);
-    vp8_zero(x->uv_mode_count)
-    x->prediction_error = 0;
-    x->intra_error = 0;
-}
-
-static void sum_coef_counts(MACROBLOCK *x, MACROBLOCK *x_thread)
-{
-    int i = 0;
-    do
-    {
-        int j = 0;
-        do
-        {
-            int k = 0;
-            do
-            {
-                /* at every context */
-
-                /* calc probs and branch cts for this frame only */
-                int t = 0;      /* token/prob index */
-
-                do
-                {
-                    x->coef_counts [i][j][k][t] +=
-                        x_thread->coef_counts [i][j][k][t];
-                }
-                while (++t < ENTROPY_NODES);
-            }
-            while (++k < PREV_COEF_CONTEXTS);
-        }
-        while (++j < COEF_BANDS);
-    }
-    while (++i < BLOCK_TYPES);
 }
 
 void vp8_encode_frame(VP8_COMP *cpi)
 {
     int mb_row;
     MACROBLOCK *const x = & cpi->mb;
     VP8_COMMON *const cm = & cpi->common;
     MACROBLOCKD *const xd = & x->e_mbd;
     TOKENEXTRA *tp = cpi->tok;
     int segment_counts[MAX_MB_SEGMENTS];
@@ skipping 23 matching lines @@
         xd->subpixel_predict16x16   = vp8_sixtap_predict16x16;
     }
     else
     {
         xd->subpixel_predict        = vp8_bilinear_predict4x4;
         xd->subpixel_predict8x4     = vp8_bilinear_predict8x4;
         xd->subpixel_predict8x8     = vp8_bilinear_predict8x8;
         xd->subpixel_predict16x16   = vp8_bilinear_predict16x16;
     }
 
-    cpi->mb.skip_true_count = 0;
+    cpi->prediction_error = 0;
+    cpi->intra_error = 0;
+    cpi->skip_true_count = 0;
     cpi->tok_count = 0;
 
 #if 0
     /* Experimental code */
     cpi->frame_distortion = 0;
     cpi->last_mb_distortion = 0;
 #endif
 
     xd->mode_info_context = cm->mi;
 
-    vp8_zero(cpi->mb.MVcount);
+    vp8_zero(cpi->MVcount);
+
+    vp8_zero(cpi->coef_counts);
 
     vp8cx_frame_init_quantizer(cpi);
 
     vp8_initialize_rd_consts(cpi,
                              vp8_dc_quant(cm->base_qindex, cm->y1dc_delta_q));
 
     vp8cx_initialize_me_consts(cpi, cm->base_qindex);
 
     if(cpi->oxcf.tuning == VP8_TUNE_SSIM)
     {
@@ skipping 84 matching lines @@
                     for (i = 0; i < cpi->encoding_thread_count; i++)
                     {
                         for (j = 0; j < 4; j++)
                             segment_counts[j] += cpi->mb_row_ei[i].segment_counts[j];
                     }
                 }
             }
 
             for (i = 0; i < cpi->encoding_thread_count; i++)
             {
-                int mode_count;
-                int mv_vals;
                 totalrate += cpi->mb_row_ei[i].totalrate;
-
-                cpi->mb.skip_true_count += cpi->mb_row_ei[i].mb.skip_true_count;
-
-                for(mode_count = 0; mode_count < VP8_YMODES; mode_count++)
-                    cpi->mb.ymode_count[mode_count] +=
-                        cpi->mb_row_ei[i].mb.ymode_count[mode_count];
-
-                for(mode_count = 0; mode_count < VP8_UV_MODES; mode_count++)
-                    cpi->mb.uv_mode_count[mode_count] +=
-                        cpi->mb_row_ei[i].mb.uv_mode_count[mode_count];
-
-                for(mv_vals = 0; mv_vals < MVvals; mv_vals++)
-                {
-                    cpi->mb.MVcount[0][mv_vals] +=
-                        cpi->mb_row_ei[i].mb.MVcount[0][mv_vals];
-                    cpi->mb.MVcount[1][mv_vals] +=
-                        cpi->mb_row_ei[i].mb.MVcount[1][mv_vals];
-                }
-
-                cpi->mb.prediction_error +=
-                    cpi->mb_row_ei[i].mb.prediction_error;
-                cpi->mb.intra_error += cpi->mb_row_ei[i].mb.intra_error;
-
-                /* add up counts for each thread */
-                sum_coef_counts(x, &cpi->mb_row_ei[i].mb);
             }
 
         }
         else
 #endif
         {
-
             /* for each macroblock row in image */
             for (mb_row = 0; mb_row < cm->mb_rows; mb_row++)
             {
                 vp8_zero(cm->left_context)
 
 #if CONFIG_REALTIME_ONLY & CONFIG_ONTHEFLY_BITPACKING
                 tp = cpi->tok;
 #endif
 
                 encode_mb_row(cpi, cm, mb_row, x, xd, &tp, segment_counts, &totalrate);
@@ skipping 201 matching lines @@
 
         do
         {
             ++ bct[xd->block[b].bmi.mode];
         }
         while (++b < 16);
     }
 
 #endif
 
-    ++x->ymode_count[m];
-    ++x->uv_mode_count[uvm];
+    ++cpi->ymode_count[m];
+    ++cpi->uv_mode_count[uvm];
 
 }
 
 /* Experimental stub function to create a per MB zbin adjustment based on
  * some previously calculated measure of MB activity.
  */
 static void adjust_act_zbin( VP8_COMP *cpi, MACROBLOCK *x )
 {
 #if USE_ACT_INDEX
     x->act_zbin_adj = *(x->mb_activity_ptr);
 #else
     int64_t a;
     int64_t b;
     int64_t act = *(x->mb_activity_ptr);
 
     /* Apply the masking to the RD multiplier. */
     a = act + 4*cpi->activity_avg;
     b = 4*act + cpi->activity_avg;
 
     if ( act > cpi->activity_avg )
         x->act_zbin_adj = (int)(((int64_t)b + (a>>1))/a) - 1;
     else
         x->act_zbin_adj = 1 - (int)(((int64_t)a + (b>>1))/b);
 #endif
 }
 
-int vp8cx_encode_intra_macroblock(VP8_COMP *cpi, MACROBLOCK *x,
-                                  TOKENEXTRA **t)
+int vp8cx_encode_intra_macroblock(VP8_COMP *cpi, MACROBLOCK *x, TOKENEXTRA **t)
 {
     MACROBLOCKD *xd = &x->e_mbd;
     int rate;
 
     if (cpi->sf.RD && cpi->compressor_speed != 2)
-        vp8_rd_pick_intra_mode(x, &rate);
+        vp8_rd_pick_intra_mode(cpi, x, &rate);
     else
-        vp8_pick_intra_mode(x, &rate);
+        vp8_pick_intra_mode(cpi, x, &rate);
 
     if(cpi->oxcf.tuning == VP8_TUNE_SSIM)
     {
         adjust_act_zbin( cpi, x );
         vp8_update_zbin_extra(cpi, x);
     }
 
     if (x->e_mbd.mode_info_context->mbmi.mode == B_PRED)
         vp8_encode_intra4x4mby(x);
     else
         vp8_encode_intra16x16mby(x);
 
     vp8_encode_intra16x16mbuv(x);
 
     sum_intra_stats(cpi, x);
 
-    vp8_tokenize_mb(cpi, x, t);
+    vp8_tokenize_mb(cpi, &x->e_mbd, t);
 
     if (xd->mode_info_context->mbmi.mode != B_PRED)
         vp8_inverse_transform_mby(xd);
 
     vp8_dequant_idct_add_uv_block
                     (xd->qcoeff+16*16, xd->dequant_uv,
                      xd->dst.u_buffer, xd->dst.v_buffer,
                      xd->dst.uv_stride, xd->eobs+16);
     return rate;
 }
@@ skipping 58 matching lines @@
         /* restore cpi->zbin_mode_boost_enabled */
         cpi->zbin_mode_boost_enabled = zbin_mode_boost_enabled;
 
     }
     else
     {
         vp8_pick_inter_mode(cpi, x, recon_yoffset, recon_uvoffset, &rate,
                             &distortion, &intra_error, mb_row, mb_col);
     }
 
-    x->prediction_error += distortion;
-    x->intra_error += intra_error;
+    cpi->prediction_error += distortion;
+    cpi->intra_error += intra_error;
 
     if(cpi->oxcf.tuning == VP8_TUNE_SSIM)
     {
         /* Adjust the zbin based on this MB rate. */
         adjust_act_zbin( cpi, x );
     }
 
 #if 0
     /* Experimental RD code */
     cpi->frame_distortion += distortion;
@@ skipping 85 matching lines @@
         }
         else
             vp8_build_inter16x16_predictors_mb(xd, xd->dst.y_buffer,
                                            xd->dst.u_buffer, xd->dst.v_buffer,
                                            xd->dst.y_stride, xd->dst.uv_stride);
 
     }
 
     if (!x->skip)
     {
-        vp8_tokenize_mb(cpi, x, t);
+        vp8_tokenize_mb(cpi, xd, t);
 
         if (xd->mode_info_context->mbmi.mode != B_PRED)
             vp8_inverse_transform_mby(xd);
 
         vp8_dequant_idct_add_uv_block
                         (xd->qcoeff+16*16, xd->dequant_uv,
                          xd->dst.u_buffer, xd->dst.v_buffer,
                          xd->dst.uv_stride, xd->eobs+16);
     }
     else
     {
         /* always set mb_skip_coeff as it is needed by the loopfilter */
         xd->mode_info_context->mbmi.mb_skip_coeff = 1;
 
         if (cpi->common.mb_no_coeff_skip)
         {
-            x->skip_true_count ++;
+            cpi->skip_true_count ++;
             vp8_fix_contexts(xd);
         }
         else
         {
-            vp8_stuff_mb(cpi, x, t);
+            vp8_stuff_mb(cpi, xd, t);
         }
     }
 
     return rate;
 }