diff --git a/vp8/common/blockd.c b/vp8/common/blockd.c
index 661a77fe5..843a19635 100644
--- a/vp8/common/blockd.c
+++ b/vp8/common/blockd.c
@@ -22,7 +22,7 @@ const unsigned char vp8_block2above[25] =
     0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 4, 5, 4, 5, 6, 7, 6, 7, 8
 };
 
-
+#if CONFIG_T8X8
 const unsigned char vp8_block2left_8x8[25] =
 {
     0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 2, 2, 2, 4, 4, 4, 4, 6, 6, 6, 6, 8
@@ -31,6 +31,6 @@ const unsigned char vp8_block2above_8x8[25] =
 {
     0, 0, 0, 0, 2, 2, 2, 2, 0, 0, 0, 0, 2, 2, 2, 2, 4, 4, 4, 4, 6, 6, 6, 6, 8
 };
-
+#endif
 
 
diff --git a/vp8/common/blockd.h b/vp8/common/blockd.h
index 7850fb065..16bfc4c99 100644
--- a/vp8/common/blockd.h
+++ b/vp8/common/blockd.h
@@ -72,11 +72,6 @@ extern const unsigned char vp8_block2above_8x8[25];
 #define VP8_COMBINEENTROPYCONTEXTS( Dest, A, B) \
     Dest = ((A)!=0) + ((B)!=0);
 
-#if CONFIG_T8X8
-#define VP8_COMBINEENTROPYCONTEXTS_8x8( Dest, A1, B1, A2, B2) \
-    Dest = ((A1)!=0 || (A2)!=0) + ((B1)!=0 || (B2)!=0);
-#endif
-
 typedef enum
 {
     KEY_FRAME = 0,
diff --git a/vp8/common/generic/systemdependent.c b/vp8/common/generic/systemdependent.c
index fcee14c41..90ff889fa 100644
--- a/vp8/common/generic/systemdependent.c
+++ b/vp8/common/generic/systemdependent.c
@@ -32,10 +32,8 @@ void vp8_machine_specific_config(VP8_COMMON *ctx)
     rtcd->idct.iwalsh16     = vp8_short_inv_walsh4x4_c;
 #if CONFIG_T8X8
     rtcd->idct.idct8        = vp8_short_idct8x8_c;
-    rtcd->idct.idct8_1      = vp8_short_idct8x8_1_c;
     rtcd->idct.idct1_scalar_add_8x8 = vp8_dc_only_idct_add_8x8_c;
     rtcd->idct.ihaar2       = vp8_short_ihaar2x2_c;
-    rtcd->idct.ihaar2_1     = vp8_short_ihaar2x2_1_c;
 #endif
     rtcd->recon.copy16x16   = vp8_copy_mem16x16_c;
     rtcd->recon.copy8x8     = vp8_copy_mem8x8_c;
diff --git a/vp8/common/idctllm.c b/vp8/common/idctllm.c
index 8097c4fb1..c87012466 100644
--- a/vp8/common/idctllm.c
+++ b/vp8/common/idctllm.c
@@ -201,35 +201,11 @@ void vp8_short_inv_walsh4x4_1_c(short *input, short *output)
 }
 
 #if CONFIG_T8X8
-
-#define FAST_IDCT_8X8
-
-void vp8_short_idct8x8_1_c(short *input, short *output, int pitch)
+void vp8_dc_only_idct_add_8x8_c(short input_dc,
+                                unsigned char *pred_ptr,
+                                unsigned char *dst_ptr,
+                                int pitch, int stride)
 {
-    int i, b;
-    int a1;
-    short *op = output;
-    short *orig_op = output;
-    int shortpitch = pitch >> 1;
-    //a1 = ((input[0] + 4) >> 3);
-    a1 = ((input[0] + 16) >> 5);
-    for (b = 0; b < 4; b++)
-    {
-        for (i = 0; i < 4; i++)
-        {
-            op[0] = a1;
-            op[1] = a1;
-            op[2] = a1;
-            op[3] = a1;
-            op += shortpitch;
-        }
-        op = orig_op + (b+1)%2*4 +(b+1)/2*4*shortpitch;
-    }
-}
-
-void vp8_dc_only_idct_add_8x8_c(short input_dc, unsigned char *pred_ptr, unsigned char *dst_ptr, int pitch, int stride)
-{
-    //int a1 = ((input_dc + 4) >> 3);
     int a1 = ((input_dc + 16) >> 5);
     int r, c, b;
     unsigned char *orig_pred = pred_ptr;
@@ -259,8 +235,6 @@ void vp8_dc_only_idct_add_8x8_c(short input_dc, unsigned char *pred_ptr, unsigne
     }
 }
 
-#ifdef FAST_IDCT_8X8
-
 #define W1 2841                 /* 2048*sqrt(2)*cos(1*pi/16) */
 #define W2 2676                 /* 2048*sqrt(2)*cos(2*pi/16) */
 #define W3 2408                 /* 2048*sqrt(2)*cos(3*pi/16) */
@@ -277,53 +251,53 @@ void vp8_dc_only_idct_add_8x8_c(short input_dc, unsigned char *pred_ptr, unsigne
 
 static void idctrow (int *blk)
 {
-  int x0, x1, x2, x3, x4, x5, x6, x7, x8;
-
-  /* shortcut */
-  if (!((x1 = blk[4] << 11) | (x2 = blk[6]) | (x3 = blk[2]) |
+    int x0, x1, x2, x3, x4, x5, x6, x7, x8;
+    /* shortcut */
+    if (!((x1 = blk[4] << 11) | (x2 = blk[6]) | (x3 = blk[2]) |
         (x4 = blk[1]) | (x5 = blk[7]) | (x6 = blk[5]) | (x7 = blk[3])))
-  {
-    blk[0] = blk[1] = blk[2] = blk[3] = blk[4] = blk[5] = blk[6] = blk[7] = blk[0] << 3;
-    return;
-  }
-  x0 = (blk[0] << 11) + 128;    /* for proper rounding in the fourth stage */
+    {
+        blk[0] = blk[1] = blk[2] = blk[3] = blk[4]
+        = blk[5] = blk[6] = blk[7] = blk[0] << 3;
+        return;
+    }
 
-  /* first stage */
-  x8 = W7 * (x4 + x5);
-  x4 = x8 + (W1 - W7) * x4;
-  x5 = x8 - (W1 + W7) * x5;
-  x8 = W3 * (x6 + x7);
-  x6 = x8 - (W3 - W5) * x6;
-  x7 = x8 - (W3 + W5) * x7;
+    x0 = (blk[0] << 11) + 128;    /* for proper rounding in the fourth stage */
+    /* first stage */
+    x8 = W7 * (x4 + x5);
+    x4 = x8 + (W1 - W7) * x4;
+    x5 = x8 - (W1 + W7) * x5;
+    x8 = W3 * (x6 + x7);
+    x6 = x8 - (W3 - W5) * x6;
+    x7 = x8 - (W3 + W5) * x7;
 
-  /* second stage */
-  x8 = x0 + x1;
-  x0 -= x1;
-  x1 = W6 * (x3 + x2);
-  x2 = x1 - (W2 + W6) * x2;
-  x3 = x1 + (W2 - W6) * x3;
-  x1 = x4 + x6;
-  x4 -= x6;
-  x6 = x5 + x7;
-  x5 -= x7;
+    /* second stage */
+    x8 = x0 + x1;
+    x0 -= x1;
+    x1 = W6 * (x3 + x2);
+    x2 = x1 - (W2 + W6) * x2;
+    x3 = x1 + (W2 - W6) * x3;
+    x1 = x4 + x6;
+    x4 -= x6;
+    x6 = x5 + x7;
+    x5 -= x7;
 
-  /* third stage */
-  x7 = x8 + x3;
-  x8 -= x3;
-  x3 = x0 + x2;
-  x0 -= x2;
-  x2 = (181 * (x4 + x5) + 128) >> 8;
-  x4 = (181 * (x4 - x5) + 128) >> 8;
+    /* third stage */
+    x7 = x8 + x3;
+    x8 -= x3;
+    x3 = x0 + x2;
+    x0 -= x2;
+    x2 = (181 * (x4 + x5) + 128) >> 8;
+    x4 = (181 * (x4 - x5) + 128) >> 8;
 
-  /* fourth stage */
-  blk[0] = (x7 + x1) >> 8;
-  blk[1] = (x3 + x2) >> 8;
-  blk[2] = (x0 + x4) >> 8;
-  blk[3] = (x8 + x6) >> 8;
-  blk[4] = (x8 - x6) >> 8;
-  blk[5] = (x0 - x4) >> 8;
-  blk[6] = (x3 - x2) >> 8;
-  blk[7] = (x7 - x1) >> 8;
+    /* fourth stage */
+    blk[0] = (x7 + x1) >> 8;
+    blk[1] = (x3 + x2) >> 8;
+    blk[2] = (x0 + x4) >> 8;
+    blk[3] = (x8 + x6) >> 8;
+    blk[4] = (x8 - x6) >> 8;
+    blk[5] = (x0 - x4) >> 8;
+    blk[6] = (x3 - x2) >> 8;
+    blk[7] = (x7 - x1) >> 8;
 }
 
 /* column (vertical) IDCT
@@ -334,59 +308,61 @@ static void idctrow (int *blk)
  * where: c[0]    = 1/1024 c[1..7] = (1/1024)*sqrt(2) */
 static void idctcol (int *blk)
 {
-  int x0, x1, x2, x3, x4, x5, x6, x7, x8;
+    int x0, x1, x2, x3, x4, x5, x6, x7, x8;
 
-  /* shortcut */
-  if (!((x1 = (blk[8 * 4] << 8)) | (x2 = blk[8 * 6]) | (x3 = blk[8 * 2]) |
-        (x4 = blk[8 * 1]) | (x5 = blk[8 * 7]) | (x6 = blk[8 * 5]) | (x7 = blk[8 * 3])))
-  {
-    blk[8 * 0] = blk[8 * 1] = blk[8 * 2] = blk[8 * 3] = blk[8 * 4] = blk[8 * 5] = blk[8 * 6] = blk[8 * 7] =
-      ((blk[8 * 0] + 32) >> 6);
-    return;
-  }
-  x0 = (blk[8 * 0] << 8) + 16384;
+    /* shortcut */
+    if (!((x1 = (blk[8 * 4] << 8)) | (x2 = blk[8 * 6]) | (x3 = blk[8 * 2]) |
+        (x4 = blk[8 * 1]) | (x5 = blk[8 * 7]) | (x6 = blk[8 * 5]) |
+        (x7 = blk[8 * 3])))
+    {
+        blk[8 * 0] = blk[8 * 1] = blk[8 * 2] = blk[8 * 3]
+                   = blk[8 * 4] = blk[8 * 5] = blk[8 * 6]
+                   = blk[8 * 7] = ((blk[8 * 0] + 32) >>6);
+        return;
+    }
 
-  /* first stage */
-  x8 = W7 * (x4 + x5) + 4;
-  x4 = (x8 + (W1 - W7) * x4) >> 3;
-  x5 = (x8 - (W1 + W7) * x5) >> 3;
-  x8 = W3 * (x6 + x7) + 4;
-  x6 = (x8 - (W3 - W5) * x6) >> 3;
-  x7 = (x8 - (W3 + W5) * x7) >> 3;
+    x0 = (blk[8 * 0] << 8) + 16384;
 
-  /* second stage */
-  x8 = x0 + x1;
-  x0 -= x1;
-  x1 = W6 * (x3 + x2) + 4;
-  x2 = (x1 - (W2 + W6) * x2) >> 3;
-  x3 = (x1 + (W2 - W6) * x3) >> 3;
-  x1 = x4 + x6;
-  x4 -= x6;
-  x6 = x5 + x7;
-  x5 -= x7;
+    /* first stage */
+    x8 = W7 * (x4 + x5) + 4;
+    x4 = (x8 + (W1 - W7) * x4) >> 3;
+    x5 = (x8 - (W1 + W7) * x5) >> 3;
+    x8 = W3 * (x6 + x7) + 4;
+    x6 = (x8 - (W3 - W5) * x6) >> 3;
+    x7 = (x8 - (W3 + W5) * x7) >> 3;
 
-  /* third stage */
-  x7 = x8 + x3;
-  x8 -= x3;
-  x3 = x0 + x2;
-  x0 -= x2;
-  x2 = (181 * (x4 + x5) + 128) >> 8;
-  x4 = (181 * (x4 - x5) + 128) >> 8;
+    /* second stage */
+    x8 = x0 + x1;
+    x0 -= x1;
+    x1 = W6 * (x3 + x2) + 4;
+    x2 = (x1 - (W2 + W6) * x2) >> 3;
+    x3 = (x1 + (W2 - W6) * x3) >> 3;
+    x1 = x4 + x6;
+    x4 -= x6;
+    x6 = x5 + x7;
+    x5 -= x7;
 
-  /* fourth stage */
-  blk[8 * 0] = (x7 + x1 ) >> 14;
-  blk[8 * 1] = (x3 + x2 ) >> 14;
-  blk[8 * 2] = (x0 + x4 ) >> 14;
-  blk[8 * 3] = (x8 + x6 ) >> 14;
-  blk[8 * 4] = (x8 - x6 ) >> 14;
-  blk[8 * 5] = (x0 - x4 ) >> 14;
-  blk[8 * 6] = (x3 - x2 ) >> 14;
-  blk[8 * 7] = (x7 - x1 ) >> 14;
+    /* third stage */
+    x7 = x8 + x3;
+    x8 -= x3;
+    x3 = x0 + x2;
+    x0 -= x2;
+    x2 = (181 * (x4 + x5) + 128) >> 8;
+    x4 = (181 * (x4 - x5) + 128) >> 8;
+
+    /* fourth stage */
+    blk[8 * 0] = (x7 + x1 ) >> 14;
+    blk[8 * 1] = (x3 + x2 ) >> 14;
+    blk[8 * 2] = (x0 + x4 ) >> 14;
+    blk[8 * 3] = (x8 + x6 ) >> 14;
+    blk[8 * 4] = (x8 - x6 ) >> 14;
+    blk[8 * 5] = (x0 - x4 ) >> 14;
+    blk[8 * 6] = (x3 - x2 ) >> 14;
+    blk[8 * 7] = (x7 - x1 ) >> 14;
 }
 
 #define TX_DIM 8
 void vp8_short_idct8x8_c(short *coefs, short *block, int pitch)
-// an approximate 8x8 dct implementation, but not used
 {
     int X[TX_DIM*TX_DIM];
     int i,j;
@@ -396,87 +372,25 @@ void vp8_short_idct8x8_c(short *coefs, short *block, int pitch)
     {
         for (j = 0; j < TX_DIM; j++)
         {
-             X[i * TX_DIM + j] = (int)(coefs[i * TX_DIM + j]+1
-                                    + (coefs[i * TX_DIM + j]<0))>>2;
+            X[i * TX_DIM + j] = (int)(coefs[i * TX_DIM + j]+1
+                + (coefs[i * TX_DIM + j]<0))>>2;
         }
     }
-  for (i = 0; i < 8; i++)
-    idctrow (X + 8 * i);
+    for (i = 0; i < 8; i++)
+        idctrow (X + 8 * i);
 
-  for (i = 0; i < 8; i++)
-    idctcol (X + i);
+    for (i = 0; i < 8; i++)
+        idctcol (X + i);
 
     for (i = 0; i < TX_DIM; i++)
     {
         for (j = 0; j < TX_DIM; j++)
         {
-             block[i*shortpitch+j]  = X[i * TX_DIM + j]>>1;
+            block[i*shortpitch+j]  = X[i * TX_DIM + j]>>1;
         }
     }
 }
 
-#else
-
-/* This is really for testing */
-void vp8_short_idct8x8_c(short *input, short *output, int pitch)
-{
-    int X[8][8];
-    double C[8][8]={{0.0}}, Ct[8][8]={{0.0}}, temp[8][8]={{0.0}};
-    int i,j,k;
-    double temp1=0.0;
-    double pi = atan( 1.0 ) * 4.0;
-    //static int count=0;
-
-    int shortpitch = pitch >> 1;
-
-    for (i = 0; i < 8; i++)
-    {
-        for (j = 0; j < 8; j++)
-        {
-             X[i][j] = input[i * 8 + j];
-        }
-     }
-
-    // TODO: DCT matrix should be calculated once for all
-    for ( j = 0 ; j < 8 ; j++ ) {
-        C[ 0 ][ j ] = 1.0 / sqrt( (double) 8 );
-        Ct[ j ][ 0 ] = C[ 0 ][ j ];
-    }
-    for ( i = 1 ; i < 8 ; i++ ) {
-        for ( j = 0 ; j < 8 ; j++ ) {
-            C[ i ][ j ] = sqrt( 2.0 / 8 ) *
-                          cos( pi * ( 2 * j + 1 ) * i / ( 2.0 * 8 ) );
-            Ct[ j ][ i ] = C[ i ][ j ];
-        }
-    }
-    /*  MatrixMultiply( temp, input, C ); */
-        for ( i = 0 ; i < 8 ; i++ ) {
-            for ( j = 0 ; j < 8 ; j++ ) {
-                temp[ i ][ j ] = 0.0;
-                for ( k = 0 ; k < 8 ; k++ )
-                    temp[ i ][ j ] += X[ i ][ k ] * C[ k ][ j ];
-            }
-        }
-
-    /*  MatrixMultiply( output, Ct, temp ); */
-        for ( i = 0 ; i < 8 ; i++ ) {
-            for ( j = 0 ; j < 8 ; j++ ) {
-                temp1 = 0.0;
-                for ( k = 0 ; k < 8 ; k++ )
-                    temp1 += Ct[ i ][ k ] * temp[ k ][ j ];
-                X[ i ][ j ] = floor( temp1/ 2.0 + 0.5);
-            }
-        }
-
-    for (i = 0; i < 8; i++)
-    {
-        for (j = 0; j < 8; j++)
-        {
-             output[i*shortpitch+j]  = X[i][j];
-        }
-    }
-}
-#endif
 
 void vp8_short_ihaar2x2_c(short *input, short *output, int pitch)
 {
@@ -494,16 +408,4 @@ void vp8_short_ihaar2x2_c(short *input, short *output, int pitch)
    op[8] = (ip[0] - ip[1] - ip[4] + ip[8])>>1;
 }
 
-void vp8_short_ihaar2x2_1_c(short *input, short *output, int pitch)
-{
-   int a1;
-   short *ip = input;
-   short *op = output;
-   a1 = ip[0]>> 2;
-   op[0] = a1;
-   op[2] = a1;
-   op[8] = a1;
-   op[10] = a1;
-
-}
 #endif
diff --git a/vp8/encoder/encodemb.h b/vp8/encoder/encodemb.h
index e0fcb644f..995ce4f0a 100644
--- a/vp8/encoder/encodemb.h
+++ b/vp8/encoder/encodemb.h
@@ -106,6 +106,7 @@ void vp8_encode_inter16x16y(const struct VP8_ENCODER_RTCD *rtcd, MACROBLOCK *x);
 
 #if CONFIG_T8X8
 void vp8_transform_mb_8x8(MACROBLOCK *mb);
+void vp8_transform_mby_8x8(MACROBLOCK *x);
 void vp8_transform_mbuv_8x8(MACROBLOCK *x);
 void vp8_transform_intra_mby_8x8(MACROBLOCK *x);
 void vp8_build_dcblock_8x8(MACROBLOCK *b);