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 } 135
