2 * Copyright (c) 2014 The WebM project authors. All Rights Reserved.
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.
12 #include "vpx/vpx_integer.h"
13 #include "vpx_ports/system_state.h"
15 static int horizontal_filter(const uint8_t *s) {
16 return (s[1] - s[-2]) * 2 + (s[-1] - s[0]) * 6;
19 static int vertical_filter(const uint8_t *s, int p) {
20 return (s[p] - s[-2 * p]) * 2 + (s[-p] - s[0]) * 6;
23 static int variance(int sum, int sum_squared, int size) {
24 return sum_squared / size - (sum / size) * (sum / size);
26 // Calculate a blockiness level for a vertical block edge.
27 // This function returns a new blockiness metric that's defined as
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 ;
40 // reconstructed_blockiness = abs(blockiness from reconstructed buffer -
41 // blockiness from source buffer,0)
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,
62 for (i = 0; i < size; ++i, s += sp, r += rp) {
63 s_blockiness += horizontal_filter(s);
64 r_blockiness += horizontal_filter(r);
66 sum_sq_0 += s[0]*s[0];
68 sum_sq_1 += s[-1]*s[-1];
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);
75 if (r_blockiness > s_blockiness)
76 return (r_blockiness - s_blockiness) / (1 + var_0 + var_1);
81 // Calculate a blockiness level for a horizontal block edge
83 static int blockiness_horizontal(const uint8_t *s, int sp, const uint8_t *r,
94 for (i = 0; i < size; ++i, ++s, ++r) {
95 s_blockiness += vertical_filter(s, sp);
96 r_blockiness += vertical_filter(r, rp);
98 sum_sq_0 += s[0] * s[0];
100 sum_sq_1 += s[-sp] * s[-sp];
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);
107 if (r_blockiness > s_blockiness)
108 return (r_blockiness - s_blockiness) / (1 + var_0 + var_1);
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,
117 int width, int height) {
118 double blockiness = 0;
120 vpx_clear_system_state();
121 for (i = 0; i < height; i += 4, img1 += img1_pitch * 4,
122 img2 += img2_pitch * 4) {
123 for (j = 0; j < width; j += 4) {
124 if (i > 0 && i < height && j > 0 && j < width) {
125 blockiness += blockiness_vertical(img1 + j, img1_pitch,
126 img2 + j, img2_pitch, 4);
127 blockiness += blockiness_horizontal(img1 + j, img1_pitch,
128 img2 + j, img2_pitch, 4);
132 blockiness /= width * height / 16;