Reversible WHT pair

This commit changed the forward and the inverse 4x4 Walsh Hadamard
transform to a new pair, where the inverse transform can pefectly
reconstuct the input to forward transform. It also does so without
changing the input and output value range. Even more, it does not
change the complexity of the transforms.

While it was not expected to improve the results of our current test,
it does improve std-hd set by 0.2% on all metrics. No change on derf.

Change-Id: Ie4f23ddd3a0f3c5fbe97fb58399f860031f99337

diff --git a/vp8/common/idctllm.c b/vp8/common/idctllm.c
index f0536d5e42bc133d52a0d0d82aeeda4c97503041..b2523ba7cfc3ff6203c2620f45eb774d6b721cc7 100644 (file)
--- a/vp8/common/idctllm.c
+++ b/vp8/common/idctllm.c
@@ -138,65 +138,60 @@ void vp8_short_inv_walsh4x4_c(short *input, short *output)
 {
     int i;
     int a1, b1, c1, d1;
-    int a2, b2, c2, d2;
     short *ip = input;
     short *op = output;
 
     for (i = 0; i < 4; i++)
     {
-        a1 = ip[0] + ip[12];
-        b1 = ip[4] + ip[8];
-        c1 = ip[4] - ip[8];
-        d1 = ip[0] - ip[12];
+        a1 = ((ip[0] + ip[3]));
+        b1 = ((ip[1] + ip[2]));
+        c1 = ((ip[1] - ip[2]));
+        d1 = ((ip[0] - ip[3]));
 
-        op[0] = a1 + b1;
-        op[4] = c1 + d1;
-        op[8] = a1 - b1;
-        op[12] = d1 - c1;
-        ip++;
-        op++;
+        op[0] = (a1 + b1 + 1)>>1;
+        op[1] = (c1 + d1)>>1;
+        op[2] = (a1 - b1)>>1;
+        op[3] = (d1 - c1)>>1;
+
+        ip += 4;
+        op += 4;
     }
 
     ip = output;
     op = output;
-
     for (i = 0; i < 4; i++)
     {
-        a1 = ip[0] + ip[3];
-        b1 = ip[1] + ip[2];
-        c1 = ip[1] - ip[2];
-        d1 = ip[0] - ip[3];
-
-        a2 = a1 + b1;
-        b2 = c1 + d1;
-        c2 = a1 - b1;
-        d2 = d1 - c1;
-
-        op[0] = (a2 + 1) >> 2;
-        op[1] = (b2 + 1) >> 2;
-        op[2] = (c2 + 1) >> 2;
-        op[3] = (d2 + 1) >> 2;
-
-        ip += 4;
-        op += 4;
+        a1 = ip[0] + ip[12];
+        b1 = ip[4] + ip[8];
+        c1 = ip[4] - ip[8];
+        d1 = ip[0] - ip[12];
+        op[0] = (a1 + b1 + 1)>>1;
+        op[4] = (c1 + d1)>>1;
+        op[8] = (a1 - b1)>>1;
+        op[12]= (d1 - c1)>>1;
+        ip++;
+        op++;
     }
 }
 
-void vp8_short_inv_walsh4x4_1_c(short *input, short *output)
+void vp8_short_inv_walsh4x4_1_c(short *in, short *out)
 {
     int i;
-    int a1;
-    short *op = output;
+    short tmp[4];
+    short *ip = in;
+    short *op = tmp;
 
-    a1 = (input[0] + 1 )>> 2;
+    op[0] =(ip[0]+ 1)>>1;
+    op[1] = op[2] = op[3] = (ip[0]>>1);
 
-    for (i = 0; i < 4; i++)
+    ip = tmp;
+    op = out;
+    for(i = 0; i<4; i++)
     {
-        op[0] = a1;
-        op[1] = a1;
-        op[2] = a1;
-        op[3] = a1;
-        op += 4;
+        op[0] =(ip[0]+ 1)>>1;
+        op[4] = op[8] = op[12] = (ip[0]>>1);
+        ip ++;
+        op ++;
     }
 }
 

diff --git a/vp8/encoder/dct.c b/vp8/encoder/dct.c
index c2f2d111768e44f89879d9fe62b5275019ab1bd7..e7505619a7d0cc2953d5f007095e0dd290aaa8bd 100644 (file)
--- a/vp8/encoder/dct.c
+++ b/vp8/encoder/dct.c
@@ -13,10 +13,6 @@
 #include "vpx_ports/config.h"
 
 
-
-
-
-
 void vp8_short_fdct8x8_c(short *block, short *coefs, int pitch)
 {
   int j1, i, j, k;
@@ -181,52 +177,41 @@ void vp8_short_walsh4x4_c(short *input, short *output, int pitch)
 {
     int i;
     int a1, b1, c1, d1;
-    int a2, b2, c2, d2;
     short *ip = input;
     short *op = output;
-
+    int pitch_short = pitch >>1;
 
     for (i = 0; i < 4; i++)
     {
-        a1 = ((ip[0] + ip[2]));
-        d1 = ((ip[1] + ip[3]));
-        c1 = ((ip[1] - ip[3]));
-        b1 = ((ip[0] - ip[2]));
-
-        op[0] = a1 + d1;
-        op[1] = b1 + c1;
-        op[2] = b1 - c1;
-        op[3] = a1 - d1;
-        ip += pitch / 2;
-        op += 4;
-    }
+        a1 = ip[0 * pitch_short] + ip[3 * pitch_short];
+        b1 = ip[1 * pitch_short] + ip[2 * pitch_short];
+        c1 = ip[1 * pitch_short] - ip[2 * pitch_short];
+        d1 = ip[0 * pitch_short] - ip[3 * pitch_short];
 
+        op[0] = (a1 + b1 + 1)>>1;
+        op[4] = (c1 + d1)>>1;
+        op[8] = (a1 - b1)>>1;
+        op[12]= (d1 - c1)>>1;
+
+        ip++;
+        op++;
+    }
     ip = output;
     op = output;
 
     for (i = 0; i < 4; i++)
     {
-        a1 = ip[0] + ip[8];
-        d1 = ip[4] + ip[12];
-        c1 = ip[4] - ip[12];
-        b1 = ip[0] - ip[8];
-
-        a2 = a1 + d1;
-        b2 = b1 + c1;
-        c2 = b1 - c1;
-        d2 = a1 - d1;
-
-        a2 += a2<0;
-        b2 += b2<0;
-        c2 += c2<0;
-        d2 += d2<0;
-
-        op[0] = (a2+1) >> 2;
-        op[4] = (b2+1) >> 2;
-        op[8] = (c2+1) >> 2;
-        op[12]= (d2+1) >> 2;
+        a1 = ip[0] + ip[3];
+        b1 = ip[1] + ip[2];
+        c1 = ip[1] - ip[2];
+        d1 = ip[0] - ip[3];
 
-        ip++;
-        op++;
+        op[0] = (a1 + b1 + 1)>>1;
+        op[1] = (c1 + d1)>>1;
+        op[2] = (a1 - b1)>>1;
+        op[3] = (d1 - c1)>>1;
+
+        ip += 4;
+        op += 4;
     }
 }