libvpx: Pull from upstream

source/libvpx/vp9/encoder/vp9_blockiness.c

 /*
  *  Copyright (c) 2014 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 <stdlib.h>
 
-#include "./vp9_rtcd.h"
-#include "./vpx_config.h"
-#include "./vpx_dsp_rtcd.h"
-#include "vp9/common/vp9_common.h"
-#include "vp9/common/vp9_filter.h"
 #include "vpx/vpx_integer.h"
-#include "vpx_dsp/vpx_convolve.h"
-#include "vpx_dsp/vpx_filter.h"
-#include "vpx_ports/mem.h"
+#include "vpx_ports/system_state.h"
 
 static int horizontal_filter(const uint8_t *s) {
   return (s[1] - s[-2]) * 2 + (s[-1] - s[0]) * 6;
 }
 
 static int vertical_filter(const uint8_t *s, int p) {
   return (s[p] - s[-2 * p]) * 2 + (s[-p] - s[0]) * 6;
 }
 
 static int variance(int sum, int sum_squared, int size) {
@@ skipping 17 matching lines @@
 //                                blockiness from source buffer,0)
 //
 // I make the assumption that flat blocks are much more visible than high
 // contrast blocks. As such, I scale the result of the blockiness calc
 // by dividing the blockiness by the variance of the pixels on either side
 // of the edge as follows:
 // var_0 = (q0^2+q1^2+q2^2+q3^2) - ((q0 + q1 + q2 + q3) / 4 )^2
 // var_1 = (r0^2+r1^2+r2^2+r3^2) - ((r0 + r1 + r2 + r3) / 4 )^2
 // The returned blockiness is the scaled value
 // Reconstructed blockiness / ( 1 + var_0 + var_1 ) ;
-int blockiness_vertical(const uint8_t *s, int sp, const uint8_t *r, int rp,
-                        int size) {
+static int blockiness_vertical(const uint8_t *s, int sp, const uint8_t *r,
+                               int rp, int size) {
   int s_blockiness = 0;
   int r_blockiness = 0;
   int sum_0 = 0;
   int sum_sq_0 = 0;
   int sum_1 = 0;
   int sum_sq_1 = 0;
   int i;
   int var_0;
   int var_1;
   for (i = 0; i < size; ++i, s += sp, r += rp) {
@@ skipping 10 matching lines @@
   s_blockiness = abs(s_blockiness);
 
   if (r_blockiness > s_blockiness)
     return (r_blockiness - s_blockiness) / (1 + var_0 + var_1);
   else
     return 0;
 }
 
 // Calculate a blockiness level for a horizontal block edge
 // same as above.
-int blockiness_horizontal(const uint8_t *s, int sp, const uint8_t *r, int rp,
-                          int size) {
+static int blockiness_horizontal(const uint8_t *s, int sp, const uint8_t *r,
+                                 int rp, int size) {
   int s_blockiness = 0;
   int r_blockiness = 0;
   int sum_0 = 0;
   int sum_sq_0 = 0;
   int sum_1 = 0;
   int sum_sq_1 = 0;
   int i;
   int var_0;
   int var_1;
   for (i = 0; i < size; ++i, ++s, ++r) {
@@ skipping 10 matching lines @@
   s_blockiness = abs(s_blockiness);
 
   if (r_blockiness > s_blockiness)
     return (r_blockiness - s_blockiness) / (1 + var_0 + var_1);
   else
     return 0;
 }
 
 // This function returns the blockiness for the entire frame currently by
 // looking at all borders in steps of 4.
-double vp9_get_blockiness(const unsigned char *img1, int img1_pitch,
-                          const unsigned char *img2, int img2_pitch,
-                          int width, int height ) {
+double vp9_get_blockiness(const uint8_t *img1, int img1_pitch,
+                          const uint8_t *img2, int img2_pitch,
+                          int width, int height) {
   double blockiness = 0;
   int i, j;
-  vp9_clear_system_state();
+  vpx_clear_system_state();
   for (i = 0; i < height; i += 4, img1 += img1_pitch * 4,
        img2 += img2_pitch * 4) {
     for (j = 0; j < width; j += 4) {
       if (i > 0 && i < height && j > 0 && j < width) {
         blockiness += blockiness_vertical(img1 + j, img1_pitch,
                                           img2 + j, img2_pitch, 4);
         blockiness += blockiness_horizontal(img1 + j, img1_pitch,
                                             img2 + j, img2_pitch, 4);
       }
     }
   }
   blockiness /= width * height / 16;
   return blockiness;
 }