libvpx: Pull from upstream

source/libvpx/vp9/common/vp9_postproc.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 73 matching lines @@
 
 void vp9_post_proc_down_and_across_c(const uint8_t *src_ptr,
                                      uint8_t *dst_ptr,
                                      int src_pixels_per_line,
                                      int dst_pixels_per_line,
                                      int rows,
                                      int cols,
                                      int flimit) {
   uint8_t const *p_src;
   uint8_t *p_dst;
-  int row;
-  int col;
-  int i;
-  int v;
+  int row, col, i, v, kernel;
   int pitch = src_pixels_per_line;
   uint8_t d[8];
   (void)dst_pixels_per_line;
 
   for (row = 0; row < rows; row++) {
     /* post_proc_down for one row */
     p_src = src_ptr;
     p_dst = dst_ptr;
 
     for (col = 0; col < cols; col++) {
-      int kernel = 4;
-      int v = p_src[col];
+      kernel = 4;
+      v = p_src[col];
 
       for (i = -2; i <= 2; i++) {
         if (abs(v - p_src[col + i * pitch]) > flimit)
           goto down_skip_convolve;
 
         kernel += kernel5[2 + i] * p_src[col + i * pitch];
       }
 
       v = (kernel >> 3);
     down_skip_convolve:
       p_dst[col] = v;
     }
 
     /* now post_proc_across */
     p_src = dst_ptr;
     p_dst = dst_ptr;
 
     for (i = 0; i < 8; i++)
       d[i] = p_src[i];
 
     for (col = 0; col < cols; col++) {
-      int kernel = 4;
+      kernel = 4;
       v = p_src[col];
 
       d[col & 7] = v;
 
       for (i = -2; i <= 2; i++) {
         if (abs(v - p_src[col + i]) > flimit)
           goto across_skip_convolve;
 
         kernel += kernel5[2 + i] * p_src[col + i];
       }
@@ skipping 19 matching lines @@
 #if CONFIG_VP9_HIGHBITDEPTH
 void vp9_highbd_post_proc_down_and_across_c(const uint16_t *src_ptr,
                                             uint16_t *dst_ptr,
                                             int src_pixels_per_line,
                                             int dst_pixels_per_line,
                                             int rows,
                                             int cols,
                                             int flimit) {
   uint16_t const *p_src;
   uint16_t *p_dst;
-  int row;
-  int col;
-  int i;
-  int v;
+  int row, col, i, v, kernel;
   int pitch = src_pixels_per_line;
   uint16_t d[8];
 
   for (row = 0; row < rows; row++) {
     // post_proc_down for one row.
     p_src = src_ptr;
     p_dst = dst_ptr;
 
     for (col = 0; col < cols; col++) {
-      int kernel = 4;
-      int v = p_src[col];
+      kernel = 4;
+      v = p_src[col];
 
       for (i = -2; i <= 2; i++) {
         if (abs(v - p_src[col + i * pitch]) > flimit)
           goto down_skip_convolve;
 
         kernel += kernel5[2 + i] * p_src[col + i * pitch];
       }
 
       v = (kernel >> 3);
 
     down_skip_convolve:
       p_dst[col] = v;
     }
 
     /* now post_proc_across */
     p_src = dst_ptr;
     p_dst = dst_ptr;
 
     for (i = 0; i < 8; i++)
       d[i] = p_src[i];
 
     for (col = 0; col < cols; col++) {
-      int kernel = 4;
+      kernel = 4;
       v = p_src[col];
 
       d[col & 7] = v;
 
       for (i = -2; i <= 2; i++) {
         if (abs(v - p_src[col + i]) > flimit)
           goto across_skip_convolve;
 
         kernel += kernel5[2 + i] * p_src[col + i];
       }
@@ skipping 292 matching lines @@
   for (i = 0; i < MAX_MB_PLANE; ++i) {
     const int src_stride = src_strides[i];
     const int src_width = src_widths[i] - 4;
     const int src_height = src_heights[i] - 4;
     const int dst_stride = dst_strides[i];
 
 #if CONFIG_VP9_HIGHBITDEPTH
     assert((src->flags & YV12_FLAG_HIGHBITDEPTH) ==
            (dst->flags & YV12_FLAG_HIGHBITDEPTH));
     if (src->flags & YV12_FLAG_HIGHBITDEPTH) {
-      const uint16_t *const src = CONVERT_TO_SHORTPTR(srcs[i] + 2 * src_stride
-                                                      + 2);
-      uint16_t *const dst = CONVERT_TO_SHORTPTR(dsts[i] + 2 * dst_stride + 2);
-      vp9_highbd_post_proc_down_and_across(src, dst, src_stride, dst_stride,
-                                           src_height, src_width, ppl);
+      const uint16_t *const src_plane = CONVERT_TO_SHORTPTR(
+          srcs[i] + 2 * src_stride + 2);
+      uint16_t *const dst_plane = CONVERT_TO_SHORTPTR(
+          dsts[i] + 2 * dst_stride + 2);
+      vp9_highbd_post_proc_down_and_across(src_plane, dst_plane, src_stride,
+                                           dst_stride, src_height, src_width,
+                                           ppl);
     } else {
-      const uint8_t *const src = srcs[i] + 2 * src_stride + 2;
-      uint8_t *const dst = dsts[i] + 2 * dst_stride + 2;
+      const uint8_t *const src_plane = srcs[i] + 2 * src_stride + 2;
+      uint8_t *const dst_plane = dsts[i] + 2 * dst_stride + 2;
 
-      vp9_post_proc_down_and_across(src, dst, src_stride, dst_stride,
-                                    src_height, src_width, ppl);
+      vp9_post_proc_down_and_across(src_plane, dst_plane, src_stride,
+                                    dst_stride, src_height, src_width, ppl);
     }
 #else
-    const uint8_t *const src = srcs[i] + 2 * src_stride + 2;
-    uint8_t *const dst = dsts[i] + 2 * dst_stride + 2;
-    vp9_post_proc_down_and_across(src, dst, src_stride, dst_stride,
+    const uint8_t *const src_plane = srcs[i] + 2 * src_stride + 2;
+    uint8_t *const dst_plane = dsts[i] + 2 * dst_stride + 2;
+    vp9_post_proc_down_and_across(src_plane, dst_plane, src_stride, dst_stride,
                                   src_height, src_width, ppl);
 #endif
   }
 }
 
 static double gaussian(double sigma, double mu, double x) {
   return 1 / (sigma * sqrt(2.0 * 3.14159265)) *
          (exp(-(x - mu) * (x - mu) / (2 * sigma * sigma)));
 }
 
 static void fillrd(struct postproc_state *state, int q, int a) {
   char char_dist[300];
 
   double sigma;
   int ai = a, qi = q, i;
 
   vp9_clear_system_state();
 
   sigma = ai + .5 + .6 * (63 - qi) / 63.0;
 
   /* set up a lookup table of 256 entries that matches
    * a gaussian distribution with sigma determined by q.
    */
   {
-    double i;
     int next, j;
 
     next = 0;
 
     for (i = -32; i < 32; i++) {
-      int a = (int)(0.5 + 256 * gaussian(sigma, 0, i));
+      int a_i = (int)(0.5 + 256 * gaussian(sigma, 0, i));
 
-      if (a) {
-        for (j = 0; j < a; j++) {
+      if (a_i) {
+        for (j = 0; j < a_i; j++) {
           char_dist[next + j] = (char) i;
         }
 
         next = next + j;
       }
     }
 
     for (; next < 256; next++)
       char_dist[next] = 0;
   }
@@ skipping 68 matching lines @@
 
   // Alloc memory for prev_mip in the first frame.
   if (cm->current_video_frame == 1) {
     cm->postproc_state.last_base_qindex = cm->base_qindex;
     cm->postproc_state.last_frame_valid = 1;
     ppstate->prev_mip = vpx_calloc(cm->mi_alloc_size, sizeof(*cm->mip));
     if (!ppstate->prev_mip) {
       return 1;
     }
     ppstate->prev_mi = ppstate->prev_mip + cm->mi_stride + 1;
-    vpx_memset(ppstate->prev_mip, 0,
-               cm->mi_stride * (cm->mi_rows + 1) * sizeof(*cm->mip));
+    memset(ppstate->prev_mip, 0,
+           cm->mi_stride * (cm->mi_rows + 1) * sizeof(*cm->mip));
   }
 
   // Allocate post_proc_buffer_int if needed.
   if ((flags & VP9D_MFQE) && !cm->post_proc_buffer_int.buffer_alloc) {
     if ((flags & VP9D_DEMACROBLOCK) || (flags & VP9D_DEBLOCK)) {
       const int width = ALIGN_POWER_OF_TWO(cm->width, 4);
       const int height = ALIGN_POWER_OF_TWO(cm->height, 4);
 
       if (vp9_alloc_frame_buffer(&cm->post_proc_buffer_int, width, height,
                                  cm->subsampling_x, cm->subsampling_y,
 #if CONFIG_VP9_HIGHBITDEPTH
                                  cm->use_highbitdepth,
 #endif  // CONFIG_VP9_HIGHBITDEPTH
                                  VP9_ENC_BORDER_IN_PIXELS,
                                  cm->byte_alignment) < 0) {
         vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
                            "Failed to allocate MFQE framebuffer");
       }
 
       // Ensure that postproc is set to all 0s so that post proc
       // doesn't pull random data in from edge.
-      vpx_memset(cm->post_proc_buffer_int.buffer_alloc, 128,
-                 cm->post_proc_buffer.frame_size);
+      memset(cm->post_proc_buffer_int.buffer_alloc, 128,
+             cm->post_proc_buffer.frame_size);
     }
   }
 
   if (vp9_realloc_frame_buffer(&cm->post_proc_buffer, cm->width, cm->height,
                                cm->subsampling_x, cm->subsampling_y,
 #if CONFIG_VP9_HIGHBITDEPTH
                                cm->use_highbitdepth,
 #endif
                                VP9_DEC_BORDER_IN_PIXELS, cm->byte_alignment,
                                NULL, NULL, NULL) < 0)
@@ skipping 49 matching lines @@
   /* handle problem with extending borders */
   dest->y_width = cm->width;
   dest->y_height = cm->height;
   dest->uv_width = dest->y_width >> cm->subsampling_x;
   dest->uv_height = dest->y_height >> cm->subsampling_y;
 
   swap_mi_and_prev_mi(cm);
   return 0;
 }
 #endif  // CONFIG_VP9_POSTPROC