Merging the hybrid transform experiments

Change-Id: I99f1982b30a630a9a070a8326d83b34a33cba14c

4 files changed, 2 insertions, 123 deletions

diff --git a/vp8/decoder/decodframe.c b/vp8/decoder/decodframe.c
index 01739c0db..cc19985fd 100644
--- a/vp8/decoder/decodframe.c
+++ b/vp8/decoder/decodframe.c
@@ -208,10 +208,7 @@ static void decode_macroblock(VP8D_COMP *pbi, MACROBLOCKD *xd,
   MB_PREDICTION_MODE mode;
   int i;
   int tx_size;
-#if CONFIG_HYBRIDTRANSFORM || CONFIG_HYBRIDTRANSFORM8X8 || \
-    CONFIG_HYBRIDTRANSFORM16X16
   TX_TYPE tx_type;
-#endif
 #if CONFIG_SUPERBLOCKS
   VP8_COMMON *pc = &pbi->common;
   int orig_skip_flag = xd->mode_info_context->mbmi.mb_skip_coeff;
@@ -330,7 +327,6 @@ static void decode_macroblock(VP8D_COMP *pbi, MACROBLOCKD *xd,
       vp8_intra8x8_predict(b, i8x8mode, b->predictor);
 
       if (xd->mode_info_context->mbmi.txfm_size == TX_8X8) {
-#if CONFIG_HYBRIDTRANSFORM8X8
         tx_type = get_tx_type(xd, &xd->block[idx]);
         if (tx_type != DCT_DCT) {
           vp8_ht_dequant_idct_add_8x8_c(tx_type,
@@ -338,9 +334,6 @@ static void decode_macroblock(VP8D_COMP *pbi, MACROBLOCKD *xd,
         } else {
           vp8_dequant_idct_add_8x8_c(q, dq, pre, dst, 16, stride);
         }
-#else
-        vp8_dequant_idct_add_8x8_c(q, dq, pre, dst, 16, stride);
-#endif
         q += 64;
       } else {
         for (j = 0; j < 4; j++) {
@@ -380,7 +373,6 @@ static void decode_macroblock(VP8D_COMP *pbi, MACROBLOCKD *xd,
       }
 #endif
 
-#if CONFIG_HYBRIDTRANSFORM
       tx_type = get_tx_type(xd, b);
       if (tx_type != DCT_DCT) {
         vp8_ht_dequant_idct_add_c(tx_type, b->qcoeff,
@@ -390,18 +382,6 @@ static void decode_macroblock(VP8D_COMP *pbi, MACROBLOCKD *xd,
         vp8_dequant_idct_add_c(b->qcoeff, b->dequant, b->predictor,
                                *(b->base_dst) + b->dst, 16, b->dst_stride);
       }
-#else
-      if (xd->eobs[i] > 1) {
-        DEQUANT_INVOKE(&pbi->dequant, idct_add)
-            (b->qcoeff, b->dequant,  b->predictor,
-             *(b->base_dst) + b->dst, 16, b->dst_stride);
-      } else {
-        IDCT_INVOKE(RTCD_VTABLE(idct), idct1_scalar_add)
-            (b->qcoeff[0] * b->dequant[0], b->predictor,
-             *(b->base_dst) + b->dst, 16, b->dst_stride);
-        ((int *)b->qcoeff)[0] = 0;
-      }
-#endif
     }
   } else if (mode == SPLITMV) {
     DEQUANT_INVOKE(&pbi->dequant, idct_add_y_block)
@@ -412,7 +392,6 @@ static void decode_macroblock(VP8D_COMP *pbi, MACROBLOCKD *xd,
     BLOCKD *b = &xd->block[24];
 
     if (tx_size == TX_16X16) {
-#if CONFIG_HYBRIDTRANSFORM16X16
       BLOCKD *bd = &xd->block[0];
       tx_type = get_tx_type(xd, bd);
       if (tx_type != DCT_DCT) {
@@ -424,11 +403,6 @@ static void decode_macroblock(VP8D_COMP *pbi, MACROBLOCKD *xd,
                                      xd->predictor, xd->dst.y_buffer,
                                      16, xd->dst.y_stride);
       }
-#else
-      vp8_dequant_idct_add_16x16_c(xd->qcoeff, xd->block[0].dequant,
-                                   xd->predictor, xd->dst.y_buffer,
-                                   16, xd->dst.y_stride);
-#endif
     } else if (tx_size == TX_8X8) {
 #if CONFIG_SUPERBLOCKS
       void *orig = xd->mode_info_context;
@@ -900,7 +874,6 @@ static void read_coef_probs(VP8D_COMP *pbi, BOOL_DECODER* const bc) {
           }
         }
   }
-#if CONFIG_HYBRIDTRANSFORM
   {
     if (vp8_read_bit(bc)) {
       /* read coef probability tree */
@@ -920,7 +893,6 @@ static void read_coef_probs(VP8D_COMP *pbi, BOOL_DECODER* const bc) {
           }
         }
   }
-#endif
 
   if (pbi->common.txfm_mode != ONLY_4X4 && vp8_read_bit(bc)) {
     // read coef probability tree
@@ -940,7 +912,6 @@ static void read_coef_probs(VP8D_COMP *pbi, BOOL_DECODER* const bc) {
           }
         }
   }
-#if CONFIG_HYBRIDTRANSFORM8X8
   if (pbi->common.txfm_mode != ONLY_4X4 && vp8_read_bit(bc)) {
     // read coef probability tree
     for (i = 0; i < BLOCK_TYPES_8X8; i++)
@@ -959,7 +930,6 @@ static void read_coef_probs(VP8D_COMP *pbi, BOOL_DECODER* const bc) {
           }
         }
   }
-#endif
 
   // 16x16
   if (pbi->common.txfm_mode > ALLOW_8X8 && vp8_read_bit(bc)) {
@@ -980,7 +950,6 @@ static void read_coef_probs(VP8D_COMP *pbi, BOOL_DECODER* const bc) {
           }
         }
   }
-#if CONFIG_HYBRIDTRANSFORM16X16
   if (pbi->common.txfm_mode > ALLOW_8X8 && vp8_read_bit(bc)) {
     // read coef probability tree
     for (i = 0; i < BLOCK_TYPES_16X16; ++i)
@@ -999,7 +968,6 @@ static void read_coef_probs(VP8D_COMP *pbi, BOOL_DECODER* const bc) {
           }
         }
   }
-#endif
 }
 
 int vp8_decode_frame(VP8D_COMP *pbi) {
@@ -1362,22 +1330,16 @@ int vp8_decode_frame(VP8D_COMP *pbi) {
 
   vp8_copy(pbi->common.fc.pre_coef_probs,
            pbi->common.fc.coef_probs);
-#if CONFIG_HYBRIDTRANSFORM
   vp8_copy(pbi->common.fc.pre_hybrid_coef_probs,
            pbi->common.fc.hybrid_coef_probs);
-#endif
   vp8_copy(pbi->common.fc.pre_coef_probs_8x8,
            pbi->common.fc.coef_probs_8x8);
-#if CONFIG_HYBRIDTRANSFORM8X8
   vp8_copy(pbi->common.fc.pre_hybrid_coef_probs_8x8,
            pbi->common.fc.hybrid_coef_probs_8x8);
-#endif
   vp8_copy(pbi->common.fc.pre_coef_probs_16x16,
            pbi->common.fc.coef_probs_16x16);
-#if CONFIG_HYBRIDTRANSFORM16X16
   vp8_copy(pbi->common.fc.pre_hybrid_coef_probs_16x16,
            pbi->common.fc.hybrid_coef_probs_16x16);
-#endif
   vp8_copy(pbi->common.fc.pre_ymode_prob, pbi->common.fc.ymode_prob);
   vp8_copy(pbi->common.fc.pre_uv_mode_prob, pbi->common.fc.uv_mode_prob);
   vp8_copy(pbi->common.fc.pre_bmode_prob, pbi->common.fc.bmode_prob);
@@ -1391,17 +1353,11 @@ int vp8_decode_frame(VP8D_COMP *pbi) {
   vp8_copy(pbi->common.fc.pre_mvc_hp, pbi->common.fc.mvc_hp);
 #endif
   vp8_zero(pbi->common.fc.coef_counts);
-#if CONFIG_HYBRIDTRANSFORM
   vp8_zero(pbi->common.fc.hybrid_coef_counts);
-#endif
   vp8_zero(pbi->common.fc.coef_counts_8x8);
-#if CONFIG_HYBRIDTRANSFORM8X8
   vp8_zero(pbi->common.fc.hybrid_coef_counts_8x8);
-#endif
   vp8_zero(pbi->common.fc.coef_counts_16x16);
-#if CONFIG_HYBRIDTRANSFORM16X16
   vp8_zero(pbi->common.fc.hybrid_coef_counts_16x16);
-#endif
   vp8_zero(pbi->common.fc.ymode_counts);
   vp8_zero(pbi->common.fc.uv_mode_counts);
   vp8_zero(pbi->common.fc.bmode_counts);
diff --git a/vp8/decoder/dequantize.c b/vp8/decoder/dequantize.c
index e55da754b..db9c3b0b8 100644
--- a/vp8/decoder/dequantize.c
+++ b/vp8/decoder/dequantize.c
@@ -42,7 +42,6 @@ void vp8_dequantize_b_c(BLOCKD *d) {
 }
 
 
-#if CONFIG_HYBRIDTRANSFORM
 void vp8_ht_dequant_idct_add_c(TX_TYPE tx_type, short *input, short *dq,
                                unsigned char *pred, unsigned char *dest,
                                int pitch, int stride) {
@@ -77,9 +76,7 @@ void vp8_ht_dequant_idct_add_c(TX_TYPE tx_type, short *input, short *dq,
       pred += pitch;
   }
 }
-#endif
 
-#if CONFIG_HYBRIDTRANSFORM8X8
 void vp8_ht_dequant_idct_add_8x8_c(TX_TYPE tx_type, short *input, short *dq,
                                    unsigned char *pred, unsigned char *dest,
                                    int pitch, int stride) {
@@ -123,7 +120,6 @@ void vp8_ht_dequant_idct_add_8x8_c(TX_TYPE tx_type, short *input, short *dq,
     pred = origpred + (b + 1) / 2 * 4 * pitch + ((b + 1) % 2) * 4;
   }
 }
-#endif
 
 void vp8_dequant_idct_add_c(short *input, short *dq, unsigned char *pred,
                             unsigned char *dest, int pitch, int stride) {
@@ -468,7 +464,6 @@ void vp8_dequant_dc_idct_add_8x8_c(short *input, short *dq, unsigned char *pred,
 #endif
 }
 
-#if CONFIG_HYBRIDTRANSFORM16X16
 void vp8_ht_dequant_idct_add_16x16_c(TX_TYPE tx_type, short *input, short *dq,
                                      unsigned char *pred, unsigned char *dest,
                                      int pitch, int stride) {
@@ -507,7 +502,6 @@ void vp8_ht_dequant_idct_add_16x16_c(TX_TYPE tx_type, short *input, short *dq,
     pred += pitch;
   }
 }
-#endif
 
 void vp8_dequant_idct_add_16x16_c(short *input, short *dq, unsigned char *pred,
                                   unsigned char *dest, int pitch, int stride) {
diff --git a/vp8/decoder/dequantize.h b/vp8/decoder/dequantize.h
index 5b7b21598..4ac710431 100644
--- a/vp8/decoder/dequantize.h
+++ b/vp8/decoder/dequantize.h
@@ -76,7 +76,6 @@ extern prototype_dequant_block(vp8_dequant_block);
 #endif
 extern prototype_dequant_idct_add(vp8_dequant_idct_add);
 
-#if CONFIG_HYBRIDTRANSFORM
 // declare dequantization and inverse transform module of hybrid transform decoder
 #ifndef vp8_ht_dequant_idct_add
 #define vp8_ht_dequant_idct_add vp8_ht_dequant_idct_add_c
@@ -85,7 +84,6 @@ extern void vp8_ht_dequant_idct_add(TX_TYPE tx_type, short *input, short *dq,
                                     unsigned char *pred, unsigned char *dest,
                                     int pitch, int stride);
 
-#endif
 
 #ifndef vp8_dequant_dc_idct_add
 #define vp8_dequant_dc_idct_add vp8_dequant_dc_idct_add_c
@@ -191,17 +189,13 @@ typedef struct {
 #define DEQUANT_INVOKE(ctx,fn) vp8_dequant_##fn
 #endif
 
-#if CONFIG_HYBRIDTRANSFORM8X8
 void vp8_ht_dequant_idct_add_8x8_c(TX_TYPE tx_type, short *input, short *dq,
                                    unsigned char *pred, unsigned char *dest,
                                    int pitch, int stride);
-#endif
 
-#if CONFIG_HYBRIDTRANSFORM16X16
 void vp8_ht_dequant_idct_add_16x16_c(TX_TYPE tx_type, short *input, short *dq,
                                      unsigned char *pred, unsigned char *dest,
                                      int pitch, int stride);
-#endif
 
 #if CONFIG_SUPERBLOCKS
 void vp8_dequant_dc_idct_add_y_block_8x8_inplace_c(short *q, short *dq,
diff --git a/vp8/decoder/detokenize.c b/vp8/decoder/detokenize.c
index 85f213470..0e5e54418 100644
--- a/vp8/decoder/detokenize.c
+++ b/vp8/decoder/detokenize.c
@@ -135,7 +135,6 @@ int get_token(int v) {
   else return DCT_VAL_CATEGORY6;
 }
 
-#if CONFIG_HYBRIDTRANSFORM
 void static count_tokens_adaptive_scan(const MACROBLOCKD *xd, INT16 *qcoeff_ptr,
                                        int block, PLANE_TYPE type,
                                        TX_TYPE tx_type,
@@ -180,7 +179,6 @@ void static count_tokens_adaptive_scan(const MACROBLOCKD *xd, INT16 *qcoeff_ptr,
       fc->coef_counts[type][band][pt][DCT_EOB_TOKEN]++;
   }
 }
-#endif
 
 void static count_tokens(INT16 *qcoeff_ptr, int block, PLANE_TYPE type,
                          ENTROPY_CONTEXT *a, ENTROPY_CONTEXT *l,
@@ -202,9 +200,7 @@ void static count_tokens(INT16 *qcoeff_ptr, int block, PLANE_TYPE type,
 }
 
 void static count_tokens_8x8(INT16 *qcoeff_ptr, int block, PLANE_TYPE type,
-#if CONFIG_HYBRIDTRANSFORM8X8
                              TX_TYPE tx_type,
-#endif
                              ENTROPY_CONTEXT *a, ENTROPY_CONTEXT *l,
                              int eob, int seg_eob, FRAME_CONTEXT *fc) {
   int c, pt, token, band;
@@ -214,29 +210,23 @@ void static count_tokens_8x8(INT16 *qcoeff_ptr, int block, PLANE_TYPE type,
     int v = qcoeff_ptr[rc];
     band = (type == 1 ? vp8_coef_bands[c] : vp8_coef_bands_8x8[c]);
     token = get_token(v);
-#if CONFIG_HYBRIDTRANSFORM8X8
     if (tx_type != DCT_DCT)
       fc->hybrid_coef_counts_8x8[type][band][pt][token]++;
     else
-#endif
       fc->coef_counts_8x8[type][band][pt][token]++;
     pt = vp8_prev_token_class[token];
   }
   if (eob < seg_eob) {
     band = (type == 1 ? vp8_coef_bands[c] : vp8_coef_bands_8x8[c]);
-#if CONFIG_HYBRIDTRANSFORM8X8
     if (tx_type != DCT_DCT)
       fc->hybrid_coef_counts_8x8[type][band][pt][DCT_EOB_TOKEN]++;
     else
-#endif
       fc->coef_counts_8x8[type][band][pt][DCT_EOB_TOKEN]++;
   }
 }
 
 void static count_tokens_16x16(INT16 *qcoeff_ptr, int block, PLANE_TYPE type,
-#if CONFIG_HYBRIDTRANSFORM16X16
                                TX_TYPE tx_type,
-#endif
                                ENTROPY_CONTEXT *a, ENTROPY_CONTEXT *l,
                                int eob, int seg_eob, FRAME_CONTEXT *fc) {
   int c, pt, token;
@@ -246,21 +236,17 @@ void static count_tokens_16x16(INT16 *qcoeff_ptr, int block, PLANE_TYPE type,
     int v = qcoeff_ptr[rc];
     int band = vp8_coef_bands_16x16[c];
     token = get_token(v);
-#if CONFIG_HYBRIDTRANSFORM16X16
     if (tx_type != DCT_DCT)
       fc->hybrid_coef_counts_16x16[type][band][pt][token]++;
     else
-#endif
       fc->coef_counts_16x16[type][band][pt][token]++;
     pt = vp8_prev_token_class[token];
   }
   if (eob < seg_eob) {
     int band = vp8_coef_bands_16x16[c];
-#if CONFIG_HYBRIDTRANSFORM16X16
     if (tx_type != DCT_DCT)
       fc->hybrid_coef_counts_16x16[type][band][pt][DCT_EOB_TOKEN]++;
     else
-#endif
       fc->coef_counts_16x16[type][band][pt][DCT_EOB_TOKEN]++;
   }
 }
@@ -306,9 +292,7 @@ static int decode_coefs(VP8D_COMP *dx, const MACROBLOCKD *xd,
                         BOOL_DECODER* const br,
                         ENTROPY_CONTEXT *a, ENTROPY_CONTEXT *l,
                         PLANE_TYPE type,
-#if CONFIG_HYBRIDTRANSFORM8X8 || CONFIG_HYBRIDTRANSFORM || CONFIG_HYBRIDTRANSFORM16X16
                         TX_TYPE tx_type,
-#endif
                         int seg_eob, INT16 *qcoeff_ptr, int i,
                         const int *const scan, int block_type,
                         const int *coef_bands) {
@@ -320,23 +304,17 @@ static int decode_coefs(VP8D_COMP *dx, const MACROBLOCKD *xd,
     default:
     case TX_4X4:
       coef_probs =
-#if CONFIG_HYBRIDTRANSFORM
         tx_type != DCT_DCT ? fc->hybrid_coef_probs[type][0][0] :
-#endif
         fc->coef_probs[type][0][0];
       break;
     case TX_8X8:
       coef_probs =
-#if CONFIG_HYBRIDTRANSFORM8X8
         tx_type != DCT_DCT ? fc->hybrid_coef_probs_8x8[type][0][0] :
-#endif
         fc->coef_probs_8x8[type][0][0];
       break;
     case TX_16X16:
       coef_probs =
-#if CONFIG_HYBRIDTRANSFORM16X16
         tx_type != DCT_DCT ? fc->hybrid_coef_probs_16x16[type][0][0] :
-#endif
         fc->coef_probs_16x16[type][0][0];
       break;
   }
@@ -422,26 +400,17 @@ SKIP_START:
   }
 
   if (block_type == TX_4X4) {
-#if CONFIG_HYBRIDTRANSFORM
     count_tokens_adaptive_scan(xd, qcoeff_ptr, i, type,
                                tx_type,
                                a, l, c, seg_eob, fc);
-#else
-    count_tokens(qcoeff_ptr, i, type,
-                 a, l, c, seg_eob, fc);
-#endif
   }
   else if (block_type == TX_8X8)
     count_tokens_8x8(qcoeff_ptr, i, type,
-#if CONFIG_HYBRIDTRANSFORM8X8
                      tx_type,
-#endif
                      a, l, c, seg_eob, fc);
   else
     count_tokens_16x16(qcoeff_ptr, i, type,
-#if CONFIG_HYBRIDTRANSFORM16X16
                        tx_type,
-#endif
                        a, l, c, seg_eob, fc);
   return c;
 }
@@ -457,12 +426,7 @@ int vp8_decode_mb_tokens_16x16(VP8D_COMP *pbi, MACROBLOCKD *xd,
   const int segment_id = xd->mode_info_context->mbmi.segment_id;
   const int seg_active = segfeature_active(xd, segment_id, SEG_LVL_EOB);
   INT16 *qcoeff_ptr = &xd->qcoeff[0];
-#if CONFIG_HYBRIDTRANSFORM8X8 || CONFIG_HYBRIDTRANSFORM || CONFIG_HYBRIDTRANSFORM16X16
-  TX_TYPE tx_type = DCT_DCT;
-#endif
-#if CONFIG_HYBRIDTRANSFORM16X16
-  tx_type = get_tx_type(xd, &xd->block[0]);
-#endif
+  TX_TYPE tx_type = get_tx_type(xd, &xd->block[0]);
 
   type = PLANE_TYPE_Y_WITH_DC;
 
@@ -475,9 +439,7 @@ int vp8_decode_mb_tokens_16x16(VP8D_COMP *pbi, MACROBLOCKD *xd,
   {
     const int* const scan = vp8_default_zig_zag1d_16x16;
     c = decode_coefs(pbi, xd, bc, A, L, type,
-#if CONFIG_HYBRIDTRANSFORM8X8 || CONFIG_HYBRIDTRANSFORM || CONFIG_HYBRIDTRANSFORM16X16
                      tx_type,
-#endif
                      seg_eob, qcoeff_ptr,
                      0, scan, TX_16X16, coef_bands_x_16x16);
     eobs[0] = c;
@@ -492,9 +454,7 @@ int vp8_decode_mb_tokens_16x16(VP8D_COMP *pbi, MACROBLOCKD *xd,
   // 8x8 chroma blocks
   qcoeff_ptr += 256;
   type = PLANE_TYPE_UV;
-#if CONFIG_HYBRIDTRANSFORM8X8 || CONFIG_HYBRIDTRANSFORM || CONFIG_HYBRIDTRANSFORM16X16
   tx_type = DCT_DCT;
-#endif
   if (seg_active)
     seg_eob = get_segdata(xd, segment_id, SEG_LVL_EOB);
   else
@@ -505,9 +465,7 @@ int vp8_decode_mb_tokens_16x16(VP8D_COMP *pbi, MACROBLOCKD *xd,
     const int* const scan = vp8_default_zig_zag1d_8x8;
 
     c = decode_coefs(pbi, xd, bc, a, l, type,
-#if CONFIG_HYBRIDTRANSFORM8X8 || CONFIG_HYBRIDTRANSFORM || CONFIG_HYBRIDTRANSFORM16X16
                      tx_type,
-#endif
                      seg_eob, qcoeff_ptr,
                      i, scan, TX_8X8, coef_bands_x_8x8);
     a[0] = l[0] = ((eobs[i] = c) != !type);
@@ -533,9 +491,7 @@ int vp8_decode_mb_tokens_8x8(VP8D_COMP *pbi, MACROBLOCKD *xd,
   const int segment_id = xd->mode_info_context->mbmi.segment_id;
   const int seg_active = segfeature_active(xd, segment_id, SEG_LVL_EOB);
   INT16 *qcoeff_ptr = &xd->qcoeff[0];
-#if CONFIG_HYBRIDTRANSFORM8X8 || CONFIG_HYBRIDTRANSFORM || CONFIG_HYBRIDTRANSFORM16X16
   TX_TYPE tx_type = DCT_DCT;
-#endif
 
   int bufthred = (xd->mode_info_context->mbmi.mode == I8X8_PRED) ? 16 : 24;
   if (xd->mode_info_context->mbmi.mode != B_PRED &&
@@ -551,9 +507,7 @@ int vp8_decode_mb_tokens_8x8(VP8D_COMP *pbi, MACROBLOCKD *xd,
     else
       seg_eob = 4;
     c = decode_coefs(pbi, xd, bc, a, l, type,
-#if CONFIG_HYBRIDTRANSFORM8X8 || CONFIG_HYBRIDTRANSFORM || CONFIG_HYBRIDTRANSFORM16X16
                      tx_type,
-#endif
                      seg_eob, qcoeff_ptr + 24 * 16,
                      24, scan, TX_8X8, coef_bands_x);
     a[0] = l[0] = ((eobs[24] = c) != !type);
@@ -573,22 +527,16 @@ int vp8_decode_mb_tokens_8x8(VP8D_COMP *pbi, MACROBLOCKD *xd,
     ENTROPY_CONTEXT *const a = A + vp8_block2above_8x8[i];
     ENTROPY_CONTEXT *const l = L + vp8_block2left_8x8[i];
     const int *const scan = vp8_default_zig_zag1d_8x8;
-#if CONFIG_HYBRIDTRANSFORM8X8 || CONFIG_HYBRIDTRANSFORM || CONFIG_HYBRIDTRANSFORM16X16
     tx_type = DCT_DCT;
-#endif
 
     if (i == 16)
       type = PLANE_TYPE_UV;
-#if CONFIG_HYBRIDTRANSFORM8X8
     if (type == PLANE_TYPE_Y_WITH_DC) {
       tx_type = get_tx_type(xd, xd->block + i);
     }
-#endif
 
     c = decode_coefs(pbi, xd, bc, a, l, type,
-#if CONFIG_HYBRIDTRANSFORM8X8 || CONFIG_HYBRIDTRANSFORM || CONFIG_HYBRIDTRANSFORM16X16
                      tx_type,
-#endif
                      seg_eob, qcoeff_ptr,
                      i, scan, TX_8X8, coef_bands_x_8x8);
     a[0] = l[0] = ((eobs[i] = c) != !type);
@@ -601,9 +549,7 @@ int vp8_decode_mb_tokens_8x8(VP8D_COMP *pbi, MACROBLOCKD *xd,
 
   if (bufthred == 16) {
     type = PLANE_TYPE_UV;
-#if CONFIG_HYBRIDTRANSFORM8X8 || CONFIG_HYBRIDTRANSFORM || CONFIG_HYBRIDTRANSFORM16X16
     tx_type = DCT_DCT;
-#endif
     seg_eob = 16;
 
     // use 4x4 transform for U, V components in I8X8 prediction mode
@@ -613,9 +559,7 @@ int vp8_decode_mb_tokens_8x8(VP8D_COMP *pbi, MACROBLOCKD *xd,
       const int *scan = vp8_default_zig_zag1d;
 
       c = decode_coefs(pbi, xd, bc, a, l, type,
-#if CONFIG_HYBRIDTRANSFORM8X8 || CONFIG_HYBRIDTRANSFORM || CONFIG_HYBRIDTRANSFORM16X16
                        tx_type,
-#endif
                        seg_eob, qcoeff_ptr,
                        i, scan, TX_4X4, coef_bands_x);
       a[0] = l[0] = ((eobs[i] = c) != !type);
@@ -652,9 +596,7 @@ int vp8_decode_mb_tokens(VP8D_COMP *dx, MACROBLOCKD *xd,
     type = PLANE_TYPE_Y2;
 
     c = decode_coefs(dx, xd, bc, a, l, type,
-#if CONFIG_HYBRIDTRANSFORM8X8 || CONFIG_HYBRIDTRANSFORM || CONFIG_HYBRIDTRANSFORM16X16
                      DCT_DCT,
-#endif
                      seg_eob, qcoeff_ptr + 24 * 16, 24,
                      scan, TX_4X4, coef_bands_x);
     a[0] = l[0] = ((eobs[24] = c) != !type);
@@ -668,13 +610,10 @@ int vp8_decode_mb_tokens(VP8D_COMP *dx, MACROBLOCKD *xd,
   for (i = 0; i < 24; ++i) {
     ENTROPY_CONTEXT *const a = A + vp8_block2above[i];
     ENTROPY_CONTEXT *const l = L + vp8_block2left[i];
-#if CONFIG_HYBRIDTRANSFORM8X8 || CONFIG_HYBRIDTRANSFORM || CONFIG_HYBRIDTRANSFORM16X16
     TX_TYPE tx_type = DCT_DCT;
-#endif
     if (i == 16)
       type = PLANE_TYPE_UV;
 
-#if CONFIG_HYBRIDTRANSFORM
     tx_type = get_tx_type(xd, &xd->block[i]);
     switch(tx_type) {
       case ADST_DCT :
@@ -689,12 +628,8 @@ int vp8_decode_mb_tokens(VP8D_COMP *dx, MACROBLOCKD *xd,
         scan = vp8_default_zig_zag1d;
         break;
     }
-#endif
 
-    c = decode_coefs(dx, xd, bc, a, l, type,
-#if CONFIG_HYBRIDTRANSFORM8X8 || CONFIG_HYBRIDTRANSFORM || CONFIG_HYBRIDTRANSFORM16X16
-                     tx_type,
-#endif
+    c = decode_coefs(dx, xd, bc, a, l, type, tx_type,
                      seg_eob, qcoeff_ptr,
                      i, scan, TX_4X4, coef_bands_x);
     a[0] = l[0] = ((eobs[i] = c) != !type);