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.
  */
 
 #include "math.h"
 #include "limits.h"
 #include "vp9/encoder/vp9_block.h"
 #include "vp9/encoder/vp9_onyx_int.h"
 #include "vp9/encoder/vp9_variance.h"
 #include "vp9/encoder/vp9_encodeintra.h"
 #include "vp9/common/vp9_setupintrarecon.h"
 #include "vp9/encoder/vp9_mcomp.h"
 #include "vp9/encoder/vp9_firstpass.h"
-#include "vpx_scale/vpxscale.h"
+#include "vpx_scale/vpx_scale.h"
 #include "vp9/encoder/vp9_encodeframe.h"
 #include "vp9/encoder/vp9_encodemb.h"
 #include "vp9/common/vp9_extend.h"
 #include "vp9/common/vp9_systemdependent.h"
 #include "vpx_mem/vpx_mem.h"
 #include "vp9/common/vp9_swapyv12buffer.h"
 #include <stdio.h>
 #include "vp9/encoder/vp9_quantize.h"
 #include "vp9/encoder/vp9_rdopt.h"
 #include "vp9/encoder/vp9_ratectrl.h"
@@ skipping 258 matching lines @@
   1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
   1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
   1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
   1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
   1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000
 };
 
 static double simple_weight(YV12_BUFFER_CONFIG *source) {
   int i, j;
 
-  unsigned char *src = source->y_buffer;
+  uint8_t *src = source->y_buffer;
   double sum_weights = 0.0;
 
   // Loop throught the Y plane raw examining levels and creating a weight for the image
   i = source->y_height;
   do {
     j = source->y_width;
     do {
       sum_weights += weight_table[ *src];
       src++;
     } while (--j);
@@ skipping 28 matching lines @@
 
 void vp9_end_first_pass(VP9_COMP *cpi) {
   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;
   BLOCK *b = &x->block[0];
   BLOCKD *d = &x->e_mbd.block[0];
 
-  unsigned char *src_ptr = (*(b->base_src) + b->src);
+  uint8_t *src_ptr = (*(b->base_src) + b->src);
   int src_stride = b->src_stride;
-  unsigned char *ref_ptr;
+  uint8_t *ref_ptr;
   int ref_stride = d->pre_stride;
 
   // Set up pointers for this macro block recon buffer
   xd->pre.y_buffer = recon_buffer->y_buffer + recon_yoffset;
 
-  ref_ptr = (unsigned char *)(*(d->base_pre) + d->pre);
+  ref_ptr = (uint8_t *)(*(d->base_pre) + d->pre);
 
   vp9_mse16x16(src_ptr, src_stride, ref_ptr, ref_stride,
                (unsigned int *)(best_motion_err));
 }
 
 static void first_pass_motion_search(VP9_COMP *cpi, MACROBLOCK *x,
                                      int_mv *ref_mv, MV *best_mv,
                                      YV12_BUFFER_CONFIG *recon_buffer,
                                      int *best_motion_err, int recon_yoffset) {
   MACROBLOCKD *const xd = &x->e_mbd;
@@ skipping 142 matching lines @@
     for (mb_col = 0; mb_col < cm->mb_cols; mb_col++) {
       int this_error;
       int gf_motion_error = INT_MAX;
       int use_dc_pred = (mb_col || mb_row) && (!mb_col || !mb_row);
 
       xd->dst.y_buffer = new_yv12->y_buffer + recon_yoffset;
       xd->dst.u_buffer = new_yv12->u_buffer + recon_uvoffset;
       xd->dst.v_buffer = new_yv12->v_buffer + recon_uvoffset;
       xd->left_available = (mb_col != 0);
 
-#if !CONFIG_SUPERBLOCKS
-      // Copy current mb to a buffer
-      vp9_copy_mem16x16(x->src.y_buffer, x->src.y_stride, x->thismb, 16);
-#endif
-
       // do intra 16x16 prediction
       this_error = vp9_encode_intra(cpi, 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
@@ skipping 258 matching lines @@
 // Estimate a cost per mb attributable to overheads such as the coding of
 // modes and motion vectors.
 // Currently simplistic in its assumptions for testing.
 //
 
 
 static double bitcost(double prob) {
   return -(log(prob) / log(2.0));
 }
 
-static long long estimate_modemvcost(VP9_COMP *cpi,
+static int64_t estimate_modemvcost(VP9_COMP *cpi,
                                      FIRSTPASS_STATS *fpstats) {
+#if 0
   int mv_cost;
   int mode_cost;
 
   double av_pct_inter = fpstats->pcnt_inter / fpstats->count;
   double av_pct_motion = fpstats->pcnt_motion / fpstats->count;
   double av_intra = (1.0 - av_pct_inter);
 
   double zz_cost;
   double motion_cost;
   double intra_cost;
 
   zz_cost = bitcost(av_pct_inter - av_pct_motion);
   motion_cost = bitcost(av_pct_motion);
   intra_cost = bitcost(av_intra);
 
   // Estimate of extra bits per mv overhead for mbs
   // << 9 is the normalization to the (bits * 512) used in vp9_bits_per_mb
   mv_cost = ((int)(fpstats->new_mv_count / fpstats->count) * 8) << 9;
 
   // Crude estimate of overhead cost from modes
   // << 9 is the normalization to (bits * 512) used in vp9_bits_per_mb
   mode_cost =
     (int)((((av_pct_inter - av_pct_motion) * zz_cost) +
            (av_pct_motion * motion_cost) +
            (av_intra * intra_cost)) * cpi->common.MBs) << 9;
 
   // return mv_cost + mode_cost;
   // TODO PGW Fix overhead costs for extended Q range
+#endif
   return 0;
 }
 
 static double calc_correction_factor(double err_per_mb,
                                      double err_divisor,
                                      double pt_low,
                                      double pt_high,
                                      int Q) {
   double power_term;
   double error_term = err_per_mb / err_divisor;
@@ skipping 384 matching lines @@
 
 // Function to test for a condition where a complex transition is followed
 // by a static section. For example in slide shows where there is a fade
 // between slides. This is to help with more optimal kf and gf positioning.
 static int detect_transition_to_still(
   VP9_COMP *cpi,
   int frame_interval,
   int still_interval,
   double loop_decay_rate,
   double last_decay_rate) {
-  BOOL trans_to_still = FALSE;
+  int trans_to_still = FALSE;
 
   // Break clause to detect very still sections after motion
   // For example a static image after a fade or other transition
   // instead of a clean scene cut.
   if ((frame_interval > MIN_GF_INTERVAL) &&
       (loop_decay_rate >= 0.999) &&
       (last_decay_rate < 0.9)) {
     int j;
     FIRSTPASS_STATS *position = cpi->twopass.stats_in;
     FIRSTPASS_STATS tmp_next_frame;
@@ skipping 17 matching lines @@
     if (j == still_interval)
       trans_to_still = TRUE;
   }
 
   return trans_to_still;
 }
 
 // This function detects a flash through the high relative pcnt_second_ref
 // score in the frame following a flash frame. The offset passed in should
 // reflect this
-static BOOL detect_flash(VP9_COMP *cpi, int offset) {
+static int detect_flash(VP9_COMP *cpi, int offset) {
   FIRSTPASS_STATS next_frame;
 
-  BOOL flash_detected = FALSE;
+  int flash_detected = FALSE;
 
   // Read the frame data.
   // The return is FALSE (no flash detected) if not a valid frame
   if (read_frame_stats(cpi, &next_frame, offset) != EOF) {
     // What we are looking for here is a situation where there is a
     // brief break in prediction (such as a flash) but subsequent frames
     // are reasonably well predicted by an earlier (pre flash) frame.
     // The recovery after a flash is indicated by a high pcnt_second_ref
     // comapred to pcnt_inter.
     if ((next_frame.pcnt_second_ref > next_frame.pcnt_inter) &&
@@ skipping 91 matching lines @@
   FIRSTPASS_STATS this_frame;
 
   int i;
   double boost_score = 0.0;
   double mv_ratio_accumulator = 0.0;
   double decay_accumulator = 1.0;
   double this_frame_mv_in_out = 0.0;
   double mv_in_out_accumulator = 0.0;
   double abs_mv_in_out_accumulator = 0.0;
   int arf_boost;
-  BOOL flash_detected = FALSE;
+  int flash_detected = FALSE;
 
   // 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,
                                   &this_frame_mv_in_out, &mv_in_out_accumulator,
                                   &abs_mv_in_out_accumulator, &mv_ratio_accumulator);
@@ skipping 134 matching lines @@
   double mv_in_out_accumulator = 0.0;
   double abs_mv_in_out_accumulator = 0.0;
 
   int max_bits = frame_max_bits(cpi);     // Max for a single frame
 
   unsigned int allow_alt_ref =
     cpi->oxcf.play_alternate && cpi->oxcf.lag_in_frames;
 
   int f_boost = 0;
   int b_boost = 0;
-  BOOL flash_detected;
+  int flash_detected;
 
   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.
@@ skipping 389 matching lines @@
   return ret_val;
 }
 
 void vp9_second_pass(VP9_COMP *cpi) {
   int tmp_q;
   int frames_left = (int)(cpi->twopass.total_stats->count - cpi->common.current_video_frame);
 
   FIRSTPASS_STATS this_frame;
   FIRSTPASS_STATS this_frame_copy;
 
-  double this_frame_error;
   double this_frame_intra_error;
   double this_frame_coded_error;
 
-  FIRSTPASS_STATS *start_pos;
-
   int overhead_bits;
 
   if (!cpi->twopass.stats_in) {
     return;
   }
 
   vp9_clear_system_state();
 
   vpx_memset(&this_frame, 0, sizeof(FIRSTPASS_STATS));
 
   if (EOF == input_stats(cpi, &this_frame))
     return;
 
-  this_frame_error = this_frame.ssim_weighted_pred_err;
   this_frame_intra_error = this_frame.intra_error;
   this_frame_coded_error = this_frame.coded_error;
 
-  start_pos = cpi->twopass.stats_in;
-
   // keyframe and section processing !
   if (cpi->twopass.frames_to_key == 0) {
     // Define next KF group and assign bits to it
     vpx_memcpy(&this_frame_copy, &this_frame, sizeof(this_frame));
     find_next_key_frame(cpi, &this_frame_copy);
   }
 
   // Is this a GF / ARF (Note that a KF is always also a GF)
   if (cpi->frames_till_gf_update_due == 0) {
     // Define next gf group and assign bits to it
@@ skipping 104 matching lines @@
       adjust_active_maxq(cpi->active_worst_quality, tmp_q);
   }
 
   cpi->twopass.frames_to_key--;
 
   // Update the total stats remaining sturcture
   subtract_stats(cpi->twopass.total_left_stats, &this_frame);
 }
 
 
-static BOOL test_candidate_kf(VP9_COMP *cpi,  FIRSTPASS_STATS *last_frame, FIRSTPASS_STATS *this_frame, FIRSTPASS_STATS *next_frame) {
-  BOOL is_viable_kf = FALSE;
+static int test_candidate_kf(VP9_COMP *cpi,
+                             FIRSTPASS_STATS *last_frame,
+                             FIRSTPASS_STATS *this_frame,
+                             FIRSTPASS_STATS *next_frame) {
+  int is_viable_kf = FALSE;
 
   // Does the frame satisfy the primary criteria of a key frame
   //      If so, then examine how well it predicts subsequent frames
   if ((this_frame->pcnt_second_ref < 0.10) &&
       (next_frame->pcnt_second_ref < 0.10) &&
       ((this_frame->pcnt_inter < 0.05) ||
        (
          ((this_frame->pcnt_inter - this_frame->pcnt_neutral) < .35) &&
          ((this_frame->intra_error / DOUBLE_DIVIDE_CHECK(this_frame->coded_error)) < 2.5) &&
          ((fabs(last_frame->coded_error - this_frame->coded_error) / DOUBLE_DIVIDE_CHECK(this_frame->coded_error) > .40) ||
@@ skipping 403 matching lines @@
                                   cpi->output_frame_rate);
   }
 
   // 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;
 }