Reduced the size of Y1Dequant and friends to [128][2]

This patch removes the local copies of the dequantize
constants and implements John's idea as described
in "Make a local copy of the dequantized data" commit.

Change-Id: Ic6b7d681f00bf63263f71ff1e39ab2f80729e8b2

diff --git a/vp8/common/arm/dequantize_arm.c b/vp8/common/arm/dequantize_arm.c
index 20a8ac4fcbe3bc48adc1ce9f2ef57fa53789e96d..7cf4bf94308b03a5d5e6e705f30fdc8803fb96f0 100644 (file)
--- a/vp8/common/arm/dequantize_arm.c
+++ b/vp8/common/arm/dequantize_arm.c
@@ -23,22 +23,20 @@ extern void vp8_dequantize_b_loop_v6(short *Q, short *DQC, short *DQ);
 
 #if HAVE_ARMV7
 
-void vp8_dequantize_b_neon(BLOCKD *d)
+void vp8_dequantize_b_neon(BLOCKD *d, short *DQC)
 {
     short *DQ  = d->dqcoeff;
     short *Q   = d->qcoeff;
-    short *DQC = d->dequant;
 
     vp8_dequantize_b_loop_neon(Q, DQC, DQ);
 }
 #endif
 
 #if HAVE_ARMV6
-void vp8_dequantize_b_v6(BLOCKD *d)
+void vp8_dequantize_b_v6(BLOCKD *d, short *DQC)
 {
     short *DQ  = d->dqcoeff;
     short *Q   = d->qcoeff;
-    short *DQC = d->dequant;
 
     vp8_dequantize_b_loop_v6(Q, DQC, DQ);
 }

diff --git a/vp8/common/blockd.h b/vp8/common/blockd.h
index 99b731c78d89efe9074613a8121111dc5728d758..85602ba3661b498fca6be121211c1436b9c24dfa 100644 (file)
--- a/vp8/common/blockd.h
+++ b/vp8/common/blockd.h
@@ -209,6 +209,11 @@ typedef struct MacroBlockD
     DECLARE_ALIGNED(16, short, dqcoeff[400]);
     DECLARE_ALIGNED(16, char,  eobs[25]);
 
+    DECLARE_ALIGNED(16, short,  dequant_y1[16]);
+    DECLARE_ALIGNED(16, short,  dequant_y1_dc[16]);
+    DECLARE_ALIGNED(16, short,  dequant_y2[16]);
+    DECLARE_ALIGNED(16, short,  dequant_uv[16]);
+
     /* 16 Y blocks, 4 U, 4 V, 1 DC 2nd order block, each with 16 entries. */
     BLOCKD block[25];
     int fullpixel_mask;

diff --git a/vp8/common/dequantize.c b/vp8/common/dequantize.c
index 4a48a3192af5576ebc0ed5dce8024e567749b6fa..96245162f1ee0f0d7b2b175f235db8879f54ec5b 100644 (file)
--- a/vp8/common/dequantize.c
+++ b/vp8/common/dequantize.c
@@ -14,12 +14,11 @@
 #include "vp8/common/idct.h"
 #include "vpx_mem/vpx_mem.h"
 
-void vp8_dequantize_b_c(BLOCKD *d)
+void vp8_dequantize_b_c(BLOCKD *d, short *DQC)
 {
     int i;
     short *DQ  = d->dqcoeff;
     short *Q   = d->qcoeff;
-    short *DQC = d->dequant;
 
     for (i = 0; i < 16; i++)
     {

diff --git a/vp8/common/dequantize.h b/vp8/common/dequantize.h
index f66cf2bac857b739a3f580c60f0899aebe4ea68c..429359190aa2d0950bce675e34936449c431c888 100644 (file)
--- a/vp8/common/dequantize.h
+++ b/vp8/common/dequantize.h
@@ -14,7 +14,7 @@
 #include "vp8/common/blockd.h"
 
 #define prototype_dequant_block(sym) \
-    void sym(BLOCKD *x)
+    void sym(BLOCKD *x, short *DQC)
 
 #define prototype_dequant_idct_add(sym) \
     void sym(short *input, short *dq, \

diff --git a/vp8/common/invtrans.h b/vp8/common/invtrans.h
index 2bcbeeccfe98a167fe6dfcbd6c856871a904f525..f49e2e5773a933cfe6b590043d832ffb4ce7852e 100644 (file)
--- a/vp8/common/invtrans.h
+++ b/vp8/common/invtrans.h
@@ -36,13 +36,7 @@ static void eob_adjust(char *eobs, short *diff)
 static void vp8_inverse_transform_mby(MACROBLOCKD *xd,
                                       const VP8_COMMON_RTCD *rtcd)
 {
-    short *DQC = xd->block[0].dequant;
-    /* save the dc dequant constant in case it is overridden */
-    short dc_dequant_temp = DQC[0];
-
-#if CONFIG_MULTITHREAD
-    DECLARE_ALIGNED(16, short, local_dequant[16]);
-#endif
+    short *DQC = xd->dequant_y1;
 
     if (xd->mode_info_context->mbmi.mode != SPLITMV)
     {
@@ -59,22 +53,11 @@ static void vp8_inverse_transform_mby(MACROBLOCKD *xd,
         }
         eob_adjust(xd->eobs, xd->qcoeff);
 
-#if CONFIG_MULTITHREAD
-        DQC = local_dequant;
-
-        vpx_memcpy(DQC, xd->block[0].dequant,
-                   sizeof(local_dequant));
-#endif
-
-        /* override the dc dequant constant */
-        DQC[0] = 1;
+        DQC = xd->dequant_y1_dc;
     }
     DEQUANT_INVOKE (&rtcd->dequant, idct_add_y_block)
                     (xd->qcoeff, DQC,
                      xd->dst.y_buffer,
                      xd->dst.y_stride, xd->eobs);
-
-    /* restore the dc dequant constant */
-    DQC[0] = dc_dequant_temp;
 }
 #endif

diff --git a/vp8/common/onyxc_int.h b/vp8/common/onyxc_int.h
index f733ff77416b49fad71f005f066ea18594f0124d..77a0ca2cce3a6ec6bbd8864c2d057762396a3146 100644 (file)
--- a/vp8/common/onyxc_int.h
+++ b/vp8/common/onyxc_int.h
@@ -93,9 +93,9 @@ typedef struct VP8Common
 {
     struct vpx_internal_error_info  error;
 
-    DECLARE_ALIGNED(16, short, Y1dequant[QINDEX_RANGE][16]);
-    DECLARE_ALIGNED(16, short, Y2dequant[QINDEX_RANGE][16]);
-    DECLARE_ALIGNED(16, short, UVdequant[QINDEX_RANGE][16]);
+    DECLARE_ALIGNED(16, short, Y1dequant[QINDEX_RANGE][2]);
+    DECLARE_ALIGNED(16, short, Y2dequant[QINDEX_RANGE][2]);
+    DECLARE_ALIGNED(16, short, UVdequant[QINDEX_RANGE][2]);
 
     int Width;
     int Height;

diff --git a/vp8/common/x86/idct_blk_mmx.c b/vp8/common/x86/idct_blk_mmx.c
index 49cebd6f586c69706f6b1989a7c4c1716a9140d0..8ff4837083d08af9ad7b894a6ba5c2072bc809b2 100644 (file)
--- a/vp8/common/x86/idct_blk_mmx.c
+++ b/vp8/common/x86/idct_blk_mmx.c
@@ -14,12 +14,12 @@
 
 extern void vp8_dequantize_b_impl_mmx(short *sq, short *dq, short *q);
 
-void vp8_dequantize_b_mmx(BLOCKD *d)
+void vp8_dequantize_b_mmx(BLOCKD *d, short *DQC)
 {
     short *sq = (short *) d->qcoeff;
     short *dq = (short *) d->dqcoeff;
-    short *q = (short *) d->dequant;
-    vp8_dequantize_b_impl_mmx(sq, dq, q);
+
+    vp8_dequantize_b_impl_mmx(sq, dq, DQC);
 }
 
 void vp8_dequant_idct_add_y_block_mmx

diff --git a/vp8/decoder/decodframe.c b/vp8/decoder/decodframe.c
index 11d0e38f589cf3a86748dde3ecd7f9073a5e8b1a..917aeceb60af929adcdde5ebe8a5b15e4524d687 100644 (file)
--- a/vp8/decoder/decodframe.c
+++ b/vp8/decoder/decodframe.c
@@ -42,7 +42,6 @@
 
 void vp8cx_init_de_quantizer(VP8D_COMP *pbi)
 {
-    int i;
     int Q;
     VP8_COMMON *const pc = & pbi->common;
 
@@ -52,15 +51,9 @@ void vp8cx_init_de_quantizer(VP8D_COMP *pbi)
         pc->Y2dequant[Q][0] = (short)vp8_dc2quant(Q, pc->y2dc_delta_q);
         pc->UVdequant[Q][0] = (short)vp8_dc_uv_quant(Q, pc->uvdc_delta_q);
 
-        /* all the ac values = ; */
-        for (i = 1; i < 16; i++)
-        {
-            int rc = vp8_default_zig_zag1d[i];
-
-            pc->Y1dequant[Q][rc] = (short)vp8_ac_yquant(Q);
-            pc->Y2dequant[Q][rc] = (short)vp8_ac2quant(Q, pc->y2ac_delta_q);
-            pc->UVdequant[Q][rc] = (short)vp8_ac_uv_quant(Q, pc->uvac_delta_q);
-        }
+        pc->Y1dequant[Q][1] = (short)vp8_ac_yquant(Q);
+        pc->Y2dequant[Q][1] = (short)vp8_ac2quant(Q, pc->y2ac_delta_q);
+        pc->UVdequant[Q][1] = (short)vp8_ac_uv_quant(Q, pc->uvac_delta_q);
     }
 }
 
@@ -88,19 +81,19 @@ void mb_init_dequantizer(VP8D_COMP *pbi, MACROBLOCKD *xd)
     else
         QIndex = pc->base_qindex;
 
-    /* Set up the block level dequant pointers */
-    for (i = 0; i < 16; i++)
-    {
-        xd->block[i].dequant = pc->Y1dequant[QIndex];
-    }
+    /* Set up the macroblock dequant constants */
+    xd->dequant_y1_dc[0] = 1;
+    xd->dequant_y1[0] = pc->Y1dequant[QIndex][0];
+    xd->dequant_y2[0] = pc->Y2dequant[QIndex][0];
+    xd->dequant_uv[0] = pc->UVdequant[QIndex][0];
 
-    for (i = 16; i < 24; i++)
+    for (i = 1; i < 16; i++)
     {
-        xd->block[i].dequant = pc->UVdequant[QIndex];
+        xd->dequant_y1_dc[i] =
+        xd->dequant_y1[i] = pc->Y1dequant[QIndex][1];
+        xd->dequant_y2[i] = pc->Y2dequant[QIndex][1];
+        xd->dequant_uv[i] = pc->UVdequant[QIndex][1];
     }
-
-    xd->block[24].dequant = pc->Y2dequant[QIndex];
-
 }
 
 #if CONFIG_RUNTIME_CPU_DETECT
@@ -180,6 +173,8 @@ static void decode_macroblock(VP8D_COMP *pbi, MACROBLOCKD *xd,
         }
         else
         {
+            short *DQC = xd->dequant_y1;
+
             /* clear out residual eob info */
             if(xd->mode_info_context->mbmi.mb_skip_coeff)
                 vpx_memset(xd->eobs, 0, 25);
@@ -200,13 +195,13 @@ static void decode_macroblock(VP8D_COMP *pbi, MACROBLOCKD *xd,
                     if (xd->eobs[i] > 1)
                     {
                         DEQUANT_INVOKE(&pbi->common.rtcd.dequant, idct_add)
-                            (b->qcoeff, b->dequant,
+                            (b->qcoeff, DQC,
                             *(b->base_dst) + b->dst, b->dst_stride);
                     }
                     else
                     {
                         IDCT_INVOKE(RTCD_VTABLE(idct), idct1_scalar_add)
-                            (b->qcoeff[0] * b->dequant[0],
+                            (b->qcoeff[0] * DQC[0],
                             *(b->base_dst) + b->dst, b->dst_stride,
                             *(b->base_dst) + b->dst, b->dst_stride);
                         ((int *)b->qcoeff)[0] = 0;
@@ -233,10 +228,7 @@ static void decode_macroblock(VP8D_COMP *pbi, MACROBLOCKD *xd,
         /* dequantization and idct */
         if (mode != B_PRED)
         {
-            short *DQC = xd->block[0].dequant;
-
-            /* save the dc dequant constant in case it is overridden */
-            short dc_dequant_temp = DQC[0];
+            short *DQC = xd->dequant_y1;
 
             if (mode != SPLITMV)
             {
@@ -245,7 +237,8 @@ static void decode_macroblock(VP8D_COMP *pbi, MACROBLOCKD *xd,
                 /* do 2nd order transform on the dc block */
                 if (xd->eobs[24] > 1)
                 {
-                    DEQUANT_INVOKE(&pbi->common.rtcd.dequant, block)(b);
+                    DEQUANT_INVOKE(&pbi->common.rtcd.dequant, block)(b,
+                        xd->dequant_y2);
 
                     IDCT_INVOKE(RTCD_VTABLE(idct), iwalsh16)(&b->dqcoeff[0],
                         xd->qcoeff);
@@ -260,7 +253,7 @@ static void decode_macroblock(VP8D_COMP *pbi, MACROBLOCKD *xd,
                 }
                 else
                 {
-                    b->dqcoeff[0] = b->qcoeff[0] * b->dequant[0];
+                    b->dqcoeff[0] = b->qcoeff[0] * xd->dequant_y2[0];
                     IDCT_INVOKE(RTCD_VTABLE(idct), iwalsh1)(&b->dqcoeff[0],
                         xd->qcoeff);
                     ((int *)b->qcoeff)[0] = 0;
@@ -269,20 +262,17 @@ static void decode_macroblock(VP8D_COMP *pbi, MACROBLOCKD *xd,
                 /* override the dc dequant constant in order to preserve the
                  * dc components
                  */
-                DQC[0] = 1;
+                DQC = xd->dequant_y1_dc;
             }
 
             DEQUANT_INVOKE (&pbi->common.rtcd.dequant, idct_add_y_block)
-                            (xd->qcoeff, xd->block[0].dequant,
+                            (xd->qcoeff, DQC,
                              xd->dst.y_buffer,
                              xd->dst.y_stride, xd->eobs);
-
-            /* restore the dc dequant constant */
-            DQC[0] = dc_dequant_temp;
         }
 
         DEQUANT_INVOKE (&pbi->common.rtcd.dequant, idct_add_uv_block)
-                        (xd->qcoeff+16*16, xd->block[16].dequant,
+                        (xd->qcoeff+16*16, xd->dequant_uv,
                          xd->dst.u_buffer, xd->dst.v_buffer,
                          xd->dst.uv_stride, xd->eobs+16);
     }

diff --git a/vp8/decoder/threading.c b/vp8/decoder/threading.c
index 947b3a1c6cdd1dd7821674b0844efb0d3d330257..2ce00f7051a8666ac1839eb3ddc26af254016d9c 100644 (file)
--- a/vp8/decoder/threading.c
+++ b/vp8/decoder/threading.c
@@ -37,7 +37,7 @@ extern void mb_init_dequantizer(VP8D_COMP *pbi, MACROBLOCKD *xd);
 static void setup_decoding_thread_data(VP8D_COMP *pbi, MACROBLOCKD *xd, MB_ROW_DEC *mbrd, int count)
 {
     VP8_COMMON *const pc = & pbi->common;
-    int i, j;
+    int i;
 
     for (i = 0; i < count; i++)
     {
@@ -77,10 +77,10 @@ static void setup_decoding_thread_data(VP8D_COMP *pbi, MACROBLOCKD *xd, MB_ROW_D
 
         mbd->current_bc = &pbi->bc2;
 
-        for (j = 0; j < 25; j++)
-        {
-            mbd->block[j].dequant = xd->block[j].dequant;
-        }
+        vpx_memcpy(mbd->dequant_y1_dc, xd->dequant_y1_dc, sizeof(xd->dequant_y1_dc));
+        vpx_memcpy(mbd->dequant_y1, xd->dequant_y1, sizeof(xd->dequant_y1));
+        vpx_memcpy(mbd->dequant_y2, xd->dequant_y2, sizeof(xd->dequant_y2));
+        vpx_memcpy(mbd->dequant_uv, xd->dequant_uv, sizeof(xd->dequant_uv));
 
         mbd->fullpixel_mask = 0xffffffff;
         if(pc->full_pixel)
@@ -177,6 +177,8 @@ static void decode_macroblock(VP8D_COMP *pbi, MACROBLOCKD *xd, int mb_row, int m
     /* dequantization and idct */
     if (xd->mode_info_context->mbmi.mode == B_PRED)
     {
+        short *DQC = xd->dequant_y1;
+
         for (i = 0; i < 16; i++)
         {
             BLOCKD *b = &xd->block[i];
@@ -190,13 +192,13 @@ static void decode_macroblock(VP8D_COMP *pbi, MACROBLOCKD *xd, int mb_row, int m
                 if (xd->eobs[i] > 1)
                 {
                     DEQUANT_INVOKE(&pbi->common.rtcd.dequant, idct_add)
-                        (b->qcoeff, b->dequant,
+                        (b->qcoeff, DQC,
                         *(b->base_dst) + b->dst, b->dst_stride);
                 }
                 else
                 {
                     IDCT_INVOKE(RTCD_VTABLE(idct), idct1_scalar_add)
-                        (b->qcoeff[0] * b->dequant[0],
+                        (b->qcoeff[0] * DQC[0],
                         *(b->base_dst) + b->dst, b->dst_stride,
                         *(b->base_dst) + b->dst, b->dst_stride);
                     ((int *)b->qcoeff)[0] = 0;
@@ -206,9 +208,7 @@ static void decode_macroblock(VP8D_COMP *pbi, MACROBLOCKD *xd, int mb_row, int m
     }
     else
     {
-        short *DQC = xd->block[0].dequant;
-
-        DECLARE_ALIGNED(16, short, local_dequant[16]);
+        short *DQC = xd->dequant_y1;
 
         if (xd->mode_info_context->mbmi.mode != SPLITMV)
         {
@@ -217,7 +217,7 @@ static void decode_macroblock(VP8D_COMP *pbi, MACROBLOCKD *xd, int mb_row, int m
             /* do 2nd order transform on the dc block */
             if (xd->eobs[24] > 1)
             {
-                DEQUANT_INVOKE(&pbi->common.rtcd.dequant, block)(b);
+                DEQUANT_INVOKE(&pbi->common.rtcd.dequant, block)(b, xd->dequant_y2);
 
                 IDCT_INVOKE(RTCD_VTABLE(idct), iwalsh16)(&b->dqcoeff[0],
                     xd->qcoeff);
@@ -232,20 +232,13 @@ static void decode_macroblock(VP8D_COMP *pbi, MACROBLOCKD *xd, int mb_row, int m
             }
             else
             {
-                b->dqcoeff[0] = b->qcoeff[0] * b->dequant[0];
+                b->dqcoeff[0] = b->qcoeff[0] * xd->dequant_y2[0];
                 IDCT_INVOKE(RTCD_VTABLE(idct), iwalsh1)(&b->dqcoeff[0], xd->qcoeff);
                 ((int *)b->qcoeff)[0] = 0;
             }
 
-            /* make a local copy of the dequant constants */
-            vpx_memcpy(local_dequant, xd->block[0].dequant,
-                       sizeof(local_dequant));
-
             /* override the dc dequant constant */
-            local_dequant[0] = 1;
-
-            /* use the new dequant constants */
-            DQC = local_dequant;
+            DQC = xd->dequant_y1_dc;
         }
 
         DEQUANT_INVOKE (&pbi->common.rtcd.dequant, idct_add_y_block)
@@ -255,7 +248,7 @@ static void decode_macroblock(VP8D_COMP *pbi, MACROBLOCKD *xd, int mb_row, int m
     }
 
     DEQUANT_INVOKE (&pbi->common.rtcd.dequant, idct_add_uv_block)
-                    (xd->qcoeff+16*16, xd->block[16].dequant,
+                    (xd->qcoeff+16*16, xd->dequant_uv,
                      xd->dst.u_buffer, xd->dst.v_buffer,
                      xd->dst.uv_stride, xd->eobs+16);
 }

diff --git a/vp8/encoder/encodeframe.c b/vp8/encoder/encodeframe.c
index 6a9ba291d873b526871eb8fa22f977807c446f08..b5c5c7445b52c4777d5441b8911b982c0725b5b4 100644 (file)
--- a/vp8/encoder/encodeframe.c
+++ b/vp8/encoder/encodeframe.c
@@ -1120,7 +1120,7 @@ int vp8cx_encode_intra_macro_block(VP8_COMP *cpi, MACROBLOCK *x, TOKENEXTRA **t,
         vp8_inverse_transform_mby(xd, IF_RTCD(&cpi->common.rtcd));
 
     DEQUANT_INVOKE (&cpi->common.rtcd.dequant, idct_add_uv_block)
-                    (xd->qcoeff+16*16, xd->block[16].dequant,
+                    (xd->qcoeff+16*16, xd->dequant_uv,
                      xd->dst.u_buffer, xd->dst.v_buffer,
                      xd->dst.uv_stride, xd->eobs+16);
     return rate;
@@ -1305,7 +1305,7 @@ int vp8cx_encode_inter_macroblock
             vp8_inverse_transform_mby(xd, IF_RTCD(&cpi->common.rtcd));
 
         DEQUANT_INVOKE (&cpi->common.rtcd.dequant, idct_add_uv_block)
-                        (xd->qcoeff+16*16, xd->block[16].dequant,
+                        (xd->qcoeff+16*16, xd->dequant_uv,
                          xd->dst.u_buffer, xd->dst.v_buffer,
                          xd->dst.uv_stride, xd->eobs+16);
     }

diff --git a/vp8/encoder/ethreading.c b/vp8/encoder/ethreading.c
index 69655989d11a23c53a180fb8eb34a7df76ddedb9..24339a5e03aada17a01661e1eb32179453802dce 100644 (file)
--- a/vp8/encoder/ethreading.c
+++ b/vp8/encoder/ethreading.c
@@ -384,10 +384,22 @@ static void setup_mbby_copy(MACROBLOCK *mbdst, MACROBLOCK *mbsrc)
         zd->mb_segement_abs_delta      = xd->mb_segement_abs_delta;
         vpx_memcpy(zd->segment_feature_data, xd->segment_feature_data, sizeof(xd->segment_feature_data));
 
-        for (i = 0; i < 25; i++)
-        {
-            zd->block[i].dequant = xd->block[i].dequant;
-        }
+        vpx_memcpy(zd->dequant_y1_dc, xd->dequant_y1_dc, sizeof(xd->dequant_y1_dc));
+        vpx_memcpy(zd->dequant_y1, xd->dequant_y1, sizeof(xd->dequant_y1));
+        vpx_memcpy(zd->dequant_y2, xd->dequant_y2, sizeof(xd->dequant_y2));
+        vpx_memcpy(zd->dequant_uv, xd->dequant_uv, sizeof(xd->dequant_uv));
+
+#if 1
+        /*TODO:  Remove dequant from BLOCKD.  This is a temporary solution until
+         * the quantizer code uses a passed in pointer to the dequant constants.
+         * This will also require modifications to the x86 and neon assembly.
+         * */
+        for (i = 0; i < 16; i++)
+            zd->block[i].dequant = zd->dequant_y1;
+        for (i = 16; i < 24; i++)
+            zd->block[i].dequant = zd->dequant_uv;
+        zd->block[24].dequant = zd->dequant_y2;
+#endif
     }
 }
 

diff --git a/vp8/encoder/quantize.c b/vp8/encoder/quantize.c
index ce04212e62f5448d10208140c36387bf3f361bcd..d2aa7fe7244ecdc7be7078c8f4730b86d264c8a7 100644 (file)
--- a/vp8/encoder/quantize.c
+++ b/vp8/encoder/quantize.c
@@ -504,7 +504,6 @@ void vp8cx_init_quantizer(VP8_COMP *cpi)
             cpi->Y1quant_shift[Q][i] = cpi->Y1quant_shift[Q][1];
             cpi->Y1zbin[Q][i] = cpi->Y1zbin[Q][1];
             cpi->Y1round[Q][i] = cpi->Y1round[Q][1];
-            cpi->common.Y1dequant[Q][i] = cpi->common.Y1dequant[Q][1];
             cpi->zrun_zbin_boost_y1[Q][i] = (cpi->common.Y1dequant[Q][1] *
                                              zbin_boost[i]) >> 7;
 
@@ -513,7 +512,6 @@ void vp8cx_init_quantizer(VP8_COMP *cpi)
             cpi->Y2quant_shift[Q][i] = cpi->Y2quant_shift[Q][1];
             cpi->Y2zbin[Q][i] = cpi->Y2zbin[Q][1];
             cpi->Y2round[Q][i] = cpi->Y2round[Q][1];
-            cpi->common.Y2dequant[Q][i] = cpi->common.Y2dequant[Q][1];
             cpi->zrun_zbin_boost_y2[Q][i] = (cpi->common.Y2dequant[Q][1] *
                                              zbin_boost[i]) >> 7;
 
@@ -522,7 +520,6 @@ void vp8cx_init_quantizer(VP8_COMP *cpi)
             cpi->UVquant_shift[Q][i] = cpi->UVquant_shift[Q][1];
             cpi->UVzbin[Q][i] = cpi->UVzbin[Q][1];
             cpi->UVround[Q][i] = cpi->UVround[Q][1];
-            cpi->common.UVdequant[Q][i] = cpi->common.UVdequant[Q][1];
             cpi->zrun_zbin_boost_uv[Q][i] = (cpi->common.UVdequant[Q][1] *
                                              zbin_boost[i]) >> 7;
         }
@@ -641,6 +638,31 @@ void vp8cx_mb_init_quantizer(VP8_COMP *cpi, MACROBLOCK *x, int ok_to_skip)
      */
     if (!ok_to_skip || QIndex != x->q_index)
     {
+
+        xd->dequant_y1_dc[0] = 1;
+        xd->dequant_y1[0] = cpi->common.Y1dequant[QIndex][0];
+        xd->dequant_y2[0] = cpi->common.Y2dequant[QIndex][0];
+        xd->dequant_uv[0] = cpi->common.UVdequant[QIndex][0];
+
+        for (i = 1; i < 16; i++)
+        {
+            xd->dequant_y1_dc[i] =
+            xd->dequant_y1[i] = cpi->common.Y1dequant[QIndex][1];
+            xd->dequant_y2[i] = cpi->common.Y2dequant[QIndex][1];
+            xd->dequant_uv[i] = cpi->common.UVdequant[QIndex][1];
+        }
+#if 1
+        /*TODO:  Remove dequant from BLOCKD.  This is a temporary solution until
+         * the quantizer code uses a passed in pointer to the dequant constants.
+         * This will also require modifications to the x86 and neon assembly.
+         * */
+        for (i = 0; i < 16; i++)
+            x->e_mbd.block[i].dequant = xd->dequant_y1; //cpi->common.Y1dequant[QIndex];
+        for (i = 16; i < 24; i++)
+            x->e_mbd.block[i].dequant = xd->dequant_uv; //cpi->common.UVdequant[QIndex];
+        x->e_mbd.block[24].dequant = xd->dequant_y2; //cpi->common.Y2dequant[QIndex];
+#endif
+
         // Y
         zbin_extra = ZBIN_EXTRA_Y;
 
@@ -651,7 +673,6 @@ void vp8cx_mb_init_quantizer(VP8_COMP *cpi, MACROBLOCK *x, int ok_to_skip)
             x->block[i].quant_shift = cpi->Y1quant_shift[QIndex];
             x->block[i].zbin = cpi->Y1zbin[QIndex];
             x->block[i].round = cpi->Y1round[QIndex];
-            x->e_mbd.block[i].dequant = cpi->common.Y1dequant[QIndex];
             x->block[i].zrun_zbin_boost = cpi->zrun_zbin_boost_y1[QIndex];
             x->block[i].zbin_extra = (short)zbin_extra;
         }
@@ -666,7 +687,6 @@ void vp8cx_mb_init_quantizer(VP8_COMP *cpi, MACROBLOCK *x, int ok_to_skip)
             x->block[i].quant_shift = cpi->UVquant_shift[QIndex];
             x->block[i].zbin = cpi->UVzbin[QIndex];
             x->block[i].round = cpi->UVround[QIndex];
-            x->e_mbd.block[i].dequant = cpi->common.UVdequant[QIndex];
             x->block[i].zrun_zbin_boost = cpi->zrun_zbin_boost_uv[QIndex];
             x->block[i].zbin_extra = (short)zbin_extra;
         }
@@ -679,7 +699,6 @@ void vp8cx_mb_init_quantizer(VP8_COMP *cpi, MACROBLOCK *x, int ok_to_skip)
         x->block[24].quant_shift = cpi->Y2quant_shift[QIndex];
         x->block[24].zbin = cpi->Y2zbin[QIndex];
         x->block[24].round = cpi->Y2round[QIndex];
-        x->e_mbd.block[24].dequant = cpi->common.Y2dequant[QIndex];
         x->block[24].zrun_zbin_boost = cpi->zrun_zbin_boost_y2[QIndex];
         x->block[24].zbin_extra = (short)zbin_extra;
 
@@ -689,6 +708,9 @@ void vp8cx_mb_init_quantizer(VP8_COMP *cpi, MACROBLOCK *x, int ok_to_skip)
         cpi->last_zbin_over_quant = cpi->zbin_over_quant;
         cpi->last_zbin_mode_boost = cpi->zbin_mode_boost;
         x->last_act_zbin_adj = x->act_zbin_adj;
+
+
+
     }
     else if(cpi->last_zbin_over_quant != cpi->zbin_over_quant
             || cpi->last_zbin_mode_boost != cpi->zbin_mode_boost