libvpx: Pull from upstream

source/libvpx/vp9/encoder/vp9_firstpass.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 329 matching lines @@
   output_stats(cpi, cpi->output_pkt_list, &cpi->twopass.total_stats);
 }
 
 static void zz_motion_search(VP9_COMP *cpi, MACROBLOCK *x, YV12_BUFFER_CONFIG *recon_buffer, int *best_motion_err, int recon_yoffset) {
   MACROBLOCKD *const xd = &x->e_mbd;
 
   // Set up pointers for this macro block recon buffer
   xd->plane[0].pre[0].buf = recon_buffer->y_buffer + recon_yoffset;
 
   switch (xd->mode_info_context->mbmi.sb_type) {
-    case BLOCK_SIZE_SB8X8:
+    case BLOCK_8X8:
       vp9_mse8x8(x->plane[0].src.buf, x->plane[0].src.stride,
                  xd->plane[0].pre[0].buf, xd->plane[0].pre[0].stride,
                  (unsigned int *)(best_motion_err));
       break;
-    case BLOCK_SIZE_SB16X8:
+    case BLOCK_16X8:
       vp9_mse16x8(x->plane[0].src.buf, x->plane[0].src.stride,
                   xd->plane[0].pre[0].buf, xd->plane[0].pre[0].stride,
                   (unsigned int *)(best_motion_err));
       break;
-    case BLOCK_SIZE_SB8X16:
+    case BLOCK_8X16:
       vp9_mse8x16(x->plane[0].src.buf, x->plane[0].src.stride,
                   xd->plane[0].pre[0].buf, xd->plane[0].pre[0].stride,
                   (unsigned int *)(best_motion_err));
       break;
     default:
       vp9_mse16x16(x->plane[0].src.buf, x->plane[0].src.stride,
                    xd->plane[0].pre[0].buf, xd->plane[0].pre[0].stride,
                    (unsigned int *)(best_motion_err));
       break;
   }
@@ skipping 25 matching lines @@
   while ((quart_frm << sr) < MAX_FULL_PEL_VAL)
     sr++;
   if (sr)
     sr--;
 
   step_param    += sr;
   further_steps -= sr;
 
   // override the default variance function to use MSE
   switch (xd->mode_info_context->mbmi.sb_type) {
-    case BLOCK_SIZE_SB8X8:
+    case BLOCK_8X8:
       v_fn_ptr.vf = vp9_mse8x8;
       break;
-    case BLOCK_SIZE_SB16X8:
+    case BLOCK_16X8:
       v_fn_ptr.vf = vp9_mse16x8;
       break;
-    case BLOCK_SIZE_SB8X16:
+    case BLOCK_8X16:
       v_fn_ptr.vf = vp9_mse8x16;
       break;
     default:
       v_fn_ptr.vf = vp9_mse16x16;
       break;
   }
 
   // Set up pointers for this macro block recon buffer
   xd->plane[0].pre[0].buf = recon_buffer->y_buffer + recon_yoffset;
 
@@ skipping 119 matching lines @@
       int gf_motion_error = INT_MAX;
       int use_dc_pred = (mb_col || mb_row) && (!mb_col || !mb_row);
 
       xd->plane[0].dst.buf = new_yv12->y_buffer + recon_yoffset;
       xd->plane[1].dst.buf = new_yv12->u_buffer + recon_uvoffset;
       xd->plane[2].dst.buf = new_yv12->v_buffer + recon_uvoffset;
       xd->left_available = (mb_col != 0);
 
       if (mb_col * 2 + 1 < cm->mi_cols) {
         if (mb_row * 2 + 1 < cm->mi_rows) {
-          xd->mode_info_context->mbmi.sb_type = BLOCK_SIZE_MB16X16;
+          xd->mode_info_context->mbmi.sb_type = BLOCK_16X16;
         } else {
-          xd->mode_info_context->mbmi.sb_type = BLOCK_SIZE_SB16X8;
+          xd->mode_info_context->mbmi.sb_type = BLOCK_16X8;
         }
       } else {
         if (mb_row * 2 + 1 < cm->mi_rows) {
-          xd->mode_info_context->mbmi.sb_type = BLOCK_SIZE_SB8X16;
+          xd->mode_info_context->mbmi.sb_type = BLOCK_8X16;
         } else {
-          xd->mode_info_context->mbmi.sb_type = BLOCK_SIZE_SB8X8;
+          xd->mode_info_context->mbmi.sb_type = BLOCK_8X8;
         }
       }
       xd->mode_info_context->mbmi.ref_frame[0] = INTRA_FRAME;
       set_mi_row_col(cm, xd,
                      mb_row << 1,
                      1 << mi_height_log2(xd->mode_info_context->mbmi.sb_type),
                      mb_col << 1,
                      1 << mi_height_log2(xd->mode_info_context->mbmi.sb_type));
 
       // do intra 16x16 prediction
-      this_error = vp9_encode_intra(cpi, x, use_dc_pred);
+      this_error = vp9_encode_intra(x, use_dc_pred);
 
       // "intrapenalty" below deals with situations where the intra and inter error scores are very low (eg a plain black frame)
       // We do not have special cases in first pass for 0,0 and nearest etc so all inter modes carry an overhead cost estimate fot the mv.
       // When the error score is very low this causes us to pick all or lots of INTRA modes and throw lots of key frames.
       // This penalty adds a cost matching that of a 0,0 mv to the intra case.
       this_error += intrapenalty;
 
       // Cumulative intra error total
       intra_error += (int64_t)this_error;
 
@@ skipping 78 matching lines @@
           mv.as_mv.row <<= 3;
           mv.as_mv.col <<= 3;
           this_error = motion_error;
           vp9_set_mbmode_and_mvs(x, NEWMV, &mv);
           xd->mode_info_context->mbmi.txfm_size = TX_4X4;
           xd->mode_info_context->mbmi.ref_frame[0] = LAST_FRAME;
           xd->mode_info_context->mbmi.ref_frame[1] = NONE;
           vp9_build_inter_predictors_sby(xd, mb_row << 1,
                                          mb_col << 1,
                                          xd->mode_info_context->mbmi.sb_type);
-          vp9_encode_sby(cm, x, xd->mode_info_context->mbmi.sb_type);
+          vp9_encode_sby(x, xd->mode_info_context->mbmi.sb_type);
           sum_mvr += mv.as_mv.row;
           sum_mvr_abs += abs(mv.as_mv.row);
           sum_mvc += mv.as_mv.col;
           sum_mvc_abs += abs(mv.as_mv.col);
           sum_mvrs += mv.as_mv.row * mv.as_mv.row;
           sum_mvcs += mv.as_mv.col * mv.as_mv.col;
           intercount++;
 
           best_ref_mv.as_int = mv.as_int;
 
@@ skipping 594 matching lines @@
     if (next_frame.pcnt_second_ref > next_frame.pcnt_inter &&
         next_frame.pcnt_second_ref >= 0.5)
       flash_detected = 1;
   }
 
   return flash_detected;
 }
 
 // Update the motion related elements to the GF arf boost calculation
 static void accumulate_frame_motion_stats(
-  VP9_COMP *cpi,
   FIRSTPASS_STATS *this_frame,
   double *this_frame_mv_in_out,
   double *mv_in_out_accumulator,
   double *abs_mv_in_out_accumulator,
   double *mv_ratio_accumulator) {
   // double this_frame_mv_in_out;
   double this_frame_mvr_ratio;
   double this_frame_mvc_ratio;
   double motion_pct;
 
@@ skipping 74 matching lines @@
   double abs_mv_in_out_accumulator = 0.0;
   int arf_boost;
   int flash_detected = 0;
 
   // Search forward from the proposed arf/next gf position
   for (i = 0; i < f_frames; i++) {
     if (read_frame_stats(cpi, &this_frame, (i + offset)) == EOF)
       break;
 
     // Update the motion related elements to the boost calculation
-    accumulate_frame_motion_stats(cpi, &this_frame,
+    accumulate_frame_motion_stats(&this_frame,
                                   &this_frame_mv_in_out, &mv_in_out_accumulator,
                                   &abs_mv_in_out_accumulator, &mv_ratio_accumulator);
 
     // We want to discount the flash frame itself and the recovery
     // frame that follows as both will have poor scores.
     flash_detected = detect_flash(cpi, (i + offset)) ||
                      detect_flash(cpi, (i + offset + 1));
 
     // Cumulative effect of prediction quality decay
     if (!flash_detected) {
@@ skipping 15 matching lines @@
   this_frame_mv_in_out = 0.0;
   mv_in_out_accumulator = 0.0;
   abs_mv_in_out_accumulator = 0.0;
 
   // Search backward towards last gf position
   for (i = -1; i >= -b_frames; i--) {
     if (read_frame_stats(cpi, &this_frame, (i + offset)) == EOF)
       break;
 
     // Update the motion related elements to the boost calculation
-    accumulate_frame_motion_stats(cpi, &this_frame,
+    accumulate_frame_motion_stats(&this_frame,
                                   &this_frame_mv_in_out, &mv_in_out_accumulator,
                                   &abs_mv_in_out_accumulator, &mv_ratio_accumulator);
 
     // We want to discount the the flash frame itself and the recovery
     // frame that follows as both will have poor scores.
     flash_detected = detect_flash(cpi, (i + offset)) ||
                      detect_flash(cpi, (i + offset + 1));
 
     // Cumulative effect of prediction quality decay
     if (!flash_detected) {
@@ skipping 147 matching lines @@
   for (i = 0; i < cpi->new_frame_coding_order_period; ++i) {
     printf("%4d ", cpi->arf_weight[i]);
   }
   printf("\n");
 #endif
 }
 #endif
 
 // Analyse and define a gf/arf group.
 static void define_gf_group(VP9_COMP *cpi, FIRSTPASS_STATS *this_frame) {
-  FIRSTPASS_STATS next_frame;
+  FIRSTPASS_STATS next_frame = { 0 };
   FIRSTPASS_STATS *start_pos;
   int i;
   double boost_score = 0.0;
   double old_boost_score = 0.0;
   double gf_group_err = 0.0;
   double gf_first_frame_err = 0.0;
   double mod_frame_err = 0.0;
 
   double mv_ratio_accumulator = 0.0;
   double decay_accumulator = 1.0;
@@ skipping 15 matching lines @@
   int b_boost = 0;
   int flash_detected;
   int active_max_gf_interval;
 
   cpi->twopass.gf_group_bits = 0;
 
   vp9_clear_system_state();  // __asm emms;
 
   start_pos = cpi->twopass.stats_in;
 
-  vpx_memset(&next_frame, 0, sizeof(next_frame)); // assure clean
-
   // Load stats for the current frame.
   mod_frame_err = calculate_modified_err(cpi, this_frame);
 
   // Note the error of the frame at the start of the group (this will be
   // the GF frame error if we code a normal gf
   gf_first_frame_err = mod_frame_err;
 
   // Special treatment if the current frame is a key frame (which is also
   // a gf). If it is then its error score (and hence bit allocation) need
   // to be subtracted out from the calculation for the GF group
@@ skipping 26 matching lines @@
     gf_group_err += mod_frame_err;
 
     if (EOF == input_stats(cpi, &next_frame))
       break;
 
     // Test for the case where there is a brief flash but the prediction
     // quality back to an earlier frame is then restored.
     flash_detected = detect_flash(cpi, 0);
 
     // Update the motion related elements to the boost calculation
-    accumulate_frame_motion_stats(cpi, &next_frame,
+    accumulate_frame_motion_stats(&next_frame,
                                   &this_frame_mv_in_out, &mv_in_out_accumulator,
                                   &abs_mv_in_out_accumulator, &mv_ratio_accumulator);
 
     // Cumulative effect of prediction quality decay
     if (!flash_detected) {
       last_loop_decay_rate = loop_decay_rate;
       loop_decay_rate = get_prediction_decay_rate(cpi, &next_frame);
       decay_accumulator = decay_accumulator * loop_decay_rate;
 
       // Monitor for static sections.
@@ skipping 453 matching lines @@
     tmp_q = estimate_max_q(
               cpi,
               &cpi->twopass.total_left_stats,
               (int)(cpi->twopass.bits_left / frames_left));
 
     // Make a damped adjustment to active max Q
     cpi->active_worst_quality =
       adjust_active_maxq(cpi->active_worst_quality, tmp_q);
   }
 #endif
-
-  vpx_memset(&this_frame, 0, sizeof(FIRSTPASS_STATS));
+  vp9_zero(this_frame);
   if (EOF == input_stats(cpi, &this_frame))
     return;
 
   this_frame_intra_error = this_frame.intra_error;
   this_frame_coded_error = this_frame.coded_error;
 
   // keyframe and section processing !
   if (cpi->twopass.frames_to_key == 0) {
     // Define next KF group and assign bits to it
     this_frame_copy = this_frame;
@@ skipping 157 matching lines @@
   double zero_motion_accumulator = 1.0;
   double boost_score = 0;
   double loop_decay_rate;
 
   double kf_mod_err = 0.0;
   double kf_group_err = 0.0;
   double kf_group_intra_err = 0.0;
   double kf_group_coded_err = 0.0;
   double recent_loop_decay[8] = {1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0};
 
-  vpx_memset(&next_frame, 0, sizeof(next_frame)); // assure clean
+  vp9_zero(next_frame);
 
   vp9_clear_system_state();  // __asm emms;
   start_position = cpi->twopass.stats_in;
 
   cpi->common.frame_type = KEY_FRAME;
 
   // is this a forced key frame by interval
   cpi->this_key_frame_forced = cpi->next_key_frame_forced;
 
   // Clear the alt ref active flag as this can never be active on a key frame
@@ skipping 294 matching lines @@
                                   cpi->output_framerate);
   }
 
   // Note the total error score of the kf group minus the key frame itself
   cpi->twopass.kf_group_error_left = (int)(kf_group_err - kf_mod_err);
 
   // Adjust the count of total modified error left.
   // The count of bits left is adjusted elsewhere based on real coded frame sizes
   cpi->twopass.modified_error_left -= kf_group_err;
 }