Changes to CONFIG_NEW_QUANT experiment.

Added dq_off_index attribute to mbmi to allow for switching between
dequantization modes.
Reduced number of different dequantization modes from 5 to 3.
Changed dequant_val_nuq to be allow for 3 dequant levels instead of 1.
Fixed lint errors

Change-Id: I7aee3548011aa4eee18adb09d835051c3108d2ee

diff --git a/vp9/common/vp9_blockd.h b/vp9/common/vp9_blockd.h
index 2736417b8bd3860a38122a254bd9c1f8e28089bd..b4fa43482b10217cff8997db52f6507ceb62196e 100644 (file)
--- a/vp9/common/vp9_blockd.h
+++ b/vp9/common/vp9_blockd.h
@@ -76,6 +76,11 @@ extern "C" {
 #define COMP_REFS 2
 #endif  // CONFIG_MULTI_REF
 
+#if CONFIG_NEW_QUANT
+#define QUANT_PROFILES 3
+#define DEFAULT_DQ 0
+#endif  // CONFIG_NEW_QUANT
+
 typedef enum {
   PLANE_TYPE_Y  = 0,
   PLANE_TYPE_UV = 1,
@@ -299,6 +304,9 @@ typedef struct {
   uint8_t palette_literal_colors[PALETTE_MAX_SIZE];
 #endif  // CONFIG_VP9_HIGHBITDEPTH
 #endif  // CONFIG_PALETTE
+#if CONFIG_NEW_QUANT
+  int dq_off_index;
+#endif  // CONFIG_NEW_QUANT
 } MB_MODE_INFO;
 
 typedef struct MODE_INFO {
@@ -366,12 +374,12 @@ struct macroblockd_plane {
   struct buf_2d pre[2];
   const int16_t *dequant;
 #if CONFIG_NEW_QUANT
-  const dequant_val_type_nuq *dequant_val_nuq;
+  const dequant_val_type_nuq* dequant_val_nuq[QUANT_PROFILES];
 #endif  // CONFIG_NEW_QUANT
 #if CONFIG_TX_SKIP
   const int16_t *dequant_pxd;
 #if CONFIG_NEW_QUANT
-  const dequant_val_type_nuq *dequant_val_nuq_pxd;
+  const dequant_val_type_nuq* dequant_val_nuq_pxd[QUANT_PROFILES];
 #endif  // CONFIG_NEW_QUANT
 #endif  // CONFIG_TX_SKIP
   ENTROPY_CONTEXT *above_context;

diff --git a/vp9/common/vp9_onyxc_int.h b/vp9/common/vp9_onyxc_int.h
index af632d67a24b9638c676b5c3571a8b53f678ffe3..e44aae9716b646fc7599ad5eae746298549b5914 100644 (file)
--- a/vp9/common/vp9_onyxc_int.h
+++ b/vp9/common/vp9_onyxc_int.h
@@ -47,6 +47,10 @@ extern "C" {
 #define FRAME_CONTEXTS_LOG2 2
 #define FRAME_CONTEXTS (1 << FRAME_CONTEXTS_LOG2)
 
+#if CONFIG_NEW_QUANT
+#define QUANT_PROFILES 3
+#endif  // CONFIG_NEW_QUANT
+
 extern const struct {
   PARTITION_CONTEXT above;
   PARTITION_CONTEXT left;
@@ -73,9 +77,9 @@ typedef struct VP9Common {
   DECLARE_ALIGNED(16, int16_t, uv_dequant[QINDEX_RANGE][8]);
 #if CONFIG_NEW_QUANT
   DECLARE_ALIGNED(16, dequant_val_type_nuq,
-                  y_dequant_val_nuq[QINDEX_RANGE][COEF_BANDS]);
+                  y_dequant_val_nuq[QUANT_PROFILES][QINDEX_RANGE][COEF_BANDS]);
   DECLARE_ALIGNED(16, dequant_val_type_nuq,
-                  uv_dequant_val_nuq[QINDEX_RANGE][COEF_BANDS]);
+                  uv_dequant_val_nuq[QUANT_PROFILES][QINDEX_RANGE][COEF_BANDS]);
 #endif  // CONFIG_NEW_QUANT
 
 #if CONFIG_TX_SKIP
@@ -83,9 +87,11 @@ typedef struct VP9Common {
   DECLARE_ALIGNED(16, int16_t, uv_dequant_pxd[QINDEX_RANGE][8]);
 #if CONFIG_NEW_QUANT
   DECLARE_ALIGNED(16, dequant_val_type_nuq,
-                  y_dequant_val_nuq_pxd[QINDEX_RANGE][COEF_BANDS]);
+                  y_dequant_val_nuq_pxd[QUANT_PROFILES][QINDEX_RANGE]
+                                       [COEF_BANDS]);
   DECLARE_ALIGNED(16, dequant_val_type_nuq,
-                  uv_dequant_val_nuq_pxd[QINDEX_RANGE][COEF_BANDS]);
+                  uv_dequant_val_nuq_pxd[QUANT_PROFILES][QINDEX_RANGE]
+                                        [COEF_BANDS]);
 #endif  // CONFIG_NEW_QUANT
 #endif  // CONFIG_TX_SKIP
 

diff --git a/vp9/common/vp9_quant_common.c b/vp9/common/vp9_quant_common.c
index 78a7fa274af54ca4bdc7f03cc3ee51eb5c2d5664..dfd2c6bde33ed31b9a03b70bf4c0af81ddfb1cda 100644 (file)
--- a/vp9/common/vp9_quant_common.c
+++ b/vp9/common/vp9_quant_common.c
@@ -41,28 +41,6 @@ static const uint8_t vp9_nuq_knots_lossless[COEF_BANDS][NUQ_KNOTS] = {
 #endif  // CONFIG_TX_SKIP
 };
 
-static const uint8_t vp9_nuq_knots_tiny[COEF_BANDS][NUQ_KNOTS] = {
-  {84, 124, 128},  // dc, band 0
-  {84, 124, 128},  // band 1
-  {84, 124, 128},  // band 2
-  {86, 124, 128},  // band 3
-  {86, 124, 128},  // band 4
-  {86, 124, 128},  // band 5
-#if CONFIG_TX_SKIP
-  {84, 124, 128},  // band 6
-#endif  // CONFIG_TX_SKIP
-};
-static const uint8_t vp9_nuq_knots_low[COEF_BANDS][NUQ_KNOTS] = {
-  {84, 124, 128},  // dc, band 0
-  {84, 124, 128},  // band 1
-  {84, 124, 128},  // band 2
-  {86, 124, 128},  // band 3
-  {86, 124, 128},  // band 4
-  {86, 124, 128},  // band 5
-#if CONFIG_TX_SKIP
-  {84, 124, 128},  // band 6
-#endif  // CONFIG_TX_SKIP
-};
 static const uint8_t vp9_nuq_knots_mid[COEF_BANDS][NUQ_KNOTS] = {
   {84, 124, 128},  // dc, band 0
   {84, 124, 128},  // band 1
@@ -74,40 +52,13 @@ static const uint8_t vp9_nuq_knots_mid[COEF_BANDS][NUQ_KNOTS] = {
   {84, 124, 128},  // band 6
 #endif  // CONFIG_TX_SKIP
 };
-static const uint8_t vp9_nuq_knots_high[COEF_BANDS][NUQ_KNOTS] = {
-  {84, 124, 128},  // dc, band 0
-  {84, 124, 128},  // band 1
-  {84, 124, 128},  // band 2
-  {86, 124, 128},  // band 3
-  {86, 124, 128},  // band 4
-  {86, 124, 128},  // band 5
-#if CONFIG_TX_SKIP
-  {84, 124, 128},  // band 6
-#endif  // CONFIG_TX_SKIP
-};
-static const uint8_t vp9_nuq_knots_huge[COEF_BANDS][NUQ_KNOTS] = {
-  {84, 124, 128},  // dc, band 0
-  {84, 124, 128},  // band 1
-  {84, 124, 128},  // band 2
-  {86, 124, 128},  // band 3
-  {86, 124, 128},  // band 4
-  {86, 124, 128},  // band 5
-#if CONFIG_TX_SKIP
-  {84, 124, 128},  // band 6
-#endif  // CONFIG_TX_SKIP
-};
 
 static const uint8_t vp9_nuq_doff_lossless[COEF_BANDS] = { 0, 0, 0, 0, 0, 0
 #if CONFIG_TX_SKIP
     , 0
 #endif  // CONFIG_TX_SKIP
 };
-static const uint8_t vp9_nuq_doff_tiny[COEF_BANDS] = { 8, 16, 17, 22, 23, 24
-#if CONFIG_TX_SKIP
-    , 8
-#endif  // CONFIG_TX_SKIP
-};
-static const uint8_t vp9_nuq_doff_low[COEF_BANDS] =  { 8, 16, 17, 22, 23, 24
+static const uint8_t vp9_nuq_doff_low[COEF_BANDS] =  { 5, 13, 14, 19, 20, 21
 #if CONFIG_TX_SKIP
     , 8
 #endif  // CONFIG_TX_SKIP
@@ -117,12 +68,7 @@ static const uint8_t vp9_nuq_doff_mid[COEF_BANDS] =  { 8, 16, 17, 22, 23, 24
     , 8
 #endif  // CONFIG_TX_SKIP
 };
-static const uint8_t vp9_nuq_doff_high[COEF_BANDS] = { 8, 16, 17, 22, 23, 24
-#if CONFIG_TX_SKIP
-    , 8
-#endif  // CONFIG_TX_SKIP
-};
-static const uint8_t vp9_nuq_doff_huge[COEF_BANDS] = { 8, 16, 17, 22, 23, 24
+static const uint8_t vp9_nuq_doff_high[COEF_BANDS] = { 41, 49, 50, 55, 56, 57
 #if CONFIG_TX_SKIP
     , 8
 #endif  // CONFIG_TX_SKIP
@@ -131,43 +77,28 @@ static const uint8_t vp9_nuq_doff_huge[COEF_BANDS] = { 8, 16, 17, 22, 23, 24
 // Allow different quantization profiles in different q ranges,
 // to enable entropy-constraints in scalar quantization.
 
-static const uint8_t *get_nuq_knots(int16_t quant, int lossless,
-                                     int band, int bd) {
-  const int shift = bd - 8;
+static const uint8_t *get_nuq_knots(int lossless, int band) {
   if (lossless)
     return vp9_nuq_knots_lossless[band];
-  if (quant > (512 << shift))
-    return vp9_nuq_knots_huge[band];
-  else if (quant > (256 << shift))
-    return vp9_nuq_knots_high[band];
-  else if (quant > (128 << shift))
-    return vp9_nuq_knots_mid[band];
-  else if (quant > (64 << shift))
-    return vp9_nuq_knots_low[band];
   else
-    return vp9_nuq_knots_tiny[band];
+    return vp9_nuq_knots_mid[band];
 }
 
-static INLINE int16_t quant_to_doff_fixed(int16_t quant, int lossless,
-                                          int band, int bd) {
-  const int shift = bd - 8;
+static INLINE int16_t quant_to_doff_fixed(int lossless, int band,
+                                          int dq_off_index) {
   if (lossless)
     return vp9_nuq_doff_lossless[band];
-  if (quant > (512 << shift))
-    return vp9_nuq_doff_huge[band];
-  else if (quant > (256 << shift))
-    return vp9_nuq_doff_high[band];
-  else if (quant > (128 << shift))
+  else if (!dq_off_index)  // dq_off_index == 0
     return vp9_nuq_doff_mid[band];
-  else if (quant > (64 << shift))
+  else if (dq_off_index == 1)
     return vp9_nuq_doff_low[band];
-  else
-    return vp9_nuq_doff_tiny[band];
+  else  // dq_off_index == 2
+    return vp9_nuq_doff_high[band];
 }
 
-static INLINE void get_cumbins_nuq(int q, int lossless, int band, int bd,
+static INLINE void get_cumbins_nuq(int q, int lossless, int band,
                                    tran_low_t *cumbins) {
-  const uint8_t *knots = get_nuq_knots(q, lossless, band, bd);
+  const uint8_t *knots = get_nuq_knots(lossless, band);
   int16_t cumknots[NUQ_KNOTS];
   int i;
   cumknots[0] = knots[0];
@@ -177,22 +108,23 @@ static INLINE void get_cumbins_nuq(int q, int lossless, int band, int bd,
     cumbins[i] = (cumknots[i] * q + 64) >> 7;
 }
 
-void vp9_get_dequant_val_nuq(int q, int lossless, int band, int bd,
-                             tran_low_t *dq, tran_low_t *cumbins) {
-  const uint8_t *knots = get_nuq_knots(q, lossless, band, bd);
+void vp9_get_dequant_val_nuq(int q, int lossless, int band,
+                             tran_low_t *dq, tran_low_t *cumbins,
+                             int dq_off_index) {
+  const uint8_t *knots = get_nuq_knots(lossless, band);
   tran_low_t cumbins_[NUQ_KNOTS], *cumbins_ptr;
   tran_low_t doff;
   int i;
   cumbins_ptr = (cumbins ? cumbins : cumbins_);
-  get_cumbins_nuq(q, lossless, band, bd, cumbins_ptr);
+  get_cumbins_nuq(q, lossless, band, cumbins_ptr);
   dq[0] = 0;
   for (i = 1; i < NUQ_KNOTS; ++i) {
     const int16_t qstep = (knots[i] * q + 64) >> 7;
-    doff = quant_to_doff_fixed(qstep, lossless, band, bd);
+    doff = quant_to_doff_fixed(lossless, band, dq_off_index);
     doff = (2 * doff * qstep + q) / (2 * q);
     dq[i] = cumbins_ptr[i - 1] + (((knots[i] - doff * 2) * q + 128) >> 8);
   }
-  doff = quant_to_doff_fixed(q, lossless, band, bd);
+  doff = quant_to_doff_fixed(lossless, band, dq_off_index);
   dq[NUQ_KNOTS] =
       cumbins_ptr[NUQ_KNOTS - 1] + (((64 - doff) * q + 64) >> 7);
 }

diff --git a/vp9/common/vp9_quant_common.h b/vp9/common/vp9_quant_common.h
index 3d534c8ce9e77ef839334f3a99ab85bca68e990b..5ee5903179486ee77ae671ce16fa93132e75c020 100644 (file)
--- a/vp9/common/vp9_quant_common.h
+++ b/vp9/common/vp9_quant_common.h
@@ -47,8 +47,9 @@ static INLINE int16_t vp9_round_factor_to_round(int16_t quant,
 #define NUQ_KNOTS 3
 typedef tran_low_t dequant_val_type_nuq[NUQ_KNOTS + 1];
 typedef tran_low_t cumbins_type_nuq[NUQ_KNOTS];
-void vp9_get_dequant_val_nuq(int q, int lossless, int band, int bd,
-                             tran_low_t *dq, tran_low_t *cumbins);
+void vp9_get_dequant_val_nuq(int q, int lossless, int band,
+                             tran_low_t *dq, tran_low_t *cumbins,
+                             int dq_off_index);
 tran_low_t vp9_dequant_abscoeff_nuq(int v, int q, const tran_low_t *dq);
 tran_low_t vp9_dequant_coeff_nuq(int v, int q, const tran_low_t *dq);
 #endif  // CONFIG_NEW_QUANT

diff --git a/vp9/common/vp9_reconinter.c b/vp9/common/vp9_reconinter.c
index 4a81a405a8fc0685d47a6d276adc0466fd45df1e..d0af4b643a1dcde7f4503cde168010c545cc71d7 100644 (file)
--- a/vp9/common/vp9_reconinter.c
+++ b/vp9/common/vp9_reconinter.c
@@ -1870,9 +1870,8 @@ static void build_inter_predictors_single_buf(MACROBLOCKD *xd,
 #endif  // CONFIG_INTRABC
   const InterpKernel *kernel = vp9_get_interp_kernel(mi->mbmi.interp_filter);
 #if CONFIG_GLOBAL_MOTION
-  Global_Motion_Params *gm;
+  Global_Motion_Params *gm = &xd->global_motion[mi->mbmi.ref_frame[ref]][0];
   int is_global;
-  gm = &xd->global_motion[mi->mbmi.ref_frame[ref]][0];
 #endif  // CONFIG_GLOBAL_MOTION
 #if CONFIG_INTRABC
   assert(!is_intrabc || mi->mbmi.interp_filter == BILINEAR);
@@ -2028,6 +2027,7 @@ static void build_wedge_inter_predictor_from_buf(MACROBLOCKD *xd, int plane,
     gm[1] = &xd->global_motion[mi->mbmi.ref_frame[1]][0];
 #endif  // CONFIG_GLOBAL_MOTION
 #if CONFIG_INTRABC
+  (void) is_intrabc;
   assert(!is_intrabc || mi->mbmi.interp_filter == BILINEAR);
 #endif  // CONFIG_INTRABC
   (void) block;

diff --git a/vp9/decoder/vp9_decodeframe.c b/vp9/decoder/vp9_decodeframe.c
index b1f2cb14e59430d9b9ef815ef387845cab23c70d..a484762dd96b02c19b88a6afb7297e211055501d 100644 (file)
--- a/vp9/decoder/vp9_decodeframe.c
+++ b/vp9/decoder/vp9_decodeframe.c
@@ -225,30 +225,40 @@ static void read_mv_probs(nmv_context *ctx, int allow_hp, vp9_reader *r) {
 
 static void setup_plane_dequants(VP9_COMMON *cm, MACROBLOCKD *xd, int q_index) {
   int i;
+#if CONFIG_NEW_QUANT
+  int dq;
+#endif  // CONFIG_NEW_QUANT
   xd->plane[0].dequant = cm->y_dequant[q_index];
 #if CONFIG_NEW_QUANT
-  xd->plane[0].dequant_val_nuq =
-      (const dequant_val_type_nuq *)cm->y_dequant_val_nuq[q_index];
+  for (dq = 0; dq < QUANT_PROFILES; dq ++) {
+    xd->plane[0].dequant_val_nuq[dq] =
+        (const dequant_val_type_nuq *)cm->y_dequant_val_nuq[dq][q_index];
+  }
 #endif  // CONFIG_NEW_QUANT
 #if CONFIG_TX_SKIP
   xd->plane[0].dequant_pxd = cm->y_dequant_pxd[q_index];
 #if CONFIG_NEW_QUANT
-  xd->plane[0].dequant_val_nuq_pxd =
-      (const dequant_val_type_nuq *)cm->y_dequant_val_nuq_pxd[q_index];
+  for (dq = 0; dq < QUANT_PROFILES; dq ++) {
+    xd->plane[0].dequant_val_nuq_pxd[dq] =
+        (const dequant_val_type_nuq *)cm->y_dequant_val_nuq_pxd[dq][q_index];
+  }
 #endif  // CONFIG_NEW_QUANT
 #endif  // CONFIG_TX_SKIP
-
   for (i = 1; i < MAX_MB_PLANE; i++) {
     xd->plane[i].dequant = cm->uv_dequant[q_index];
 #if CONFIG_NEW_QUANT
-    xd->plane[i].dequant_val_nuq =
-        (const dequant_val_type_nuq *)cm->uv_dequant_val_nuq[q_index];
+    for (dq = 0; dq < QUANT_PROFILES; dq ++) {
+      xd->plane[i].dequant_val_nuq[dq] =
+          (const dequant_val_type_nuq *)cm->uv_dequant_val_nuq[dq][q_index];
+    }
 #endif  // CONFIG_NEW_QUANT
 #if CONFIG_TX_SKIP
     xd->plane[i].dequant_pxd = cm->uv_dequant_pxd[q_index];
 #if CONFIG_NEW_QUANT
-    xd->plane[i].dequant_val_nuq_pxd =
-        (const dequant_val_type_nuq *)cm->uv_dequant_val_nuq_pxd[q_index];
+    for (dq = 0; dq < QUANT_PROFILES; dq ++) {
+      xd->plane[i].dequant_val_nuq_pxd[dq] =
+          (const dequant_val_type_nuq *)cm->uv_dequant_val_nuq_pxd[dq][q_index];
+    }
 #endif  // CONFIG_NEW_QUANT
 #endif  // CONFIG_TX_SKIP
   }
@@ -1673,7 +1683,6 @@ static void decode_block(VP9_COMMON *const cm, MACROBLOCKD *const xd,
   mbmi->tx_skip_shift = q_idx > TX_SKIP_SHIFT_THRESH ?
                         TX_SKIP_SHIFT_HQ : TX_SKIP_SHIFT_LQ;
 #endif
-
 #if CONFIG_SUPERTX
   if (!supertx_enabled) {
 #endif
@@ -2310,6 +2319,7 @@ static void setup_quantization(VP9_COMMON *const cm, MACROBLOCKD *const xd,
                  cm->y_dc_delta_q == 0 &&
                  cm->uv_dc_delta_q == 0 &&
                  cm->uv_ac_delta_q == 0;
+
 #if CONFIG_VP9_HIGHBITDEPTH
   xd->bd = (int)cm->bit_depth;
 #endif
@@ -3506,6 +3516,9 @@ static int read_compressed_header(VP9Decoder *pbi, const uint8_t *data,
 
 void vp9_init_dequantizer(VP9_COMMON *cm) {
   int q;
+#if CONFIG_NEW_QUANT
+  int dq;
+#endif  // CONFIG_NEW_QUANT
 
   for (q = 0; q < QINDEX_RANGE; q++) {
     int b;
@@ -3516,13 +3529,15 @@ void vp9_init_dequantizer(VP9_COMMON *cm) {
     cm->uv_dequant[q][1] = vp9_ac_quant(q, cm->uv_ac_delta_q, cm->bit_depth);
 
 #if CONFIG_NEW_QUANT
-    for (b = 0; b < COEF_BANDS; ++b) {
-      vp9_get_dequant_val_nuq(
-          cm->y_dequant[q][b != 0], q == 0, b, cm->bit_depth,
-          cm->y_dequant_val_nuq[q][b], NULL);
-      vp9_get_dequant_val_nuq(
-          cm->uv_dequant[q][b != 0], q == 0, b, cm->bit_depth,
-          cm->uv_dequant_val_nuq[q][b], NULL);
+    for (dq = 0; dq < QUANT_PROFILES; dq ++) {
+      for (b = 0; b < COEF_BANDS; ++b) {
+        vp9_get_dequant_val_nuq(
+            cm->y_dequant[q][b != 0], q == 0, b,
+            cm->y_dequant_val_nuq[dq][q][b], NULL, dq);
+        vp9_get_dequant_val_nuq(
+            cm->uv_dequant[q][b != 0], q == 0, b,
+            cm->uv_dequant_val_nuq[dq][q][b], NULL, dq);
+      }
     }
 #endif  // CONFIG_NEW_QUANT
 
@@ -3533,13 +3548,15 @@ void vp9_init_dequantizer(VP9_COMMON *cm) {
     cm->uv_dequant_pxd[q][0] = cm->uv_dequant[q][PXD_QUANT_INDEX];
     cm->uv_dequant_pxd[q][1] = cm->uv_dequant[q][PXD_QUANT_INDEX];
 #if CONFIG_NEW_QUANT
-    for (b = 0; b < COEF_BANDS; ++b) {
-      vp9_get_dequant_val_nuq(
-          cm->y_dequant_pxd[q][b != 0], q == 0, b, cm->bit_depth,
-          cm->y_dequant_val_nuq_pxd[q][b], NULL);
-      vp9_get_dequant_val_nuq(
-          cm->uv_dequant_pxd[q][b != 0], q == 0, b, cm->bit_depth,
-          cm->uv_dequant_val_nuq_pxd[q][b], NULL);
+    for (dq = 0; dq < QUANT_PROFILES; dq ++) {
+      for (b = 0; b < COEF_BANDS; ++b) {
+        vp9_get_dequant_val_nuq(
+            cm->y_dequant_pxd[q][b != 0], q == 0, b,
+            cm->y_dequant_val_nuq_pxd[dq][q][b], NULL, dq);
+        vp9_get_dequant_val_nuq(
+            cm->uv_dequant_pxd[q][b != 0], q == 0, b,
+            cm->uv_dequant_val_nuq_pxd[dq][q][b], NULL, dq);
+      }
     }
 #endif  // CONFIG_NEW_QUANT
 #endif  // CONFIG_TX_SKIP

diff --git a/vp9/decoder/vp9_decodemv.c b/vp9/decoder/vp9_decodemv.c
index 8e4baeeff92c4389fbf93846ee3da2f8674896f3..114904f773e2209f10981f99c1f5fe753d298811 100644 (file)
--- a/vp9/decoder/vp9_decodemv.c
+++ b/vp9/decoder/vp9_decodemv.c
@@ -310,6 +310,10 @@ static void read_intra_frame_mode_info(VP9_COMMON *const cm,
   int_mv dv_ref;
 #endif  // CONFIG_INTRABC
 
+#if CONFIG_NEW_QUANT
+  mbmi->dq_off_index = DEFAULT_DQ;
+#endif  // CONFIG_NEW_QUANT
+
   mbmi->segment_id = read_intra_segment_id(cm, xd, mi_row, mi_col, r);
 #if CONFIG_MISC_ENTROPY
   mbmi->skip = 0;
@@ -1460,6 +1464,10 @@ static void read_inter_frame_mode_info(VP9_COMMON *const cm,
   (void) supertx_enabled;
 #endif
 
+#if CONFIG_NEW_QUANT
+  mbmi->dq_off_index = DEFAULT_DQ;
+#endif  // CONFIG_NEW_QUANT
+
   mbmi->mv[0].as_int = 0;
   mbmi->mv[1].as_int = 0;
 

diff --git a/vp9/decoder/vp9_detokenize.c b/vp9/decoder/vp9_detokenize.c
index 2739fccd578fba48c52c2e41b7e05cef855144dd..4f9e76435c97f504fcea14f9bade1af05453bc5f 100644 (file)
--- a/vp9/decoder/vp9_detokenize.c
+++ b/vp9/decoder/vp9_detokenize.c
@@ -447,6 +447,9 @@ int vp9_decode_block_tokens(VP9_COMMON *cm, MACROBLOCKD *xd,
                                                pd->left_context + y);
   const scan_order *so = get_scan(xd, tx_size, pd->plane_type, block);
   int eob;
+#if CONFIG_NEW_QUANT
+  int dq = xd->mi->mbmi.dq_off_index;
+#endif  // CONFIG_NEW_QUANT
 
 #if CONFIG_TX_SKIP
   if (xd->mi->src_mi->mbmi.tx_skip[plane != 0] && FOR_SCREEN_CONTENT)
@@ -454,7 +457,7 @@ int vp9_decode_block_tokens(VP9_COMMON *cm, MACROBLOCKD *xd,
                            BLOCK_OFFSET(pd->dqcoeff, block), tx_size,
                            pd->dequant_pxd,
 #if CONFIG_NEW_QUANT
-                           pd->dequant_val_nuq_pxd,
+                           pd->dequant_val_nuq_pxd[dq],
 #endif  // CONFIG_NEW_QUANT
                            ctx, so->scan,
                            so->neighbors, r);
@@ -471,9 +474,10 @@ int vp9_decode_block_tokens(VP9_COMMON *cm, MACROBLOCKD *xd,
 #if CONFIG_NEW_QUANT
 #if CONFIG_TX_SKIP
                        xd->mi->src_mi->mbmi.tx_skip[plane != 0] ?
-                           pd->dequant_val_nuq_pxd : pd->dequant_val_nuq,
+                           pd->dequant_val_nuq_pxd[dq] :
+                           pd->dequant_val_nuq[dq],
 #else
-                       pd->dequant_val_nuq,
+                       pd->dequant_val_nuq[dq],
 #endif  // CONFIG_TX_SKIP
 #endif  // CONFIG_NEW_QUANT
                        ctx, so->scan,
@@ -485,5 +489,3 @@ int vp9_decode_block_tokens(VP9_COMMON *cm, MACROBLOCKD *xd,
   vp9_set_contexts(xd, pd, plane_bsize, tx_size, eob > 0, x, y);
   return eob;
 }
-
-

diff --git a/vp9/encoder/vp9_encodeframe.c b/vp9/encoder/vp9_encodeframe.c
index 90891ffaa0c592206f883837060a5b4c86d13267..25efd79f922e1a44d720e4cdc112d1f56195d32e 100644 (file)
--- a/vp9/encoder/vp9_encodeframe.c
+++ b/vp9/encoder/vp9_encodeframe.c
@@ -4712,6 +4712,10 @@ static void encode_superblock(VP9_COMP *cpi, TOKENEXTRA **t, int output_enabled,
   const int mi_width = num_8x8_blocks_wide_lookup[bsize];
   const int mi_height = num_8x8_blocks_high_lookup[bsize];
 
+#if CONFIG_NEW_QUANT
+  mbmi->dq_off_index = DEFAULT_DQ;
+#endif  // CONFIG_NEW_QUANT
+
   x->skip_recode = !x->select_tx_size && mbmi->sb_type >= BLOCK_8X8 &&
                    cpi->oxcf.aq_mode != COMPLEXITY_AQ &&
                    cpi->oxcf.aq_mode != CYCLIC_REFRESH_AQ &&

diff --git a/vp9/encoder/vp9_encodemb.c b/vp9/encoder/vp9_encodemb.c
index 81f49dd613ea2dbb4b9b27e839702981ae65534a..7af77ed86d81ecf4339b8fd5243df07102003cc4 100644 (file)
--- a/vp9/encoder/vp9_encodemb.c
+++ b/vp9/encoder/vp9_encodemb.c
@@ -150,6 +150,9 @@ static int optimize_b(MACROBLOCK *mb, int plane, int block,
   tran_low_t *const dqcoeff = BLOCK_OFFSET(pd->dqcoeff, block);
   const int eob = p->eobs[block];
   const PLANE_TYPE type = pd->plane_type;
+#if CONFIG_NEW_QUANT
+  int dq = xd->mi->mbmi.dq_off_index;
+#endif  //  CONFIG_NEW_QUANT
 #if CONFIG_SR_MODE
   int b_sr = xd->mi[0].src_mi->mbmi.sr;
   // TX_SIZE new_tx_size = (b_sr) ? (tx_size - 1) : tx_size;
@@ -164,10 +167,11 @@ static int optimize_b(MACROBLOCK *mb, int plane, int block,
   const int16_t *dequant_ptr = pd->dequant;
 #endif  // CONFIG_TX_SKIP
 #if CONFIG_NEW_QUANT
+  int dq = xd->mi->mbmi.dq_off_index;
 #if CONFIG_TX_SKIP
   const int use_rect_quant = is_rect_quant_used(&xd->mi[0].src_mi->mbmi, plane);
 #endif  // CONFIG_TX_SKIP
-  const dequant_val_type_nuq *dequant_val = pd->dequant_val_nuq;
+  const dequant_val_type_nuq *dequant_val = pd->dequant_val_nuq[dq];
 #endif  // CONFIG_NEW_QUANT
 #if CONFIG_TX_SKIP
   const uint8_t *const band_translate = tx_skip ?
@@ -192,7 +196,7 @@ static int optimize_b(MACROBLOCK *mb, int plane, int block,
 #if CONFIG_TX_SKIP
   const int use_rect_quant = is_rect_quant_used(&xd->mi[0].src_mi->mbmi, plane);
 #endif  // CONFIG_TX_SKIP
-  const dequant_val_type_nuq *dequant_val = pd->dequant_val_nuq;
+  const dequant_val_type_nuq *dequant_val = pd->dequant_val_nuq[dq];
 #endif  // CONFIG_NEW_QUANT
 #if CONFIG_TX_SKIP
   const uint8_t *const band_translate = tx_skip ?
@@ -224,7 +228,7 @@ static int optimize_b(MACROBLOCK *mb, int plane, int block,
 
 #if CONFIG_TX_SKIP && CONFIG_NEW_QUANT
   if (xd->mi[0].src_mi->mbmi.tx_skip[plane != 0])
-    dequant_val = pd->dequant_val_nuq_pxd;
+    dequant_val = pd->dequant_val_nuq_pxd[dq];
 #endif  // CONFIG_TX_SKIP && CONFIG_NEW_QUANT
 
   /* Now set up a Viterbi trellis to evaluate alternative roundings. */
@@ -678,6 +682,7 @@ void vp9_xform_quant_nuq(MACROBLOCK *x, int plane, int block,
   MACROBLOCKD *const xd = &x->e_mbd;
   const struct macroblock_plane *const p = &x->plane[plane];
   const struct macroblockd_plane *const pd = &xd->plane[plane];
+int dq = xd->mi->mbmi.dq_off_index;
 #if CONFIG_TX_SKIP
   MB_MODE_INFO *mbmi = &xd->mi[0].src_mi->mbmi;
   int shift = mbmi->tx_skip_shift;
@@ -712,7 +717,7 @@ void vp9_xform_quant_nuq(MACROBLOCK *x, int plane, int block,
                                 pd->dequant_pxd,
                                 (const cumbins_type_nuq *)p->cumbins_nuq_pxd,
                                 (const dequant_val_type_nuq *)
-                                pd->dequant_val_nuq_pxd,
+                                pd->dequant_val_nuq_pxd[dq],
                                 qcoeff, dqcoeff, eob,
                                 scan_order->scan, band);
       else
@@ -720,7 +725,8 @@ void vp9_xform_quant_nuq(MACROBLOCK *x, int plane, int block,
         vp9_quantize_nuq(coeff, bs * bs, x->skip_block,
                          p->quant_pxd, p->quant_shift_pxd, pd->dequant_pxd,
                          (const cumbins_type_nuq *)p->cumbins_nuq_pxd,
-                         (const dequant_val_type_nuq *)pd->dequant_val_nuq_pxd,
+                         (const dequant_val_type_nuq *)
+                         pd->dequant_val_nuq_pxd[dq],
                          qcoeff, dqcoeff, eob,
                          scan_order->scan, band);
     } else if (tx_size == TX_32X32) {
@@ -732,7 +738,7 @@ void vp9_xform_quant_nuq(MACROBLOCK *x, int plane, int block,
                                       (const cumbins_type_nuq *)
                                       p->cumbins_nuq_pxd,
                                       (const dequant_val_type_nuq *)
-                                      pd->dequant_val_nuq,
+                                      pd->dequant_val_nuq[dq],
                                       qcoeff, dqcoeff, eob,
                                       scan_order->scan, band);
       else
@@ -742,7 +748,7 @@ void vp9_xform_quant_nuq(MACROBLOCK *x, int plane, int block,
                                pd->dequant_pxd,
                                (const cumbins_type_nuq *)p->cumbins_nuq_pxd,
                                (const dequant_val_type_nuq *)
-                               pd->dequant_val_nuq,
+                               pd->dequant_val_nuq[dq],
                                qcoeff, dqcoeff, eob,
                                scan_order->scan, band);
     }
@@ -756,7 +762,7 @@ void vp9_xform_quant_nuq(MACROBLOCK *x, int plane, int block,
                                       (const cumbins_type_nuq *)
                                       p->cumbins_nuq_pxd,
                                       (const dequant_val_type_nuq *)
-                                      pd->dequant_val_nuq,
+                                      pd->dequant_val_nuq[dq],
                                       qcoeff, dqcoeff, eob,
                                       scan_order->scan, band);
       else
@@ -766,7 +772,7 @@ void vp9_xform_quant_nuq(MACROBLOCK *x, int plane, int block,
                                pd->dequant_pxd,
                                (const cumbins_type_nuq *)p->cumbins_nuq_pxd,
                                (const dequant_val_type_nuq *)
-                               pd->dequant_val_nuq,
+                               pd->dequant_val_nuq[dq],
                                qcoeff, dqcoeff, eob,
                                scan_order->scan, band);
     }
@@ -786,7 +792,7 @@ void vp9_xform_quant_nuq(MACROBLOCK *x, int plane, int block,
                                       p->quant, p->quant_shift, pd->dequant,
                                       (const cumbins_type_nuq *)p->cumbins_nuq,
                                       (const dequant_val_type_nuq *)
-                                          pd->dequant_val_nuq,
+                                          pd->dequant_val_nuq[dq],
                                       qcoeff, dqcoeff, eob,
                                       scan_order->scan, band);
         break;
@@ -797,7 +803,7 @@ void vp9_xform_quant_nuq(MACROBLOCK *x, int plane, int block,
                                       p->quant, p->quant_shift, pd->dequant,
                                       (const cumbins_type_nuq *)p->cumbins_nuq,
                                       (const dequant_val_type_nuq *)
-                                          pd->dequant_val_nuq,
+                                          pd->dequant_val_nuq[dq],
                                       qcoeff, dqcoeff, eob,
                                       scan_order->scan, band);
         break;
@@ -811,7 +817,7 @@ void vp9_xform_quant_nuq(MACROBLOCK *x, int plane, int block,
                                 p->quant, p->quant_shift, pd->dequant,
                                 (const cumbins_type_nuq *)p->cumbins_nuq,
                                 (const dequant_val_type_nuq *)
-                                    pd->dequant_val_nuq,
+                                    pd->dequant_val_nuq[dq],
                                 qcoeff, dqcoeff, eob,
                                 scan_order->scan, band);
         break;
@@ -825,7 +831,7 @@ void vp9_xform_quant_nuq(MACROBLOCK *x, int plane, int block,
                                 p->quant, p->quant_shift, pd->dequant,
                                 (const cumbins_type_nuq *)p->cumbins_nuq,
                                 (const dequant_val_type_nuq *)
-                                    pd->dequant_val_nuq,
+                                    pd->dequant_val_nuq[dq],
                                 qcoeff, dqcoeff, eob,
                                 scan_order->scan, band);
         break;
@@ -839,7 +845,7 @@ void vp9_xform_quant_nuq(MACROBLOCK *x, int plane, int block,
                                 p->quant, p->quant_shift, pd->dequant,
                                 (const cumbins_type_nuq *)p->cumbins_nuq,
                                 (const dequant_val_type_nuq *)
-                                    pd->dequant_val_nuq,
+                                    pd->dequant_val_nuq[dq],
                                 qcoeff, dqcoeff, eob,
                                 scan_order->scan, band);
         break;
@@ -861,7 +867,8 @@ void vp9_xform_quant_nuq(MACROBLOCK *x, int plane, int block,
       vp9_quantize_64x64_nuq(coeff, 4096, x->skip_block,
                              p->quant, p->quant_shift, pd->dequant,
                              (const cumbins_type_nuq *)p->cumbins_nuq,
-                             (const dequant_val_type_nuq *)pd->dequant_val_nuq,
+                             (const dequant_val_type_nuq *)
+                             pd->dequant_val_nuq[dq],
                              qcoeff, dqcoeff, eob,
                              scan_order->scan, band);
       break;
@@ -875,7 +882,8 @@ void vp9_xform_quant_nuq(MACROBLOCK *x, int plane, int block,
       vp9_quantize_32x32_nuq(coeff, 1024, x->skip_block,
                              p->quant, p->quant_shift, pd->dequant,
                              (const cumbins_type_nuq *)p->cumbins_nuq,
-                             (const dequant_val_type_nuq *)pd->dequant_val_nuq,
+                             (const dequant_val_type_nuq *)
+                             pd->dequant_val_nuq[dq],
                              qcoeff, dqcoeff, eob,
                              scan_order->scan, band);
       break;
@@ -888,7 +896,8 @@ void vp9_xform_quant_nuq(MACROBLOCK *x, int plane, int block,
       vp9_quantize_nuq(coeff, 256, x->skip_block,
                        p->quant, p->quant_shift, pd->dequant,
                        (const cumbins_type_nuq *)p->cumbins_nuq,
-                       (const dequant_val_type_nuq *)pd->dequant_val_nuq,
+                       (const dequant_val_type_nuq *)
+                       pd->dequant_val_nuq[dq],
                        qcoeff, dqcoeff, eob,
                        scan_order->scan, band);
       break;
@@ -901,7 +910,8 @@ void vp9_xform_quant_nuq(MACROBLOCK *x, int plane, int block,
       vp9_quantize_nuq(coeff, 64, x->skip_block,
                        p->quant, p->quant_shift, pd->dequant,
                        (const cumbins_type_nuq *)p->cumbins_nuq,
-                       (const dequant_val_type_nuq *)pd->dequant_val_nuq,
+                       (const dequant_val_type_nuq *)
+                       pd->dequant_val_nuq[dq],
                        qcoeff, dqcoeff, eob,
                        scan_order->scan, band);
       break;
@@ -914,7 +924,8 @@ void vp9_xform_quant_nuq(MACROBLOCK *x, int plane, int block,
       vp9_quantize_nuq(coeff, 16, x->skip_block,
                        p->quant, p->quant_shift, pd->dequant,
                        (const cumbins_type_nuq *)p->cumbins_nuq,
-                       (const dequant_val_type_nuq *)pd->dequant_val_nuq,
+                       (const dequant_val_type_nuq *)
+                       pd->dequant_val_nuq[dq],
                        qcoeff, dqcoeff, eob,
                        scan_order->scan, band);
       break;
@@ -929,6 +940,7 @@ void vp9_xform_quant_fp_nuq(MACROBLOCK *x, int plane, int block,
   MACROBLOCKD *const xd = &x->e_mbd;
   const struct macroblock_plane *const p = &x->plane[plane];
   const struct macroblockd_plane *const pd = &xd->plane[plane];
+int dq = xd->mi->mbmi.dq_off_index;
 #if CONFIG_TX_SKIP
   MB_MODE_INFO *mbmi = &xd->mi[0].src_mi->mbmi;
   int shift = mbmi->tx_skip_shift;
@@ -962,7 +974,7 @@ void vp9_xform_quant_fp_nuq(MACROBLOCK *x, int plane, int block,
                                    p->quant_pxd_fp, pd->dequant_pxd,
                                    (const cumbins_type_nuq *)p->cumbins_nuq_pxd,
                                    (const dequant_val_type_nuq *)
-                                   pd->dequant_val_nuq_pxd,
+                                   pd->dequant_val_nuq_pxd[dq],
                                    qcoeff, dqcoeff, eob,
                                    scan_order->scan, band);
       else
@@ -971,7 +983,7 @@ void vp9_xform_quant_fp_nuq(MACROBLOCK *x, int plane, int block,
                             p->quant_pxd_fp, pd->dequant_pxd,
                             (const cumbins_type_nuq *)p->cumbins_nuq_pxd,
                             (const dequant_val_type_nuq *)
-                            pd->dequant_val_nuq_pxd,
+                            pd->dequant_val_nuq_pxd[dq],
                             qcoeff, dqcoeff, eob,
                             scan_order->scan, band);
     } else if (tx_size == TX_32X32) {
@@ -982,7 +994,7 @@ void vp9_xform_quant_fp_nuq(MACROBLOCK *x, int plane, int block,
                                          (const cumbins_type_nuq *)
                                          p->cumbins_nuq_pxd,
                                          (const dequant_val_type_nuq *)
-                                         pd->dequant_val_nuq_pxd,
+                                         pd->dequant_val_nuq_pxd[dq],
                                          qcoeff, dqcoeff, eob,
                                          scan_order->scan, band);
       else
@@ -991,7 +1003,7 @@ void vp9_xform_quant_fp_nuq(MACROBLOCK *x, int plane, int block,
                                   p->quant_pxd_fp, pd->dequant_pxd,
                                   (const cumbins_type_nuq *)p->cumbins_nuq_pxd,
                                   (const dequant_val_type_nuq *)
-                                  pd->dequant_val_nuq_pxd,
+                                  pd->dequant_val_nuq_pxd[dq],
                                   qcoeff, dqcoeff, eob,
                                   scan_order->scan, band);
     }
@@ -1004,7 +1016,7 @@ void vp9_xform_quant_fp_nuq(MACROBLOCK *x, int plane, int block,
                                          (const cumbins_type_nuq *)
                                          p->cumbins_nuq_pxd,
                                          (const dequant_val_type_nuq *)
-                                         pd->dequant_val_nuq_pxd,
+                                         pd->dequant_val_nuq_pxd[dq],
                                          qcoeff, dqcoeff, eob,
                                          scan_order->scan, band);
       else
@@ -1013,7 +1025,7 @@ void vp9_xform_quant_fp_nuq(MACROBLOCK *x, int plane, int block,
                                   p->quant_pxd_fp, pd->dequant_pxd,
                                   (const cumbins_type_nuq *)p->cumbins_nuq_pxd,
                                   (const dequant_val_type_nuq *)
-                                  pd->dequant_val_nuq_pxd,
+                                  pd->dequant_val_nuq_pxd[dq],
                                   qcoeff, dqcoeff, eob,
                                   scan_order->scan, band);
     }
@@ -1033,7 +1045,7 @@ void vp9_xform_quant_fp_nuq(MACROBLOCK *x, int plane, int block,
                                          (const cumbins_type_nuq *)
                                              p->cumbins_nuq,
                                          (const dequant_val_type_nuq *)
-                                             pd->dequant_val_nuq,
+                                             pd->dequant_val_nuq[dq],
                                          qcoeff, dqcoeff, eob,
                                          scan_order->scan, band);
         break;
@@ -1045,7 +1057,7 @@ void vp9_xform_quant_fp_nuq(MACROBLOCK *x, int plane, int block,
                                          (const cumbins_type_nuq *)
                                              p->cumbins_nuq,
                                          (const dequant_val_type_nuq *)
-                                             pd->dequant_val_nuq,
+                                             pd->dequant_val_nuq[dq],
                                          qcoeff, dqcoeff, eob,
                                          scan_order->scan, band);
         break;
@@ -1059,7 +1071,7 @@ void vp9_xform_quant_fp_nuq(MACROBLOCK *x, int plane, int block,
                                    p->quant_fp, pd->dequant,
                                    (const cumbins_type_nuq *)p->cumbins_nuq,
                                    (const dequant_val_type_nuq *)
-                                       pd->dequant_val_nuq,
+                                       pd->dequant_val_nuq[dq],
                                    qcoeff, dqcoeff, eob,
                                    scan_order->scan, band);
         break;
@@ -1073,7 +1085,7 @@ void vp9_xform_quant_fp_nuq(MACROBLOCK *x, int plane, int block,
                                    p->quant_fp, pd->dequant,
                                    (const cumbins_type_nuq *)p->cumbins_nuq,
                                    (const dequant_val_type_nuq *)
-                                       pd->dequant_val_nuq,
+                                       pd->dequant_val_nuq[dq],
                                    qcoeff, dqcoeff, eob,
                                    scan_order->scan, band);
         break;
@@ -1087,7 +1099,7 @@ void vp9_xform_quant_fp_nuq(MACROBLOCK *x, int plane, int block,
                                    p->quant_fp, pd->dequant,
                                    (const cumbins_type_nuq *)p->cumbins_nuq,
                                    (const dequant_val_type_nuq *)
-                                       pd->dequant_val_nuq,
+                                       pd->dequant_val_nuq[dq],
                                    qcoeff, dqcoeff, eob,
                                    scan_order->scan, band);
         break;
@@ -1110,7 +1122,7 @@ void vp9_xform_quant_fp_nuq(MACROBLOCK *x, int plane, int block,
                                 p->quant_fp, pd->dequant,
                                 (const cumbins_type_nuq *)p->cumbins_nuq,
                                 (const dequant_val_type_nuq *)
-                                    pd->dequant_val_nuq,
+                                    pd->dequant_val_nuq[dq],
                                 qcoeff, dqcoeff, eob,
                                 scan_order->scan, band);
       break;
@@ -1125,7 +1137,7 @@ void vp9_xform_quant_fp_nuq(MACROBLOCK *x, int plane, int block,
                                 p->quant_fp, pd->dequant,
                                 (const cumbins_type_nuq *)p->cumbins_nuq,
                                 (const dequant_val_type_nuq *)
-                                    pd->dequant_val_nuq,
+                                    pd->dequant_val_nuq[dq],
                                 qcoeff, dqcoeff, eob,
                                 scan_order->scan, band);
       break;
@@ -1138,7 +1150,8 @@ void vp9_xform_quant_fp_nuq(MACROBLOCK *x, int plane, int block,
       vp9_quantize_fp_nuq(coeff, 256, x->skip_block,
                           p->quant_fp, pd->dequant,
                           (const cumbins_type_nuq *)p->cumbins_nuq,
-                          (const dequant_val_type_nuq *)pd->dequant_val_nuq,
+                          (const dequant_val_type_nuq *)
+                          pd->dequant_val_nuq[dq],
                           qcoeff, dqcoeff, eob,
                           scan_order->scan, band);
       break;
@@ -1151,7 +1164,8 @@ void vp9_xform_quant_fp_nuq(MACROBLOCK *x, int plane, int block,
       vp9_quantize_fp_nuq(coeff, 64, x->skip_block,
                           p->quant_fp, pd->dequant,
                           (const cumbins_type_nuq *)p->cumbins_nuq,
-                          (const dequant_val_type_nuq *)pd->dequant_val_nuq,
+                          (const dequant_val_type_nuq *)
+                          pd->dequant_val_nuq[dq],
                           qcoeff, dqcoeff, eob,
                           scan_order->scan, band);
       break;
@@ -1164,7 +1178,8 @@ void vp9_xform_quant_fp_nuq(MACROBLOCK *x, int plane, int block,
       vp9_quantize_fp_nuq(coeff, 16, x->skip_block,
                           p->quant_fp, pd->dequant,
                           (const cumbins_type_nuq *)p->cumbins_nuq,
-                          (const dequant_val_type_nuq *)pd->dequant_val_nuq,
+                          (const dequant_val_type_nuq *)
+                          pd->dequant_val_nuq[dq],
                           qcoeff, dqcoeff, eob,
                           scan_order->scan, band);
       break;
@@ -1186,6 +1201,7 @@ void vp9_xform_quant_dc_nuq(MACROBLOCK *x, int plane, int block,
   const int diff_stride = 4 * num_4x4_blocks_wide_lookup[plane_bsize];
   int i, j;
   const int16_t *src_diff;
+  int dq = xd->mi->mbmi.dq_off_index;
 #if CONFIG_TX_SKIP
   MB_MODE_INFO *mbmi = &xd->mi[0].src_mi->mbmi;
   int shift = mbmi->tx_skip_shift;
@@ -1205,13 +1221,14 @@ void vp9_xform_quant_dc_nuq(MACROBLOCK *x, int plane, int block,
                                    p->quant_pxd[0], p->quant_shift_pxd[0],
                                    pd->dequant_pxd[0],
                                    p->cumbins_nuq_pxd[0],
-                                   pd->dequant_val_nuq_pxd[0],
+                                   pd->dequant_val_nuq_pxd[dq][0],
                                    qcoeff, dqcoeff, eob);
 #endif  // CONFIG_VP9_HIGHBITDEPTH
       vp9_quantize_dc_nuq(coeff, x->skip_block,
                           p->quant_pxd[0], p->quant_shift_pxd[0],
                           pd->dequant_pxd[0],
-                          p->cumbins_nuq_pxd[0], pd->dequant_val_nuq_pxd[0],
+                          p->cumbins_nuq_pxd[0],
+                          pd->dequant_val_nuq_pxd[dq][0],
                           qcoeff, dqcoeff, eob);
     } else if (tx_size == TX_32X32) {
 #if CONFIG_VP9_HIGHBITDEPTH
@@ -1220,7 +1237,7 @@ void vp9_xform_quant_dc_nuq(MACROBLOCK *x, int plane, int block,
                                          p->quant_pxd[0], p->quant_shift_pxd[0],
                                          pd->dequant_pxd[0],
                                          p->cumbins_nuq_pxd[0],
-                                         pd->dequant_val_nuq_pxd[0],
+                                         pd->dequant_val_nuq_pxd[dq][0],
                                          qcoeff, dqcoeff, eob);
       else
 #endif  // CONFIG_VP9_HIGHBITDEPTH
@@ -1228,7 +1245,7 @@ void vp9_xform_quant_dc_nuq(MACROBLOCK *x, int plane, int block,
                                   p->quant_pxd[0], p->quant_shift_pxd[0],
                                   pd->dequant_pxd[0],
                                   p->cumbins_nuq_pxd[0],
-                                  pd->dequant_val_nuq_pxd[0],
+                                  pd->dequant_val_nuq_pxd[dq][0],
                                   qcoeff, dqcoeff, eob);
     }
 #if CONFIG_TX64X64
@@ -1239,7 +1256,7 @@ void vp9_xform_quant_dc_nuq(MACROBLOCK *x, int plane, int block,
                                          p->quant_pxd[0], p->quant_shift_pxd[0],
                                          pd->dequant_pxd[0],
                                          p->cumbins_nuq_pxd[0],
-                                         pd->dequant_val_nuq_pxd[0],
+                                         pd->dequant_val_nuq_pxd[dq][0],
                                          qcoeff, dqcoeff, eob);
       else
 #endif  // CONFIG_VP9_HIGHBITDEPTH
@@ -1247,7 +1264,7 @@ void vp9_xform_quant_dc_nuq(MACROBLOCK *x, int plane, int block,
                                   p->quant_pxd[0], p->quant_shift_pxd[0],
                                   pd->dequant_pxd[0],
                                   p->cumbins_nuq_pxd[0],
-                                  pd->dequant_val_nuq_pxd[0],
+                                  pd->dequant_val_nuq_pxd[dq][0],
                                   qcoeff, dqcoeff, eob);
     }
 #endif  // CONFIG_TX64X64
@@ -1266,7 +1283,7 @@ void vp9_xform_quant_dc_nuq(MACROBLOCK *x, int plane, int block,
                                          p->quant[0], p->quant_shift[0],
                                          pd->dequant[0],
                                          p->cumbins_nuq[0],
-                                         pd->dequant_val_nuq[0],
+                                         pd->dequant_val_nuq[dq][0],
                                          qcoeff, dqcoeff, eob);
         break;
 #endif  // CONFIG_TX64X64
@@ -1276,7 +1293,7 @@ void vp9_xform_quant_dc_nuq(MACROBLOCK *x, int plane, int block,
                                          p->quant[0], p->quant_shift[0],
                                          pd->dequant[0],
                                          p->cumbins_nuq[0],
-                                         pd->dequant_val_nuq[0],
+                                         pd->dequant_val_nuq[dq][0],
                                          qcoeff, dqcoeff, eob);
         break;
       case TX_16X16:
@@ -1289,7 +1306,7 @@ void vp9_xform_quant_dc_nuq(MACROBLOCK *x, int plane, int block,
                                    p->quant[0], p->quant_shift[0],
                                    pd->dequant[0],
                                    p->cumbins_nuq[0],
-                                   pd->dequant_val_nuq[0],
+                                   pd->dequant_val_nuq[dq][0],
                                    qcoeff, dqcoeff, eob);
         break;
       case TX_8X8:
@@ -1302,7 +1319,7 @@ void vp9_xform_quant_dc_nuq(MACROBLOCK *x, int plane, int block,
                                    p->quant[0], p->quant_shift[0],
                                    pd->dequant[0],
                                    p->cumbins_nuq[0],
-                                   pd->dequant_val_nuq[0],
+                                   pd->dequant_val_nuq[dq][0],
                                    qcoeff, dqcoeff, eob);
         break;
       case TX_4X4:
@@ -1315,7 +1332,7 @@ void vp9_xform_quant_dc_nuq(MACROBLOCK *x, int plane, int block,
                                    p->quant[0], p->quant_shift[0],
                                    pd->dequant[0],
                                    p->cumbins_nuq[0],
-                                   pd->dequant_val_nuq[0],
+                                   pd->dequant_val_nuq[dq][0],
                                    qcoeff, dqcoeff, eob);
         break;
       default:
@@ -1335,7 +1352,8 @@ void vp9_xform_quant_dc_nuq(MACROBLOCK *x, int plane, int block,
 #endif
       vp9_quantize_dc_64x64_nuq(coeff, x->skip_block,
                                 p->quant[0], p->quant_shift[0], pd->dequant[0],
-                                p->cumbins_nuq[0], pd->dequant_val_nuq[0],
+                                p->cumbins_nuq[0],
+                                pd->dequant_val_nuq[dq][0],
                                 qcoeff, dqcoeff, eob);
       break;
 #endif  // CONFIG_TX64X64
@@ -1347,7 +1365,8 @@ void vp9_xform_quant_dc_nuq(MACROBLOCK *x, int plane, int block,
 #endif
       vp9_quantize_dc_32x32_nuq(coeff, x->skip_block,
                                 p->quant[0], p->quant_shift[0], pd->dequant[0],
-                                p->cumbins_nuq[0], pd->dequant_val_nuq[0],
+                                p->cumbins_nuq[0],
+                                pd->dequant_val_nuq[dq][0],
                                 qcoeff, dqcoeff, eob);
       break;
     case TX_16X16:
@@ -1358,7 +1377,8 @@ void vp9_xform_quant_dc_nuq(MACROBLOCK *x, int plane, int block,
 #endif
       vp9_quantize_dc_nuq(coeff, x->skip_block,
                           p->quant[0], p->quant_shift[0], pd->dequant[0],
-                          p->cumbins_nuq[0], pd->dequant_val_nuq[0],
+                          p->cumbins_nuq[0],
+                          pd->dequant_val_nuq[dq][0],
                           qcoeff, dqcoeff, eob);
       break;
     case TX_8X8:
@@ -1369,7 +1389,8 @@ void vp9_xform_quant_dc_nuq(MACROBLOCK *x, int plane, int block,
 #endif
       vp9_quantize_dc_nuq(coeff, x->skip_block,
                           p->quant[0], p->quant_shift[0], pd->dequant[0],
-                          p->cumbins_nuq[0], pd->dequant_val_nuq[0],
+                          p->cumbins_nuq[0],
+                          pd->dequant_val_nuq[dq][0],
                           qcoeff, dqcoeff, eob);
       break;
     case TX_4X4:
@@ -1380,7 +1401,8 @@ void vp9_xform_quant_dc_nuq(MACROBLOCK *x, int plane, int block,
 #endif
       vp9_quantize_dc_nuq(coeff, x->skip_block,
                           p->quant[0], p->quant_shift[0], pd->dequant[0],
-                          p->cumbins_nuq[0], pd->dequant_val_nuq[0],
+                          p->cumbins_nuq[0],
+                          pd->dequant_val_nuq[dq][0],
                           qcoeff, dqcoeff, eob);
       break;
     default:
@@ -1401,6 +1423,7 @@ void vp9_xform_quant_dc_fp_nuq(MACROBLOCK *x, int plane, int block,
   const int diff_stride = 4 * num_4x4_blocks_wide_lookup[plane_bsize];
   int i, j;
   const int16_t *src_diff;
+  int dq = xd->mi->mbmi.dq_off_index;
 #if CONFIG_TX_SKIP
   MB_MODE_INFO *mbmi = &xd->mi[0].src_mi->mbmi;
   int shift = mbmi->tx_skip_shift;
@@ -1419,14 +1442,14 @@ void vp9_xform_quant_dc_fp_nuq(MACROBLOCK *x, int plane, int block,
         vp9_highbd_quantize_dc_fp_nuq(coeff, x->skip_block,
                                       p->quant_pxd_fp[0], pd->dequant_pxd[0],
                                       p->cumbins_nuq_pxd[0],
-                                      pd->dequant_val_nuq_pxd[0],
+                                      pd->dequant_val_nuq_pxd[dq][0],
                                       qcoeff, dqcoeff, eob);
       else
 #endif  // CONFIG_VP9_HIGHBITDEPTH
         vp9_quantize_dc_fp_nuq(coeff, x->skip_block,
                                p->quant_pxd_fp[0], pd->dequant_pxd[0],
                                p->cumbins_nuq_pxd[0],
-                               pd->dequant_val_nuq_pxd[0],
+                               pd->dequant_val_nuq_pxd[dq][0],
                                qcoeff, dqcoeff, eob);
     } else if (tx_size == TX_32X32) {
 #if CONFIG_VP9_HIGHBITDEPTH
@@ -1435,14 +1458,15 @@ void vp9_xform_quant_dc_fp_nuq(MACROBLOCK *x, int plane, int block,
                                             p->quant_pxd_fp[0],
                                             pd->dequant_pxd[0],
                                             p->cumbins_nuq_pxd[0],
-                                            pd->dequant_val_nuq_pxd[0],
+                                            pd->
+                                            dequant_val_nuq_pxd[dq][0],
                                             qcoeff, dqcoeff, eob);
       else
 #endif  // CONFIG_VP9_HIGHBITDEPTH
         vp9_quantize_dc_32x32_fp_nuq(coeff, x->skip_block,
                                      p->quant_pxd_fp[0], pd->dequant_pxd[0],
                                      p->cumbins_nuq_pxd[0],
-                                     pd->dequant_val_nuq_pxd[0],
+                                     pd->dequant_val_nuq_pxd[dq][0],
                                      qcoeff, dqcoeff, eob);
     }
 #if CONFIG_TX64X64
@@ -1453,14 +1477,15 @@ void vp9_xform_quant_dc_fp_nuq(MACROBLOCK *x, int plane, int block,
                                             p->quant_pxd_fp[0],
                                             pd->dequant_pxd[0],
                                             p->cumbins_nuq_pxd[0],
-                                            pd->dequant_val_nuq_pxd[0],
+                                            pd->
+                                            dequant_val_nuq_pxd[dq][0],
                                             qcoeff, dqcoeff, eob);
       else
 #endif  // CONFIG_VP9_HIGHBITDEPTH
         vp9_quantize_dc_64x64_fp_nuq(coeff, x->skip_block,
                                      p->quant_pxd_fp[0], pd->dequant_pxd[0],
                                      p->cumbins_nuq_pxd[0],
-                                     pd->dequant_val_nuq_pxd[0],
+                                     pd->dequant_val_nuq_pxd[dq][0],
                                      qcoeff, dqcoeff, eob);
     }
 #endif  // CONFIG_TX64X64
@@ -1478,7 +1503,7 @@ void vp9_xform_quant_dc_fp_nuq(MACROBLOCK *x, int plane, int block,
         vp9_highbd_quantize_dc_64x64_fp_nuq(coeff, x->skip_block,
                                             p->quant_fp[0], pd->dequant[0],
                                             p->cumbins_nuq[0],
-                                            pd->dequant_val_nuq[0],
+                                            pd->dequant_val_nuq[dq][0],
                                             qcoeff, dqcoeff, eob);
         break;
 #endif  // CONFIG_TX64X64
@@ -1487,7 +1512,7 @@ void vp9_xform_quant_dc_fp_nuq(MACROBLOCK *x, int plane, int block,
         vp9_highbd_quantize_dc_32x32_fp_nuq(coeff, x->skip_block,
                                             p->quant_fp[0], pd->dequant[0],
                                             p->cumbins_nuq[0],
-                                            pd->dequant_val_nuq[0],
+                                            pd->dequant_val_nuq[dq][0],
                                             qcoeff, dqcoeff, eob);
         break;
       case TX_16X16:
@@ -1499,7 +1524,7 @@ void vp9_xform_quant_dc_fp_nuq(MACROBLOCK *x, int plane, int block,
         vp9_highbd_quantize_dc_fp_nuq(coeff, x->skip_block,
                                       p->quant_fp[0], pd->dequant[0],
                                       p->cumbins_nuq[0],
-                                      pd->dequant_val_nuq[0],
+                                      pd->dequant_val_nuq[dq][0],
                                       qcoeff, dqcoeff, eob);
         break;
       case TX_8X8:
@@ -1511,7 +1536,7 @@ void vp9_xform_quant_dc_fp_nuq(MACROBLOCK *x, int plane, int block,
         vp9_highbd_quantize_dc_fp_nuq(coeff, x->skip_block,
                                       p->quant_fp[0], pd->dequant[0],
                                       p->cumbins_nuq[0],
-                                      pd->dequant_val_nuq[0],
+                                      pd->dequant_val_nuq[dq][0],
                                       qcoeff, dqcoeff, eob);
         break;
       case TX_4X4:
@@ -1523,7 +1548,7 @@ void vp9_xform_quant_dc_fp_nuq(MACROBLOCK *x, int plane, int block,
         vp9_highbd_quantize_dc_fp_nuq(coeff, x->skip_block,
                                       p->quant_fp[0], pd->dequant[0],
                                       p->cumbins_nuq[0],
-                                      pd->dequant_val_nuq[0],
+                                      pd->dequant_val_nuq[dq][0],
                                       qcoeff, dqcoeff, eob);
         break;
       default:
@@ -1543,7 +1568,8 @@ void vp9_xform_quant_dc_fp_nuq(MACROBLOCK *x, int plane, int block,
 #endif
       vp9_quantize_dc_64x64_fp_nuq(coeff, x->skip_block,
                                    p->quant_fp[0], pd->dequant[0],
-                                   p->cumbins_nuq[0], pd->dequant_val_nuq[0],
+                                   p->cumbins_nuq[0],
+                                   pd->dequant_val_nuq[dq][0],
                                    qcoeff, dqcoeff, eob);
       break;
 #endif  // CONFIG_TX64X64
@@ -1555,7 +1581,8 @@ void vp9_xform_quant_dc_fp_nuq(MACROBLOCK *x, int plane, int block,
 #endif
       vp9_quantize_dc_32x32_fp_nuq(coeff, x->skip_block,
                                    p->quant_fp[0], pd->dequant[0],
-                                   p->cumbins_nuq[0], pd->dequant_val_nuq[0],
+                                   p->cumbins_nuq[0],
+                                   pd->dequant_val_nuq[dq][0],
                                    qcoeff, dqcoeff, eob);
       break;
     case TX_16X16:
@@ -1566,7 +1593,8 @@ void vp9_xform_quant_dc_fp_nuq(MACROBLOCK *x, int plane, int block,
 #endif
       vp9_quantize_dc_fp_nuq(coeff, x->skip_block,
                              p->quant_fp[0], pd->dequant[0],
-                             p->cumbins_nuq[0], pd->dequant_val_nuq[0],
+                             p->cumbins_nuq[0],
+                             pd->dequant_val_nuq[dq][0],
                              qcoeff, dqcoeff, eob);
       break;
     case TX_8X8:
@@ -1577,7 +1605,8 @@ void vp9_xform_quant_dc_fp_nuq(MACROBLOCK *x, int plane, int block,
 #endif
       vp9_quantize_dc_fp_nuq(coeff, x->skip_block,
                              p->quant_fp[0], pd->dequant[0],
-                             p->cumbins_nuq[0], pd->dequant_val_nuq[0],
+                             p->cumbins_nuq[0],
+                             pd->dequant_val_nuq[dq][0],
                              qcoeff, dqcoeff, eob);
       break;
     case TX_4X4:
@@ -1588,7 +1617,8 @@ void vp9_xform_quant_dc_fp_nuq(MACROBLOCK *x, int plane, int block,
 #endif
       vp9_quantize_dc_fp_nuq(coeff, x->skip_block,
                              p->quant_fp[0], pd->dequant[0],
-                             p->cumbins_nuq[0], pd->dequant_val_nuq[0],
+                             p->cumbins_nuq[0],
+                             pd->dequant_val_nuq[dq][0],
                              qcoeff, dqcoeff, eob);
       break;
     default:
@@ -2968,6 +2998,7 @@ static void encode_block_intra(int plane, int block, BLOCK_SIZE plane_bsize,
   const int dst_stride = pd->dst.stride;
   int i, j;
 #if CONFIG_NEW_QUANT
+  int dq = xd->mi->mbmi.dq_off_index;
   const uint8_t* band = get_band_translate(tx_size);
 #endif  // CONFIG_NEW_QUANT
 #if CONFIG_SR_MODE
@@ -3067,7 +3098,7 @@ static void encode_block_intra(int plane, int block, BLOCK_SIZE plane_bsize,
                                        (const cumbins_type_nuq *)
                                        p->cumbins_nuq_pxd,
                                        (const dequant_val_type_nuq *)
-                                       pd->dequant_val_nuq_pxd,
+                                       pd->dequant_val_nuq_pxd[dq],
                                        qcoeff, dqcoeff, eob,
                                        scan_order->scan, band);
           else
@@ -3077,7 +3108,7 @@ static void encode_block_intra(int plane, int block, BLOCK_SIZE plane_bsize,
                                     (const cumbins_type_nuq *)
                                     p->cumbins_nuq_pxd,
                                     (const dequant_val_type_nuq *)
-                                    pd->dequant_val_nuq_pxd,
+                                    pd->dequant_val_nuq_pxd[dq],
                                     qcoeff, dqcoeff, eob,
                                     scan_order->scan, band);
         } else {
@@ -3086,7 +3117,7 @@ static void encode_block_intra(int plane, int block, BLOCK_SIZE plane_bsize,
                                 p->quant_pxd_fp, pd->dequant_pxd,
                                 (const cumbins_type_nuq *)p->cumbins_nuq_pxd,
                                 (const dequant_val_type_nuq *)
-                                pd->dequant_val_nuq_pxd,
+                                pd->dequant_val_nuq_pxd[dq],
                                 qcoeff, dqcoeff, eob,
                                 scan_order->scan, band);
           else
@@ -3094,7 +3125,7 @@ static void encode_block_intra(int plane, int block, BLOCK_SIZE plane_bsize,
                              p->quant_pxd, p->quant_shift_pxd, pd->dequant_pxd,
                              (const cumbins_type_nuq *)p->cumbins_nuq_pxd,
                              (const dequant_val_type_nuq *)
-                             pd->dequant_val_nuq_pxd,
+                             pd->dequant_val_nuq_pxd[dq],
                              qcoeff, dqcoeff, eob,
                              scan_order->scan, band);
         }
@@ -3104,7 +3135,7 @@ static void encode_block_intra(int plane, int block, BLOCK_SIZE plane_bsize,
                               p->quant_pxd_fp, pd->dequant_pxd,
                               (const cumbins_type_nuq *)p->cumbins_nuq_pxd,
                               (const dequant_val_type_nuq *)
-                              pd->dequant_val_nuq_pxd,
+                              pd->dequant_val_nuq_pxd[dq],
                               qcoeff, dqcoeff, eob,
                               scan_order->scan, band);
         else
@@ -3112,7 +3143,7 @@ static void encode_block_intra(int plane, int block, BLOCK_SIZE plane_bsize,
                            p->quant_pxd, p->quant_shift_pxd, pd->dequant_pxd,
                            (const cumbins_type_nuq *)p->cumbins_nuq_pxd,
                            (const dequant_val_type_nuq *)
-                           pd->dequant_val_nuq_pxd,
+                           pd->dequant_val_nuq_pxd[dq],
                            qcoeff, dqcoeff, eob,
                            scan_order->scan, band);
 #endif  // CONFIG_VP9_HIGHBITDEPTH
@@ -3140,7 +3171,8 @@ static void encode_block_intra(int plane, int block, BLOCK_SIZE plane_bsize,
                                              (const cumbins_type_nuq *)p->
                                              cumbins_nuq_pxd,
                                              (const dequant_val_type_nuq *)
-                                             pd->dequant_val_nuq_pxd,
+                                             pd->
+                                             dequant_val_nuq_pxd[dq],
                                              qcoeff, dqcoeff, eob,
                                              scan_order->scan, band);
           else
@@ -3150,7 +3182,7 @@ static void encode_block_intra(int plane, int block, BLOCK_SIZE plane_bsize,
                                           (const cumbins_type_nuq *)
                                           p->cumbins_nuq_pxd,
                                           (const dequant_val_type_nuq *)
-                                          pd->dequant_val_nuq_pxd,
+                                          pd->dequant_val_nuq_pxd[dq],
                                           qcoeff, dqcoeff, eob,
                                           scan_order->scan, band);
         } else {
@@ -3160,7 +3192,7 @@ static void encode_block_intra(int plane, int block, BLOCK_SIZE plane_bsize,
                                       (const cumbins_type_nuq *)
                                       p->cumbins_nuq_pxd,
                                       (const dequant_val_type_nuq *)
-                                      pd->dequant_val_nuq_pxd,
+                                      pd->dequant_val_nuq_pxd[dq],
                                       qcoeff, dqcoeff, eob,
                                       scan_order->scan, band);
           else
@@ -3169,7 +3201,7 @@ static void encode_block_intra(int plane, int block, BLOCK_SIZE plane_bsize,
                                    pd->dequant_pxd,
                                    (const cumbins_type_nuq *)p->cumbins_nuq_pxd,
                                    (const dequant_val_type_nuq *)
-                                   pd->dequant_val_nuq_pxd,
+                                   pd->dequant_val_nuq_pxd[dq],
                                    qcoeff, dqcoeff, eob,
                                    scan_order->scan, band);
         }
@@ -3180,7 +3212,7 @@ static void encode_block_intra(int plane, int block, BLOCK_SIZE plane_bsize,
                                     (const cumbins_type_nuq *)
                                     p->cumbins_nuq_pxd,
                                     (const dequant_val_type_nuq *)
-                                    pd->dequant_val_nuq_pxd,
+                                    pd->dequant_val_nuq_pxd[dq],
                                     qcoeff, dqcoeff, eob,
                                     scan_order->scan, band);
         else
@@ -3189,7 +3221,7 @@ static void encode_block_intra(int plane, int block, BLOCK_SIZE plane_bsize,
                                  pd->dequant_pxd,
                                  (const cumbins_type_nuq *)p->cumbins_nuq_pxd,
                                  (const dequant_val_type_nuq *)
-                                 pd->dequant_val_nuq_pxd,
+                                 pd->dequant_val_nuq_pxd[dq],
                                  qcoeff, dqcoeff, eob,
                                  scan_order->scan, band);/**/
 #endif  // CONFIG_VP9_HIGHBITDEPTH
@@ -3220,7 +3252,8 @@ static void encode_block_intra(int plane, int block, BLOCK_SIZE plane_bsize,
                                              (const cumbins_type_nuq *)
                                              p->cumbins_nuq_pxd,
                                              (const dequant_val_type_nuq *)
-                                             pd->dequant_val_nuq_pxd,
+                                             pd->
+                                             dequant_val_nuq_pxd[dq],
                                              qcoeff, dqcoeff, eob,
                                              scan_order->scan, band);
           else
@@ -3230,7 +3263,7 @@ static void encode_block_intra(int plane, int block, BLOCK_SIZE plane_bsize,
                                           (const cumbins_type_nuq *)
                                           p->cumbins_nuq_pxd,
                                           (const dequant_val_type_nuq *)
-                                          pd->dequant_val_nuq_pxd,
+                                          pd->dequant_val_nuq_pxd[dq],
                                           qcoeff, dqcoeff, eob,
                                           scan_order->scan, band);
         } else {
@@ -3240,7 +3273,7 @@ static void encode_block_intra(int plane, int block, BLOCK_SIZE plane_bsize,
                                       (const cumbins_type_nuq *)
                                       p->cumbins_nuq_pxd,
                                       (const dequant_val_type_nuq *)
-                                      pd->dequant_val_nuq_pxd,
+                                      pd->dequant_val_nuq_pxd[dq],
                                       qcoeff, dqcoeff, eob,
                                       scan_order->scan, band);
           else
@@ -3250,7 +3283,7 @@ static void encode_block_intra(int plane, int block, BLOCK_SIZE plane_bsize,
                                    (const cumbins_type_nuq *)
                                    p->cumbins_nuq_pxd,
                                    (const dequant_val_type_nuq *)
-                                   pd->dequant_val_nuq_pxd,
+                                   pd->dequant_val_nuq_pxd[dq],
                                    qcoeff, dqcoeff, eob,
                                    scan_order->scan, band);
         }
@@ -3261,7 +3294,7 @@ static void encode_block_intra(int plane, int block, BLOCK_SIZE plane_bsize,
                                     (const cumbins_type_nuq *)
                                     p->cumbins_nuq_pxd,
                                     (const dequant_val_type_nuq *)
-                                    pd->dequant_val_nuq_pxd,
+                                    pd->dequant_val_nuq_pxd[dq],
                                     qcoeff, dqcoeff, eob,
                                     scan_order->scan, band);
         else
@@ -3270,7 +3303,7 @@ static void encode_block_intra(int plane, int block, BLOCK_SIZE plane_bsize,
                                  pd->dequant_pxd,
                                  (const cumbins_type_nuq *)p->cumbins_nuq_pxd,
                                  (const dequant_val_type_nuq *)
-                                 pd->dequant_val_nuq_pxd,
+                                 pd->dequant_val_nuq_pxd[dq],
                                  qcoeff, dqcoeff, eob,
                                  scan_order->scan, band);
 #endif  // CONFIG_VP9_HIGHBITDEPTH
@@ -3335,7 +3368,7 @@ static void encode_block_intra(int plane, int block, BLOCK_SIZE plane_bsize,
                                              (const cumbins_type_nuq *)
                                              p->cumbins_nuq,
                                              (const dequant_val_type_nuq *)
-                                             pd->dequant_val_nuq,
+                                             pd->dequant_val_nuq[dq],
                                              qcoeff, dqcoeff, eob,
                                              scan_order->scan,
                                              band);
@@ -3345,7 +3378,7 @@ static void encode_block_intra(int plane, int block, BLOCK_SIZE plane_bsize,
                                           (const cumbins_type_nuq *)
                                           p->cumbins_nuq,
                                           (const dequant_val_type_nuq *)
-                                          pd->dequant_val_nuq,
+                                          pd->dequant_val_nuq[dq],
                                           qcoeff, dqcoeff, eob,
                                           scan_order->scan, band);
 #else
@@ -3381,7 +3414,7 @@ static void encode_block_intra(int plane, int block, BLOCK_SIZE plane_bsize,
                                              (const cumbins_type_nuq *)
                                              p->cumbins_nuq,
                                              (const dequant_val_type_nuq *)
-                                             pd->dequant_val_nuq,
+                                             pd->dequant_val_nuq[dq],
                                              qcoeff, dqcoeff, eob,
                                              scan_order->scan,
                                              band);
@@ -3391,7 +3424,7 @@ static void encode_block_intra(int plane, int block, BLOCK_SIZE plane_bsize,
                                           (const cumbins_type_nuq *)
                                           p->cumbins_nuq,
                                           (const dequant_val_type_nuq *)
-                                          pd->dequant_val_nuq,
+                                          pd->dequant_val_nuq[dq],
                                           qcoeff, dqcoeff, eob,
                                           scan_order->scan, band);
 #else
@@ -3426,7 +3459,7 @@ static void encode_block_intra(int plane, int block, BLOCK_SIZE plane_bsize,
                                        p->quant_fp, pd->dequant,
                                        (const cumbins_type_nuq *)p->cumbins_nuq,
                                        (const dequant_val_type_nuq *)
-                                       pd->dequant_val_nuq,
+                                       pd->dequant_val_nuq[dq],
                                        qcoeff, dqcoeff, eob,
                                        scan_order->scan, band);
           else
@@ -3434,7 +3467,7 @@ static void encode_block_intra(int plane, int block, BLOCK_SIZE plane_bsize,
                                     p->quant, p->quant_shift, pd->dequant,
                                     (const cumbins_type_nuq *)p->cumbins_nuq,
                                     (const dequant_val_type_nuq *)
-                                    pd->dequant_val_nuq,
+                                    pd->dequant_val_nuq[dq],
                                     qcoeff, dqcoeff, eob,
                                     scan_order->scan, band);
 #else
@@ -3470,7 +3503,7 @@ static void encode_block_intra(int plane, int block, BLOCK_SIZE plane_bsize,
                                        p->quant_fp, pd->dequant,
                                        (const cumbins_type_nuq *)p->cumbins_nuq,
                                        (const dequant_val_type_nuq *)
-                                       pd->dequant_val_nuq,
+                                       pd->dequant_val_nuq[dq],
                                        qcoeff, dqcoeff, eob,
                                        scan_order->scan, band);
           else
@@ -3478,7 +3511,7 @@ static void encode_block_intra(int plane, int block, BLOCK_SIZE plane_bsize,
                                     p->quant, p->quant_shift, pd->dequant,
                                     (const cumbins_type_nuq *)p->cumbins_nuq,
                                     (const dequant_val_type_nuq *)
-                                    pd->dequant_val_nuq,
+                                    pd->dequant_val_nuq[dq],
                                     qcoeff, dqcoeff, eob,
                                     scan_order->scan, band);
 #else
@@ -3518,7 +3551,7 @@ static void encode_block_intra(int plane, int block, BLOCK_SIZE plane_bsize,
                                        p->quant_fp, pd->dequant,
                                        (const cumbins_type_nuq *)p->cumbins_nuq,
                                        (const dequant_val_type_nuq *)
-                                       pd->dequant_val_nuq,
+                                       pd->dequant_val_nuq[dq],
                                        qcoeff, dqcoeff, eob,
                                        scan_order->scan, band);
           else
@@ -3526,7 +3559,7 @@ static void encode_block_intra(int plane, int block, BLOCK_SIZE plane_bsize,
                                     p->quant, p->quant_shift, pd->dequant,
                                     (const cumbins_type_nuq *)p->cumbins_nuq,
                                     (const dequant_val_type_nuq *)
-                                    pd->dequant_val_nuq,
+                                    pd->dequant_val_nuq[dq],
                                     qcoeff, dqcoeff, eob,
                                     scan_order->scan, band);
 #else
@@ -3599,7 +3632,7 @@ static void encode_block_intra(int plane, int block, BLOCK_SIZE plane_bsize,
                                     p->quant_fp, pd->dequant,
                                     (const cumbins_type_nuq *)p->cumbins_nuq,
                                     (const dequant_val_type_nuq *)
-                                    pd->dequant_val_nuq,
+                                    pd->dequant_val_nuq[dq],
                                     qcoeff, dqcoeff, eob,
                                     scan_order->scan, band);
         else
@@ -3607,7 +3640,7 @@ static void encode_block_intra(int plane, int block, BLOCK_SIZE plane_bsize,
                                  p->quant, p->quant_shift, pd->dequant,
                                  (const cumbins_type_nuq *)p->cumbins_nuq,
                                  (const dequant_val_type_nuq *)
-                                 pd->dequant_val_nuq,
+                                 pd->dequant_val_nuq[dq],
                                  qcoeff, dqcoeff, eob,
                                  scan_order->scan, band);
 #else
@@ -3635,7 +3668,7 @@ static void encode_block_intra(int plane, int block, BLOCK_SIZE plane_bsize,
                                     p->quant_fp, pd->dequant,
                                     (const cumbins_type_nuq *)p->cumbins_nuq,
                                     (const dequant_val_type_nuq *)
-                                    pd->dequant_val_nuq,
+                                    pd->dequant_val_nuq[dq],
                                     qcoeff, dqcoeff, eob,
                                     scan_order->scan, band);
         else
@@ -3643,7 +3676,7 @@ static void encode_block_intra(int plane, int block, BLOCK_SIZE plane_bsize,
                                  p->quant, p->quant_shift, pd->dequant,
                                  (const cumbins_type_nuq *)p->cumbins_nuq,
                                  (const dequant_val_type_nuq *)
-                                 pd->dequant_val_nuq,
+                                 pd->dequant_val_nuq[dq],
                                  qcoeff, dqcoeff, eob,
                                  scan_order->scan, band);
 #else
@@ -3679,14 +3712,16 @@ static void encode_block_intra(int plane, int block, BLOCK_SIZE plane_bsize,
           vp9_quantize_fp_nuq(coeff, 256, x->skip_block,
                               p->quant_fp, pd->dequant,
                               (const cumbins_type_nuq *)p->cumbins_nuq,
-                              (const dequant_val_type_nuq *)pd->dequant_val_nuq,
+                              (const dequant_val_type_nuq *)
+                              pd->dequant_val_nuq[dq],
                               qcoeff, dqcoeff, eob,
                               scan_order->scan, band);
         else
           vp9_quantize_nuq(coeff, 256, x->skip_block,
                            p->quant, p->quant_shift, pd->dequant,
                            (const cumbins_type_nuq *)p->cumbins_nuq,
-                           (const dequant_val_type_nuq *)pd->dequant_val_nuq,
+                           (const dequant_val_type_nuq *)
+                           pd->dequant_val_nuq[dq],
                            qcoeff, dqcoeff, eob,
                            scan_order->scan, band);
 #else
@@ -3713,7 +3748,7 @@ static void encode_block_intra(int plane, int block, BLOCK_SIZE plane_bsize,
                                     p->quant_fp, pd->dequant,
                                     (const cumbins_type_nuq *)p->cumbins_nuq,
                                     (const dequant_val_type_nuq *)
-                                    pd->dequant_val_nuq,
+                                    pd->dequant_val_nuq[dq],
                                     qcoeff, dqcoeff, eob,
                                     scan_order->scan, band);
         else
@@ -3721,7 +3756,7 @@ static void encode_block_intra(int plane, int block, BLOCK_SIZE plane_bsize,
                                  p->quant, p->quant_shift, pd->dequant,
                                  (const cumbins_type_nuq *)p->cumbins_nuq,
                                  (const dequant_val_type_nuq *)
-                                 pd->dequant_val_nuq,
+                                 pd->dequant_val_nuq[dq],
                                  qcoeff, dqcoeff, eob,
                                  scan_order->scan, band);
 #else
@@ -3756,14 +3791,16 @@ static void encode_block_intra(int plane, int block, BLOCK_SIZE plane_bsize,
           vp9_quantize_fp_nuq(coeff, 64, x->skip_block,
                               p->quant_fp, pd->dequant,
                               (const cumbins_type_nuq *)p->cumbins_nuq,
-                              (const dequant_val_type_nuq *)pd->dequant_val_nuq,
+                              (const dequant_val_type_nuq *)
+                              pd->dequant_val_nuq[dq],
                               qcoeff, dqcoeff, eob,
                               scan_order->scan, band);
         else
           vp9_quantize_nuq(coeff, 64, x->skip_block,
                            p->quant, p->quant_shift, pd->dequant,
                            (const cumbins_type_nuq *)p->cumbins_nuq,
-                           (const dequant_val_type_nuq *)pd->dequant_val_nuq,
+                           (const dequant_val_type_nuq *)
+                           pd->dequant_val_nuq[dq],
                            qcoeff, dqcoeff, eob,
                            scan_order->scan, band);
 #else
@@ -3789,14 +3826,16 @@ static void encode_block_intra(int plane, int block, BLOCK_SIZE plane_bsize,
           vp9_quantize_fp_nuq(coeff, 256, x->skip_block,
                               p->quant_fp, pd->dequant,
                               (const cumbins_type_nuq *)p->cumbins_nuq,
-                              (const dequant_val_type_nuq *)pd->dequant_val_nuq,
+                              (const dequant_val_type_nuq *)
+                              pd->dequant_val_nuq[dq],
                               qcoeff, dqcoeff, eob,
                               scan_order->scan, band);
         else
           vp9_quantize_nuq(coeff, 256, x->skip_block,
                            p->quant, p->quant_shift, pd->dequant,
                            (const cumbins_type_nuq *)p->cumbins_nuq,
-                           (const dequant_val_type_nuq *)pd->dequant_val_nuq,
+                           (const dequant_val_type_nuq *)
+                           pd->dequant_val_nuq[dq],
                            qcoeff, dqcoeff, eob,
                            scan_order->scan, band);
 #else
@@ -3834,13 +3873,14 @@ static void encode_block_intra(int plane, int block, BLOCK_SIZE plane_bsize,
             vp9_quantize_fp_nuq(
                 coeff, 16, x->skip_block, p->quant_fp, pd->dequant,
                 (const cumbins_type_nuq *)p->cumbins_nuq,
-                (const dequant_val_type_nuq *)pd->dequant_val_nuq,
+                (const dequant_val_type_nuq *)pd->dequant_val_nuq[dq],
                 qcoeff, dqcoeff, eob, scan_order->scan, band);
           else
             vp9_quantize_nuq(coeff, 16, x->skip_block,
                              p->quant, p->quant_shift, pd->dequant,
                              (const cumbins_type_nuq *)p->cumbins_nuq,
-                             (const dequant_val_type_nuq *)pd->dequant_val_nuq,
+                             (const dequant_val_type_nuq *)
+                             pd->dequant_val_nuq[dq],
                              qcoeff, dqcoeff, eob,
                              scan_order->scan, band);
 #else
@@ -3869,14 +3909,16 @@ static void encode_block_intra(int plane, int block, BLOCK_SIZE plane_bsize,
           vp9_quantize_fp_nuq(coeff, 64, x->skip_block,
                               p->quant_fp, pd->dequant,
                               (const cumbins_type_nuq *)p->cumbins_nuq,
-                              (const dequant_val_type_nuq *)pd->dequant_val_nuq,
+                              (const dequant_val_type_nuq *)
+                              pd->dequant_val_nuq[dq],
                               qcoeff, dqcoeff, eob,
                               scan_order->scan, band);
         else
           vp9_quantize_nuq(coeff, 64, x->skip_block,
                            p->quant, p->quant_shift, pd->dequant,
                            (const cumbins_type_nuq *)p->cumbins_nuq,
-                           (const dequant_val_type_nuq *)pd->dequant_val_nuq,
+                           (const dequant_val_type_nuq *)
+                           pd->dequant_val_nuq[dq],
                            qcoeff, dqcoeff, eob,
                            scan_order->scan, band);
 #else
@@ -3905,14 +3947,16 @@ static void encode_block_intra(int plane, int block, BLOCK_SIZE plane_bsize,
           vp9_quantize_fp_nuq(coeff, 16, x->skip_block,
                               p->quant_fp, pd->dequant,
                               (const cumbins_type_nuq *)p->cumbins_nuq,
-                              (const dequant_val_type_nuq *)pd->dequant_val_nuq,
+                              (const dequant_val_type_nuq *)
+                              pd->dequant_val_nuq[dq],
                               qcoeff, dqcoeff, eob,
                               scan_order->scan, band);
         else
           vp9_quantize_nuq(coeff, 16, x->skip_block,
                            p->quant, p->quant_shift, pd->dequant,
                            (const cumbins_type_nuq *)p->cumbins_nuq,
-                           (const dequant_val_type_nuq *)pd->dequant_val_nuq,
+                           (const dequant_val_type_nuq *)
+                           pd->dequant_val_nuq[dq],
                            qcoeff, dqcoeff, eob,
                            scan_order->scan, band);
 #else

diff --git a/vp9/encoder/vp9_encoder.c b/vp9/encoder/vp9_encoder.c
index 4370b72e0ff59d357a8d4065a13e1e8eb5a4f9b5..79ef4bafb7d14bbc517ebc2b8da450fb041ddf49 100644 (file)
--- a/vp9/encoder/vp9_encoder.c
+++ b/vp9/encoder/vp9_encoder.c
@@ -1627,7 +1627,7 @@ void vp9_change_config(struct VP9_COMP *cpi, const VP9EncoderConfig *oxcf) {
 #endif  // CONFIG_VP9_HIGHBITDEPTH
 #if CONFIG_GLOBAL_MOTION
   cpi->mb.e_mbd.global_motion = cm->global_motion;
-#endif
+#endif  // CONFIG_GLOBAL_MOTION
 
   rc->baseline_gf_interval = DEFAULT_GF_INTERVAL;
 

diff --git a/vp9/encoder/vp9_quantize.c b/vp9/encoder/vp9_quantize.c
index 1ec2bfc23bd51c31489a217e7824f072a417609d..3aa5e59f8e87160f60bfb4dc9649dc74cf73ef04 100644 (file)
--- a/vp9/encoder/vp9_quantize.c
+++ b/vp9/encoder/vp9_quantize.c
@@ -1955,6 +1955,9 @@ void vp9_init_quantizer(VP9_COMP *cpi) {
   VP9_COMMON *const cm = &cpi->common;
   QUANTS *const quants = &cpi->quants;
   int i, q, quant;
+#if CONFIG_NEW_QUANT
+  int dq;
+#endif  // CONFIG_NEW_QUANT
 
   for (q = 0; q < QINDEX_RANGE; q++) {
     const int qzbin_factor = get_qzbin_factor(q, cm->bit_depth);
@@ -1988,15 +1991,17 @@ void vp9_init_quantizer(VP9_COMP *cpi) {
     }
 
 #if CONFIG_NEW_QUANT
-    for (i = 0; i < COEF_BANDS; i++) {
-      const int quant = cm->y_dequant[q][i != 0];
-      const int uvquant = cm->uv_dequant[q][i != 0];
-      vp9_get_dequant_val_nuq(quant, q == 0, i, cm->bit_depth,
-                              cm->y_dequant_val_nuq[q][i],
-                              quants->y_cumbins_nuq[q][i]);
-      vp9_get_dequant_val_nuq(uvquant, q == 0, i, cm->bit_depth,
-                              cm->uv_dequant_val_nuq[q][i],
-                              quants->uv_cumbins_nuq[q][i]);
+    for (dq = 0; dq < QUANT_PROFILES; dq ++) {
+      for (i = 0; i < COEF_BANDS; i++) {
+        const int quant = cm->y_dequant[q][i != 0];
+        const int uvquant = cm->uv_dequant[q][i != 0];
+        vp9_get_dequant_val_nuq(quant, q == 0, i,
+                                cm->y_dequant_val_nuq[dq][q][i],
+                                quants->y_cumbins_nuq[q][i], dq);
+        vp9_get_dequant_val_nuq(uvquant, q == 0, i,
+                                cm->uv_dequant_val_nuq[dq][q][i],
+                                quants->uv_cumbins_nuq[q][i], dq);
+      }
     }
 #endif  // CONFIG_NEW_QUANT
 
@@ -2039,15 +2044,17 @@ void vp9_init_quantizer(VP9_COMP *cpi) {
     }
 
 #if CONFIG_NEW_QUANT
-    for (i = 0; i < COEF_BANDS; i++) {
-      const int quant = cm->y_dequant_pxd[q][i != 0];
-      const int uvquant = cm->uv_dequant_pxd[q][i != 0];
-      vp9_get_dequant_val_nuq(quant, q == 0, i, cm->bit_depth,
-                              cm->y_dequant_val_nuq_pxd[q][i],
-                              quants->y_cumbins_nuq_pxd[q][i]);
-      vp9_get_dequant_val_nuq(uvquant, q == 0, i, cm->bit_depth,
-                              cm->uv_dequant_val_nuq_pxd[q][i],
-                              quants->uv_cumbins_nuq_pxd[q][i]);
+    for (dq = 0; dq < QUANT_PROFILES; dq ++) {
+      for (i = 0; i < COEF_BANDS; i++) {
+        const int quant = cm->y_dequant_pxd[q][i != 0];
+        const int uvquant = cm->uv_dequant_pxd[q][i != 0];
+        vp9_get_dequant_val_nuq(quant, q == 0, i,
+                                cm->y_dequant_val_nuq_pxd[dq][q][i],
+                                quants->y_cumbins_nuq_pxd[q][i], dq);
+        vp9_get_dequant_val_nuq(uvquant, q == 0, i,
+                                cm->uv_dequant_val_nuq_pxd[dq][q][i],
+                                quants->uv_cumbins_nuq_pxd[q][i], dq);
+      }
     }
 #endif  // CONFIG_NEW_QUANT
 #endif  // CONFIG_TX_SKIP
@@ -2062,6 +2069,9 @@ void vp9_init_plane_quantizers(VP9_COMP *cpi, MACROBLOCK *x) {
   const int qindex = vp9_get_qindex(&cm->seg, segment_id, cm->base_qindex);
   const int rdmult = vp9_compute_rd_mult(cpi, qindex + cm->y_dc_delta_q);
   int i;
+  #if CONFIG_NEW_QUANT
+  int dq;
+  #endif  // CONFIG_NEW_QUANT
 
   // Y
   x->plane[0].quant = quants->y_quant[qindex];
@@ -2073,7 +2083,11 @@ void vp9_init_plane_quantizers(VP9_COMP *cpi, MACROBLOCK *x) {
   xd->plane[0].dequant = cm->y_dequant[qindex];
 #if CONFIG_NEW_QUANT
   x->plane[0].cumbins_nuq = quants->y_cumbins_nuq[qindex];
-  xd->plane[0].dequant_val_nuq = cm->y_dequant_val_nuq[qindex];
+  for (dq = 0; dq < QUANT_PROFILES; dq ++) {
+    xd->plane[0].dequant_val_nuq[dq] =
+        cm->y_dequant_val_nuq[dq][qindex];
+  }
+
 #endif  // CONFIG_NEW_QUANT
 #if CONFIG_TX_SKIP
   x->plane[0].quant_pxd = quants->y_quant_pxd[qindex];
@@ -2085,7 +2099,11 @@ void vp9_init_plane_quantizers(VP9_COMP *cpi, MACROBLOCK *x) {
   xd->plane[0].dequant_pxd = cm->y_dequant_pxd[qindex];
 #if CONFIG_NEW_QUANT
   x->plane[0].cumbins_nuq_pxd = quants->y_cumbins_nuq_pxd[qindex];
-  xd->plane[0].dequant_val_nuq_pxd = cm->y_dequant_val_nuq_pxd[qindex];
+  for (dq = 0; dq < QUANT_PROFILES; dq ++) {
+    xd->plane[0].dequant_val_nuq_pxd[dq] =
+        cm->y_dequant_val_nuq_pxd[dq][qindex];
+  }
+
 #endif  // CONFIG_NEW_QUANT
 #endif  // CONFIG_TX_SKIP
 
@@ -2103,7 +2121,10 @@ void vp9_init_plane_quantizers(VP9_COMP *cpi, MACROBLOCK *x) {
     xd->plane[i].dequant = cm->uv_dequant[qindex];
 #if CONFIG_NEW_QUANT
     x->plane[i].cumbins_nuq = quants->uv_cumbins_nuq[qindex];
-    xd->plane[i].dequant_val_nuq = cm->uv_dequant_val_nuq[qindex];
+    for (dq = 0; dq < QUANT_PROFILES; dq ++) {
+      xd->plane[i].dequant_val_nuq[dq] =
+          cm->uv_dequant_val_nuq[dq][qindex];
+    }
 #endif  // CONFIG_NEW_QUANT
 #if CONFIG_TX_SKIP
     x->plane[i].quant_pxd = quants->uv_quant_pxd[qindex];
@@ -2115,7 +2136,10 @@ void vp9_init_plane_quantizers(VP9_COMP *cpi, MACROBLOCK *x) {
     xd->plane[i].dequant_pxd = cm->uv_dequant_pxd[qindex];
 #if CONFIG_NEW_QUANT
     x->plane[i].cumbins_nuq_pxd = quants->uv_cumbins_nuq_pxd[qindex];
-    xd->plane[i].dequant_val_nuq_pxd = cm->uv_dequant_val_nuq_pxd[qindex];
+    for (dq = 0; dq < QUANT_PROFILES; dq ++) {
+      xd->plane[i].dequant_val_nuq_pxd[dq] =
+          cm->uv_dequant_val_nuq_pxd[dq][qindex];
+    }
 #endif  // CONFIG_NEW_QUANT
 #endif  // CONFIG_TX_SKIP