libvpx: Pull from upstream

source/libvpx/vp8/encoder/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 555 matching lines @@
     vp8_build_block_offsets(x);
 
     /* set up frame new frame for intra coded blocks */
     vp8_setup_intra_recon(new_yv12);
     vp8cx_frame_init_quantizer(cpi);
 
     /* Initialise the MV cost table to the defaults */
     {
         int flag[2] = {1, 1};
         vp8_initialize_rd_consts(cpi, x, vp8_dc_quant(cm->base_qindex, cm->y1dc_delta_q));
-        vpx_memcpy(cm->fc.mvc, vp8_default_mv_context, sizeof(vp8_default_mv_context));
+        memcpy(cm->fc.mvc, vp8_default_mv_context, sizeof(vp8_default_mv_context));
         vp8_build_component_cost_table(cpi->mb.mvcost, (const MV_CONTEXT *) cm->fc.mvc, flag);
     }
 
     /* for each macroblock row in image */
     for (mb_row = 0; mb_row < cm->mb_rows; mb_row++)
     {
         int_mv best_ref_mv;
 
         best_ref_mv.as_int = 0;
 
@@ skipping 1185 matching lines @@
     int b_boost = 0;
     int flash_detected;
 
     cpi->twopass.gf_group_bits = 0;
     cpi->twopass.gf_decay_rate = 0;
 
     vp8_clear_system_state();
 
     start_pos = cpi->twopass.stats_in;
 
-    vpx_memset(&next_frame, 0, sizeof(next_frame)); /* assure clean */
+    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
@@ skipping 75 matching lines @@
                 ((mv_ratio_accumulator > 100.0) ||
                  (abs_mv_in_out_accumulator > 3.0) ||
                  (mv_in_out_accumulator < -2.0) ||
                  ((boost_score - old_boost_score) < 2.0))
             ) )
         {
             boost_score = old_boost_score;
             break;
         }
 
-        vpx_memcpy(this_frame, &next_frame, sizeof(*this_frame));
+        memcpy(this_frame, &next_frame, sizeof(*this_frame));
 
         old_boost_score = boost_score;
     }
 
     cpi->twopass.gf_decay_rate =
         (i > 0) ? (int)(100.0 * (1.0 - decay_accumulator)) / i : 0;
 
     /* When using CBR apply additional buffer related upper limits */
     if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER)
     {
@@ skipping 549 matching lines @@
     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 */
-        vpx_memcpy(&this_frame_copy, &this_frame, sizeof(this_frame));
+        memcpy(&this_frame_copy, &this_frame, sizeof(this_frame));
         find_next_key_frame(cpi, &this_frame_copy);
 
         /* Special case: Error error_resilient_mode mode does not make much
          * sense for two pass but with its current meaning this code is
          * designed to stop outlandish behaviour if someone does set it when
          * using two pass. It effectively disables GF groups. This is
          * temporary code until we decide what should really happen in this
          * case.
          */
         if (cpi->oxcf.error_resilient_mode)
         {
             cpi->twopass.gf_group_bits = cpi->twopass.kf_group_bits;
             cpi->twopass.gf_group_error_left =
                                   (int)cpi->twopass.kf_group_error_left;
             cpi->baseline_gf_interval = cpi->twopass.frames_to_key;
             cpi->frames_till_gf_update_due = cpi->baseline_gf_interval;
             cpi->source_alt_ref_pending = 0;
         }
 
     }
 
     /* 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 */
-        vpx_memcpy(&this_frame_copy, &this_frame, sizeof(this_frame));
+        memcpy(&this_frame_copy, &this_frame, sizeof(this_frame));
         define_gf_group(cpi, &this_frame_copy);
 
         /* If we are going to code an altref frame at the end of the group
          * and the current frame is not a key frame.... If the previous
          * group used an arf this frame has already benefited from that arf
          * boost and it should not be given extra bits If the previous
          * group was NOT coded using arf we may want to apply some boost to
          * this GF as well
          */
         if (cpi->source_alt_ref_pending && (cpi->common.frame_type != KEY_FRAME))
         {
             /* Assign a standard frames worth of bits from those allocated
              * to the GF group
              */
             int bak = cpi->per_frame_bandwidth;
-            vpx_memcpy(&this_frame_copy, &this_frame, sizeof(this_frame));
+            memcpy(&this_frame_copy, &this_frame, sizeof(this_frame));
             assign_std_frame_bits(cpi, &this_frame_copy);
             cpi->per_frame_bandwidth = bak;
         }
     }
 
     /* Otherwise this is an ordinary frame */
     else
     {
         /* Special case: Error error_resilient_mode mode does not make much
          * sense for two pass but with its current meaning but this code is
          * designed to stop outlandish behaviour if someone does set it
          * when using two pass. It effectively disables GF groups. This is
          * temporary code till we decide what should really happen in this
          * case.
          */
         if (cpi->oxcf.error_resilient_mode)
         {
             cpi->frames_till_gf_update_due = cpi->twopass.frames_to_key;
 
             if (cpi->common.frame_type != KEY_FRAME)
             {
                 /* Assign bits from those allocated to the GF group */
-                vpx_memcpy(&this_frame_copy, &this_frame, sizeof(this_frame));
+                memcpy(&this_frame_copy, &this_frame, sizeof(this_frame));
                 assign_std_frame_bits(cpi, &this_frame_copy);
             }
         }
         else
         {
             /* Assign bits from those allocated to the GF group */
-            vpx_memcpy(&this_frame_copy, &this_frame, sizeof(this_frame));
+            memcpy(&this_frame_copy, &this_frame, sizeof(this_frame));
             assign_std_frame_bits(cpi, &this_frame_copy);
         }
     }
 
     /* Keep a globally available copy of this and the next frame's iiratio. */
     cpi->twopass.this_iiratio = (unsigned int)(this_frame_intra_error /
                         DOUBLE_DIVIDE_CHECK(this_frame_coded_error));
     {
         FIRSTPASS_STATS next_frame;
         if ( lookup_next_frame_stats(cpi, &next_frame) != EOF )
@@ skipping 120 matching lines @@
         int i;
         FIRSTPASS_STATS *start_pos;
 
         FIRSTPASS_STATS local_next_frame;
 
         double boost_score = 0.0;
         double old_boost_score = 0.0;
         double decay_accumulator = 1.0;
         double next_iiratio;
 
-        vpx_memcpy(&local_next_frame, next_frame, sizeof(*next_frame));
+        memcpy(&local_next_frame, next_frame, sizeof(*next_frame));
 
         /* Note the starting file position so we can reset to it */
         start_pos = cpi->twopass.stats_in;
 
         /* Examine how well the key frame predicts subsequent frames */
         for (i = 0 ; i < 16; i++)
         {
             next_iiratio = (IIKFACTOR1 * local_next_frame.intra_error / DOUBLE_DIVIDE_CHECK(local_next_frame.coded_error)) ;
 
             if (next_iiratio > RMAX)
@@ skipping 56 matching lines @@
     double boost_score = 0;
     double old_boost_score = 0.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));
+    memset(&next_frame, 0, sizeof(next_frame));
 
     vp8_clear_system_state();
     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
      */
     cpi->source_alt_ref_active = 0;
 
     /* Kf is always a gf so clear frames till next gf counter */
     cpi->frames_till_gf_update_due = 0;
 
     cpi->twopass.frames_to_key = 1;
 
     /* Take a copy of the initial frame details */
-    vpx_memcpy(&first_frame, this_frame, sizeof(*this_frame));
+    memcpy(&first_frame, this_frame, sizeof(*this_frame));
 
     cpi->twopass.kf_group_bits = 0;
     cpi->twopass.kf_group_error_left = 0;
 
     kf_mod_err = calculate_modified_err(cpi, this_frame);
 
     /* find the next keyframe */
     i = 0;
     while (cpi->twopass.stats_in < cpi->twopass.stats_in_end)
     {
         /* Accumulate kf group error */
         kf_group_err += calculate_modified_err(cpi, this_frame);
 
         /* These figures keep intra and coded error counts for all frames
          * including key frames in the group. The effect of the key frame
          * itself can be subtracted out using the first_frame data
          * collected above
          */
         kf_group_intra_err += this_frame->intra_error;
         kf_group_coded_err += this_frame->coded_error;
 
         /* Load the next frame's stats. */
-        vpx_memcpy(&last_frame, this_frame, sizeof(*this_frame));
+        memcpy(&last_frame, this_frame, sizeof(*this_frame));
         input_stats(cpi, this_frame);
 
         /* Provided that we are not at the end of the file... */
         if (cpi->oxcf.auto_key
             && lookup_next_frame_stats(cpi, &next_frame) != EOF)
         {
             /* Normal scene cut check */
             if ( ( i >= MIN_GF_INTERVAL ) &&
                  test_candidate_kf(cpi, &last_frame, this_frame, &next_frame) )
             {
@@ skipping 47 matching lines @@
      */
     if (cpi->oxcf.auto_key
         && cpi->twopass.frames_to_key > (int)cpi->key_frame_frequency )
     {
         FIRSTPASS_STATS *current_pos = cpi->twopass.stats_in;
         FIRSTPASS_STATS tmp_frame;
 
         cpi->twopass.frames_to_key /= 2;
 
         /* Copy first frame details */
-        vpx_memcpy(&tmp_frame, &first_frame, sizeof(first_frame));
+        memcpy(&tmp_frame, &first_frame, sizeof(first_frame));
 
         /* Reset to the start of the group */
         reset_fpf_position(cpi, start_position);
 
         kf_group_err = 0;
         kf_group_intra_err = 0;
         kf_group_coded_err = 0;
 
         /* Rescan to get the correct error data for the forced kf group */
         for( i = 0; i < cpi->twopass.frames_to_key; i++ )
@@ skipping 101 matching lines @@
         cpi->twopass.kf_group_bits = 0;
 
     /* Reset the first pass file position */
     reset_fpf_position(cpi, start_position);
 
     /* determine how big to make this keyframe based on how well the
      * subsequent frames use inter blocks
      */
     decay_accumulator = 1.0;
     boost_score = 0.0;
-    loop_decay_rate = 1.00;       /* Starting decay rate */
 
     for (i = 0 ; i < cpi->twopass.frames_to_key ; i++)
     {
         double r;
 
         if (EOF == input_stats(cpi, &next_frame))
             break;
 
         if (next_frame.intra_error > cpi->twopass.kf_intra_err_min)
             r = (IIKFACTOR2 * next_frame.intra_error /
@@ skipping 223 matching lines @@
     if (cpi->oxcf.allow_spatial_resampling)
     {
         int resample_trigger = 0;
         int last_kf_resampled = 0;
         int kf_q;
         int scale_val = 0;
         int hr, hs, vr, vs;
         int new_width = cpi->oxcf.Width;
         int new_height = cpi->oxcf.Height;
 
-        int projected_buffer_level = (int)cpi->buffer_level;
+        int projected_buffer_level;
         int tmp_q;
 
         double projected_bits_perframe;
         double group_iiratio = (kf_group_intra_err - first_frame.intra_error) / (kf_group_coded_err - first_frame.coded_error);
         double err_per_frame = kf_group_err / cpi->twopass.frames_to_key;
         double bits_per_frame;
         double av_bits_per_frame;
         double effective_size_ratio;
 
         if ((cpi->common.Width != cpi->oxcf.Width) || (cpi->common.Height != cpi->oxcf.Height))
@@ skipping 136 matching lines @@
         }
 
         if ((cpi->common.Width != new_width) || (cpi->common.Height != new_height))
         {
             cpi->common.Width = new_width;
             cpi->common.Height = new_height;
             vp8_alloc_compressor_data(cpi);
         }
     }
 }