libvpx: Pull from upstream

source/libvpx/vp9/encoder/vp9_temporal_filter.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 "vp9/common/vp9_onyxc_int.h"
 #include "vp9/encoder/vp9_onyx_int.h"
 #include "vp9/common/vp9_systemdependent.h"
 #include "vp9/encoder/vp9_quantize.h"
 #include "vp9/common/vp9_alloccommon.h"
 #include "vp9/encoder/vp9_mcomp.h"
 #include "vp9/encoder/vp9_firstpass.h"
 #include "vp9/encoder/vp9_psnr.h"
-#include "vpx_scale/vpxscale.h"
+#include "vpx_scale/vpx_scale.h"
 #include "vp9/common/vp9_extend.h"
 #include "vp9/encoder/vp9_ratectrl.h"
 #include "vp9/common/vp9_quant_common.h"
 #include "vp9/encoder/vp9_segmentation.h"
 #include "vpx_mem/vpx_mem.h"
 #include "vp9/common/vp9_swapyv12buffer.h"
 #include "vpx_ports/vpx_timer.h"
 
 #include <math.h>
 #include <limits.h>
 
 #define ALT_REF_MC_ENABLED 1    // dis/enable MC in AltRef filtering
 #define ALT_REF_SUBPEL_ENABLED 1 // dis/enable subpel in MC AltRef filtering
 
 #if VP9_TEMPORAL_ALT_REF
 
 
-static void temporal_filter_predictors_mb_c
-(
-  MACROBLOCKD *xd,
-  unsigned char *y_mb_ptr,
-  unsigned char *u_mb_ptr,
-  unsigned char *v_mb_ptr,
-  int stride,
-  int mv_row,
-  int mv_col,
-  unsigned char *pred
-) {
+static void temporal_filter_predictors_mb_c(MACROBLOCKD *xd,
+                                            uint8_t *y_mb_ptr,
+                                            uint8_t *u_mb_ptr,
+                                            uint8_t *v_mb_ptr,
+                                            int stride,
+                                            int mv_row,
+                                            int mv_col,
+                                            uint8_t *pred) {
   int offset;
-  unsigned char *yptr, *uptr, *vptr;
+  uint8_t *yptr, *uptr, *vptr;
   int omv_row, omv_col;
 
   // Y
   yptr = y_mb_ptr + (mv_row >> 3) * stride + (mv_col >> 3);
 
   if ((mv_row | mv_col) & 7) {
     xd->subpixel_predict16x16(yptr, stride,
                              (mv_col & 7) << 1, (mv_row & 7) << 1, &pred[0], 16);
   } else {
     vp9_copy_mem16x16(yptr, stride, &pred[0], 16);
   }
 
   // U & V
   omv_row = mv_row;
   omv_col = mv_col;
   mv_row >>= 1;
   mv_col >>= 1;
   stride = (stride + 1) >> 1;
   offset = (mv_row >> 3) * stride + (mv_col >> 3);
   uptr = u_mb_ptr + offset;
   vptr = v_mb_ptr + offset;
 
   if ((omv_row | omv_col) & 15) {
     xd->subpixel_predict8x8(uptr, stride,
                            (omv_col & 15), (omv_row & 15), &pred[256], 8);
     xd->subpixel_predict8x8(vptr, stride,
                            (omv_col & 15), (omv_row & 15), &pred[320], 8);
-  }
-  else {
+  } else {
     vp9_copy_mem8x8(uptr, stride, &pred[256], 8);
     vp9_copy_mem8x8(vptr, stride, &pred[320], 8);
   }
 }
-void vp9_temporal_filter_apply_c
-(
-  unsigned char *frame1,
-  unsigned int stride,
-  unsigned char *frame2,
-  unsigned int block_size,
-  int strength,
-  int filter_weight,
-  unsigned int *accumulator,
-  unsigned short *count
-) {
+
+void vp9_temporal_filter_apply_c(uint8_t *frame1,
+                                 unsigned int stride,
+                                 uint8_t *frame2,
+                                 unsigned int block_size,
+                                 int strength,
+                                 int filter_weight,
+                                 unsigned int *accumulator,
+                                 uint16_t *count) {
   unsigned int i, j, k;
   int modifier;
   int byte = 0;
 
   for (i = 0, k = 0; i < block_size; i++) {
     for (j = 0; j < block_size; j++, k++) {
 
       int src_byte = frame1[byte];
       int pixel_value = *frame2++;
 
@@ skipping 17 matching lines @@
 
       byte++;
     }
 
     byte += stride - block_size;
   }
 }
 
 #if ALT_REF_MC_ENABLED
 
-static int temporal_filter_find_matching_mb_c
-(
-  VP9_COMP *cpi,
-  YV12_BUFFER_CONFIG *arf_frame,
-  YV12_BUFFER_CONFIG *frame_ptr,
-  int mb_offset,
-  int error_thresh
-) {
+static int temporal_filter_find_matching_mb_c(VP9_COMP *cpi,
+                                              YV12_BUFFER_CONFIG *arf_frame,
+                                              YV12_BUFFER_CONFIG *frame_ptr,
+                                              int mb_offset,
+                                              int error_thresh) {
   MACROBLOCK *x = &cpi->mb;
   int step_param;
-  int further_steps;
   int sadpb = x->sadperbit16;
   int bestsme = INT_MAX;
 
   BLOCK *b = &x->block[0];
   BLOCKD *d = &x->e_mbd.block[0];
   int_mv best_ref_mv1;
   int_mv best_ref_mv1_full; /* full-pixel value of best_ref_mv1 */
 
   // Save input state
-  unsigned char **base_src = b->base_src;
+  uint8_t **base_src = b->base_src;
   int src = b->src;
   int src_stride = b->src_stride;
-  unsigned char **base_pre = d->base_pre;
+  uint8_t **base_pre = d->base_pre;
   int pre = d->pre;
   int pre_stride = d->pre_stride;
 
   best_ref_mv1.as_int = 0;
   best_ref_mv1_full.as_mv.col = best_ref_mv1.as_mv.col >> 3;
   best_ref_mv1_full.as_mv.row = best_ref_mv1.as_mv.row >> 3;
 
   // Setup frame pointers
   b->base_src = &arf_frame->y_buffer;
   b->src_stride = arf_frame->y_stride;
   b->src = mb_offset;
 
   d->base_pre = &frame_ptr->y_buffer;
   d->pre_stride = frame_ptr->y_stride;
   d->pre = mb_offset;
 
   // Further step/diamond searches as necessary
   if (cpi->Speed < 8) {
     step_param = cpi->sf.first_step +
                  ((cpi->Speed > 5) ? 1 : 0);
-    further_steps =
-      (cpi->sf.max_step_search_steps - 1) - step_param;
   } else {
     step_param = cpi->sf.first_step + 2;
-    further_steps = 0;
   }
 
   /*cpi->sf.search_method == HEX*/
   // TODO Check that the 16x16 vf & sdf are selected here
   // Ignore mv costing by sending NULL pointer instead of cost arrays
   bestsme = vp9_hex_search(x, b, d, &best_ref_mv1_full, &d->bmi.as_mv.first,
                            step_param, sadpb, &cpi->fn_ptr[BLOCK_16X16],
                            NULL, NULL, NULL, NULL,
                            &best_ref_mv1);
 
@@ skipping 18 matching lines @@
   b->src = src;
   b->src_stride = src_stride;
   d->base_pre = base_pre;
   d->pre = pre;
   d->pre_stride = pre_stride;
 
   return bestsme;
 }
 #endif
 
-static void temporal_filter_iterate_c
-(
-  VP9_COMP *cpi,
-  int frame_count,
-  int alt_ref_index,
-  int strength
-) {
+static void temporal_filter_iterate_c(VP9_COMP *cpi,
+                                      int frame_count,
+                                      int alt_ref_index,
+                                      int strength) {
   int byte;
   int frame;
   int mb_col, mb_row;
   unsigned int filter_weight;
   int mb_cols = cpi->common.mb_cols;
   int mb_rows = cpi->common.mb_rows;
   int mb_y_offset = 0;
   int mb_uv_offset = 0;
   DECLARE_ALIGNED_ARRAY(16, unsigned int, accumulator, 16 * 16 + 8 * 8 + 8 * 8);
-  DECLARE_ALIGNED_ARRAY(16, unsigned short, count, 16 * 16 + 8 * 8 + 8 * 8);
+  DECLARE_ALIGNED_ARRAY(16, uint16_t, count, 16 * 16 + 8 * 8 + 8 * 8);
   MACROBLOCKD *mbd = &cpi->mb.e_mbd;
   YV12_BUFFER_CONFIG *f = cpi->frames[alt_ref_index];
-  unsigned char *dst1, *dst2;
-  DECLARE_ALIGNED_ARRAY(16, unsigned char,  predictor, 16 * 16 + 8 * 8 + 8 * 8);
+  uint8_t *dst1, *dst2;
+  DECLARE_ALIGNED_ARRAY(16, uint8_t,  predictor, 16 * 16 + 8 * 8 + 8 * 8);
 
   // Save input state
-  unsigned char *y_buffer = mbd->pre.y_buffer;
-  unsigned char *u_buffer = mbd->pre.u_buffer;
-  unsigned char *v_buffer = mbd->pre.v_buffer;
+  uint8_t *y_buffer = mbd->pre.y_buffer;
+  uint8_t *u_buffer = mbd->pre.u_buffer;
+  uint8_t *v_buffer = mbd->pre.v_buffer;
 
   for (mb_row = 0; mb_row < mb_rows; mb_row++) {
 #if ALT_REF_MC_ENABLED
     // Source frames are extended to 16 pixels.  This is different than
     //  L/A/G reference frames that have a border of 32 (VP9BORDERINPIXELS)
     // A 6/8 tap filter is used for motion search.  This requires 2 pixels
     //  before and 3 pixels after.  So the largest Y mv on a border would
     //  then be 16 - VP9_INTERP_EXTEND. The UV blocks are half the size of the
     //  Y and therefore only extended by 8.  The largest mv that a UV block
     //  can support is 8 - VP9_INTERP_EXTEND.  A UV mv is half of a Y mv.
     //  (16 - VP9_INTERP_EXTEND) >> 1 which is greater than
     //  8 - VP9_INTERP_EXTEND.
     // To keep the mv in play for both Y and UV planes the max that it
     //  can be on a border is therefore 16 - (2*VP9_INTERP_EXTEND+1).
     cpi->mb.mv_row_min = -((mb_row * 16) + (17 - 2 * VP9_INTERP_EXTEND));
     cpi->mb.mv_row_max = ((cpi->common.mb_rows - 1 - mb_row) * 16)
                          + (17 - 2 * VP9_INTERP_EXTEND);
 #endif
 
     for (mb_col = 0; mb_col < mb_cols; mb_col++) {
       int i, j, k;
       int stride;
 
       vpx_memset(accumulator, 0, 384 * sizeof(unsigned int));
-      vpx_memset(count, 0, 384 * sizeof(unsigned short));
+      vpx_memset(count, 0, 384 * sizeof(uint16_t));
 
 #if ALT_REF_MC_ENABLED
       cpi->mb.mv_col_min = -((mb_col * 16) + (17 - 2 * VP9_INTERP_EXTEND));
       cpi->mb.mv_col_max = ((cpi->common.mb_cols - 1 - mb_col) * 16)
                            + (17 - 2 * VP9_INTERP_EXTEND);
 #endif
 
       for (frame = 0; frame < frame_count; frame++) {
         if (cpi->frames[frame] == NULL)
           continue;
@@ skipping 54 matching lines @@
       // Normalize filter output to produce AltRef frame
       dst1 = cpi->alt_ref_buffer.y_buffer;
       stride = cpi->alt_ref_buffer.y_stride;
       byte = mb_y_offset;
       for (i = 0, k = 0; i < 16; i++) {
         for (j = 0; j < 16; j++, k++) {
           unsigned int pval = accumulator[k] + (count[k] >> 1);
           pval *= cpi->fixed_divide[count[k]];
           pval >>= 19;
 
-          dst1[byte] = (unsigned char)pval;
+          dst1[byte] = (uint8_t)pval;
 
           // move to next pixel
           byte++;
         }
 
         byte += stride - 16;
       }
 
       dst1 = cpi->alt_ref_buffer.u_buffer;
       dst2 = cpi->alt_ref_buffer.v_buffer;
       stride = cpi->alt_ref_buffer.uv_stride;
       byte = mb_uv_offset;
       for (i = 0, k = 256; i < 8; i++) {
         for (j = 0; j < 8; j++, k++) {
           int m = k + 64;
 
           // U
           unsigned int pval = accumulator[k] + (count[k] >> 1);
           pval *= cpi->fixed_divide[count[k]];
           pval >>= 19;
-          dst1[byte] = (unsigned char)pval;
+          dst1[byte] = (uint8_t)pval;
 
           // V
           pval = accumulator[m] + (count[m] >> 1);
           pval *= cpi->fixed_divide[count[m]];
           pval >>= 19;
-          dst2[byte] = (unsigned char)pval;
+          dst2[byte] = (uint8_t)pval;
 
           // move to next pixel
           byte++;
         }
 
         byte += stride - 8;
       }
 
       mb_y_offset += 16;
       mb_uv_offset += 8;
@@ skipping 107 matching lines @@
     cpi->frames[frames_to_blur - 1 - frame] = &buf->img;
   }
 
   temporal_filter_iterate_c(
     cpi,
     frames_to_blur,
     frames_to_blur_backward,
     strength);
 }
 #endif