granicus.if.org Git - libvpx/blob - vp9/encoder/vp9_blockiness.c

   1 /*
   2  *  Copyright (c) 2014 The WebM project authors. All Rights Reserved.
   3  *
   4  *  Use of this source code is governed by a BSD-style license
   5  *  that can be found in the LICENSE file in the root of the source
   6  *  tree. An additional intellectual property rights grant can be found
   7  *  in the file PATENTS.  All contributing project authors may
   8  *  be found in the AUTHORS file in the root of the source tree.
   9  */
  10 #include <stdlib.h>
  11
  12 #include "vpx/vpx_integer.h"
  13 #include "vpx_ports/system_state.h"
  14
  15 static int horizontal_filter(const uint8_t *s) {
  16   return (s[1] - s[-2]) * 2 + (s[-1] - s[0]) * 6;
  17 }
  18
  19 static int vertical_filter(const uint8_t *s, int p) {
  20   return (s[p] - s[-2 * p]) * 2 + (s[-p] - s[0]) * 6;
  21 }
  22
  23 static int variance(int sum, int sum_squared, int size) {
  24   return sum_squared / size - (sum / size) * (sum / size);
  25 }
  26 // Calculate a blockiness level for a vertical block edge.
  27 // This function returns a new blockiness metric that's defined as
  28
  29 //              p0 p1 p2 p3
  30 //              q0 q1 q2 q3
  31 // block edge ->
  32 //              r0 r1 r2 r3
  33 //              s0 s1 s2 s3
  34
  35 // blockiness =  p0*-2+q0*6+r0*-6+s0*2 +
  36 //               p1*-2+q1*6+r1*-6+s1*2 +
  37 //               p2*-2+q2*6+r2*-6+s2*2 +
  38 //               p3*-2+q3*6+r3*-6+s3*2 ;
  39
  40 // reconstructed_blockiness = abs(blockiness from reconstructed buffer -
  41 //                                blockiness from source buffer,0)
  42 //
  43 // I make the assumption that flat blocks are much more visible than high
  44 // contrast blocks. As such, I scale the result of the blockiness calc
  45 // by dividing the blockiness by the variance of the pixels on either side
  46 // of the edge as follows:
  47 // var_0 = (q0^2+q1^2+q2^2+q3^2) - ((q0 + q1 + q2 + q3) / 4 )^2
  48 // var_1 = (r0^2+r1^2+r2^2+r3^2) - ((r0 + r1 + r2 + r3) / 4 )^2
  49 // The returned blockiness is the scaled value
  50 // Reconstructed blockiness / ( 1 + var_0 + var_1 ) ;
  51 static int blockiness_vertical(const uint8_t *s, int sp, const uint8_t *r,
  52                                int rp, int size) {
  53   int s_blockiness = 0;
  54   int r_blockiness = 0;
  55   int sum_0 = 0;
  56   int sum_sq_0 = 0;
  57   int sum_1 = 0;
  58   int sum_sq_1 = 0;
  59   int i;
  60   int var_0;
  61   int var_1;
  62   for (i = 0; i < size; ++i, s += sp, r += rp) {
  63     s_blockiness += horizontal_filter(s);
  64     r_blockiness += horizontal_filter(r);
  65     sum_0 += s[0];
  66     sum_sq_0 += s[0] * s[0];
  67     sum_1 += s[-1];
  68     sum_sq_1 += s[-1] * s[-1];
  69   }
  70   var_0 = variance(sum_0, sum_sq_0, size);
  71   var_1 = variance(sum_1, sum_sq_1, size);
  72   r_blockiness = abs(r_blockiness);
  73   s_blockiness = abs(s_blockiness);
  74
  75   if (r_blockiness > s_blockiness)
  76     return (r_blockiness - s_blockiness) / (1 + var_0 + var_1);
  77   else
  78     return 0;
  79 }
  80
  81 // Calculate a blockiness level for a horizontal block edge
  82 // same as above.
  83 static int blockiness_horizontal(const uint8_t *s, int sp, const uint8_t *r,
  84                                  int rp, int size) {
  85   int s_blockiness = 0;
  86   int r_blockiness = 0;
  87   int sum_0 = 0;
  88   int sum_sq_0 = 0;
  89   int sum_1 = 0;
  90   int sum_sq_1 = 0;
  91   int i;
  92   int var_0;
  93   int var_1;
  94   for (i = 0; i < size; ++i, ++s, ++r) {
  95     s_blockiness += vertical_filter(s, sp);
  96     r_blockiness += vertical_filter(r, rp);
  97     sum_0 += s[0];
  98     sum_sq_0 += s[0] * s[0];
  99     sum_1 += s[-sp];
 100     sum_sq_1 += s[-sp] * s[-sp];
 101   }
 102   var_0 = variance(sum_0, sum_sq_0, size);
 103   var_1 = variance(sum_1, sum_sq_1, size);
 104   r_blockiness = abs(r_blockiness);
 105   s_blockiness = abs(s_blockiness);
 106
 107   if (r_blockiness > s_blockiness)
 108     return (r_blockiness - s_blockiness) / (1 + var_0 + var_1);
 109   else
 110     return 0;
 111 }
 112
 113 // This function returns the blockiness for the entire frame currently by
 114 // looking at all borders in steps of 4.
 115 double vp9_get_blockiness(const uint8_t *img1, int img1_pitch,
 116                           const uint8_t *img2, int img2_pitch, int width,
 117                           int height) {
 118   double blockiness = 0;
 119   int i, j;
 120   vpx_clear_system_state();
 121   for (i = 0; i < height;
 122        i += 4, img1 += img1_pitch * 4, img2 += img2_pitch * 4) {
 123     for (j = 0; j < width; j += 4) {
 124       if (i > 0 && i < height && j > 0 && j < width) {
 125         blockiness +=
 126             blockiness_vertical(img1 + j, img1_pitch, img2 + j, img2_pitch, 4);
 127         blockiness += blockiness_horizontal(img1 + j, img1_pitch, img2 + j,
 128                                             img2_pitch, 4);
 129       }
 130     }
 131   }
 132   blockiness /= width * height / 16;
 133   return blockiness;
 134 }