Support for delta-q at superblock level

Change-Id: I4128af44776d1f361bddc1fdffb75ed2224dbfa5

aomenc.c

@@ -391,10 +391,17 @@ static const arg_def_t frame_parallel_decoding =
     ARG_DEF(NULL, "frame-parallel", 1,
             "Enable frame parallel decodability features "
             "(0: false (default), 1: true)");
+#if CONFIG_DELTA_Q
+static const arg_def_t aq_mode = ARG_DEF(
+    NULL, "aq-mode", 1,
+    "Adaptive quantization mode (0: off (default), 1: variance 2: complexity, "
+    "3: cyclic refresh)");
+#else
 static const arg_def_t aq_mode = ARG_DEF(
     NULL, "aq-mode", 1,
     "Adaptive quantization mode (0: off (default), 1: variance 2: complexity, "
     "3: cyclic refresh, 4: equator360)");
+#endif
 static const arg_def_t frame_periodic_boost =
     ARG_DEF(NULL, "frame-boost", 1,
             "Enable frame periodic boost (0: off (default), 1: on)");

av1/common/blockd.h

@@ -163,6 +163,9 @@ typedef struct {
   int_mv mv[2];
   /* deringing gain *per-superblock* */
   int8_t dering_gain;
+#if CONFIG_DELTA_Q
+  int current_q_index;
+#endif
 } MB_MODE_INFO;
 
 typedef struct MODE_INFO {
@@ -290,6 +293,11 @@ typedef struct macroblockd {
   int corrupted;
 
   struct aom_internal_error_info *error_info;
+#if CONFIG_DELTA_Q
+  int prev_qindex;
+  int delta_qindex;
+  int current_qindex;
+#endif
 } MACROBLOCKD;
 
 static INLINE BLOCK_SIZE get_subsize(BLOCK_SIZE bsize,

av1/common/onyxc_int.h

@@ -343,6 +343,9 @@ typedef struct AV1Common {
 #if CONFIG_DERING
   int dering_level;
 #endif
+#if CONFIG_DELTA_Q
+  int delta_q_present_flag;
+#endif
 } AV1_COMMON;
 
 // TODO(hkuang): Don't need to lock the whole pool after implementing atomic

av1/decoder/decodeframe.c

@@ -506,6 +506,26 @@ static void decode_block(AV1Decoder *const pbi, MACROBLOCKD *const xd,
 
   av1_read_mode_info(pbi, xd, mi_row, mi_col, r, x_mis, y_mis);
 
+#if CONFIG_DELTA_Q
+  if (cm->delta_q_present_flag) {
+    int i;
+    for (i = 0; i < MAX_SEGMENTS; i++) {
+      xd->plane[0].seg_dequant[i][0] =
+          av1_dc_quant(xd->current_qindex, cm->y_dc_delta_q, cm->bit_depth);
+      xd->plane[0].seg_dequant[i][1] =
+          av1_ac_quant(xd->current_qindex, 0, cm->bit_depth);
+      xd->plane[1].seg_dequant[i][0] =
+          av1_dc_quant(xd->current_qindex, cm->uv_dc_delta_q, cm->bit_depth);
+      xd->plane[1].seg_dequant[i][1] =
+          av1_ac_quant(xd->current_qindex, cm->uv_ac_delta_q, cm->bit_depth);
+      xd->plane[2].seg_dequant[i][0] =
+          av1_dc_quant(xd->current_qindex, cm->uv_dc_delta_q, cm->bit_depth);
+      xd->plane[2].seg_dequant[i][1] =
+          av1_ac_quant(xd->current_qindex, cm->uv_ac_delta_q, cm->bit_depth);
+    }
+  }
+#endif
+
   if (mbmi->skip) {
     dec_reset_skip_context(xd);
   }
@@ -1966,6 +1986,27 @@ static size_t read_uncompressed_header(AV1Decoder *pbi,
 
   setup_segmentation(cm, rb);
 
+#if CONFIG_DELTA_Q
+  {
+    struct segmentation *const seg = &cm->seg;
+    int segment_quantizer_active = 0;
+    for (i = 0; i < MAX_SEGMENTS; i++) {
+      if (segfeature_active(seg, i, SEG_LVL_ALT_Q)) {
+        segment_quantizer_active = 1;
+      }
+    }
+
+    if (segment_quantizer_active == 0) {
+      cm->delta_q_present_flag = aom_rb_read_bit(rb);
+    } else {
+      cm->delta_q_present_flag = 0;
+    }
+    if (cm->delta_q_present_flag) {
+      xd->prev_qindex = cm->base_qindex;
+    }
+  }
+#endif
+
   for (i = 0; i < MAX_SEGMENTS; ++i) {
     const int qindex = CONFIG_MISC_FIXES && cm->seg.enabled
                            ? av1_get_qindex(&cm->seg, i, cm->base_qindex)

av1/decoder/decodemv.c

@@ -459,6 +459,38 @@ static void read_intra_frame_mode_info(AV1_COMMON *const cm,
 
   mbmi->segment_id = read_intra_segment_id(cm, xd, mi_offset, x_mis, y_mis, r);
   mbmi->skip = read_skip(cm, xd, mbmi->segment_id, r);
+
+#if CONFIG_DELTA_Q
+  if (cm->delta_q_present_flag) {
+    int b_col = mi_col & 7;
+    int b_row = mi_row & 7;
+    int read_delta_q_flag = (b_col == 0 && b_row == 0);
+    if ((bsize != BLOCK_64X64 || mbmi->skip == 0) && read_delta_q_flag) {
+      int sign, abs, tmp, delta_qindex;
+
+      abs = 0;
+      tmp = aom_read_bit(r, ACCT_STR);
+      while (tmp == 0 && abs < 2) {
+        tmp = aom_read_bit(r, ACCT_STR);
+        abs++;
+      }
+      if (tmp == 0) {
+        abs = aom_read_literal(r, 6, ACCT_STR);
+      }
+
+      if (abs) {
+        sign = aom_read_bit(r, ACCT_STR);
+      } else {
+        sign = 1;
+      }
+
+      delta_qindex = sign ? -abs : abs;
+      xd->current_qindex = xd->prev_qindex + delta_qindex;
+      xd->prev_qindex = xd->current_qindex;
+    }
+  }
+#endif
+
   mbmi->tx_size = read_tx_size(cm, xd, 1, r);
   mbmi->ref_frame[0] = INTRA_FRAME;
   mbmi->ref_frame[1] = NONE;
@@ -1111,6 +1143,35 @@ static void read_inter_frame_mode_info(AV1Decoder *const pbi,
   mbmi->mv[1].as_int = 0;
   mbmi->segment_id = read_inter_segment_id(cm, xd, mi_row, mi_col, r);
   mbmi->skip = read_skip(cm, xd, mbmi->segment_id, r);
+#if CONFIG_DELTA_Q
+  if (cm->delta_q_present_flag) {
+    BLOCK_SIZE bsize = mbmi->sb_type;
+    int b_col = mi_col & 7;
+    int b_row = mi_row & 7;
+    int read_delta_q_flag = (b_col == 0 && b_row == 0);
+    if ((bsize != BLOCK_64X64 || mbmi->skip == 0) && read_delta_q_flag) {
+      int sign, abs, tmp, delta_qindex;
+
+      abs = 0;
+      tmp = aom_read_bit(r, ACCT_STR);
+      while (tmp == 0 && abs < 2) {
+        tmp = aom_read_bit(r, ACCT_STR);
+        abs++;
+      }
+      if (tmp == 0) {
+        abs = aom_read_literal(r, 6, ACCT_STR);
+      }
+      if (abs) {
+        sign = aom_read_bit(r, ACCT_STR);
+      } else {
+        sign = 1;
+      }
+      delta_qindex = sign ? -abs : abs;
+      xd->current_qindex = xd->prev_qindex + delta_qindex;
+      xd->prev_qindex = xd->current_qindex;
+    }
+  }
+#endif
   inter_block = read_is_inter_block(cm, xd, mbmi->segment_id, r);
   mbmi->tx_size = read_tx_size(cm, xd, !mbmi->skip || !inter_block, r);
 

av1/encoder/bitstream.c

@@ -298,6 +298,22 @@ static int write_skip(const AV1_COMMON *cm, const MACROBLOCKD *xd,
   }
 }
 
+#if CONFIG_DELTA_Q
+static void write_delta_qindex(int delta_qindex, aom_writer *w) {
+  int sign = delta_qindex < 0;
+  int abs = sign ? -delta_qindex : delta_qindex;
+  if (abs < 3) {
+    aom_write_literal(w, 1, abs + 1);
+  } else {
+    aom_write_literal(w, 0, 3);
+    aom_write_literal(w, abs, 6);
+  }
+  if (abs > 0) {
+    aom_write_bit(w, sign);
+  }
+}
+#endif
+
 static void update_skip_probs(AV1_COMMON *cm, aom_writer *w,
                               FRAME_COUNTS *counts) {
   int k;
@@ -692,8 +708,14 @@ static void pack_inter_mode_mvs(AV1_COMP *cpi, const MODE_INFO *mi,
 #if !CONFIG_REF_MV
   const nmv_context *nmvc = &cm->fc->nmvc;
 #endif
+
+#if CONFIG_DELTA_Q
+  MACROBLOCK *const x = &cpi->td.mb;
+  MACROBLOCKD *const xd = &x->e_mbd;
+#else
   const MACROBLOCK *const x = &cpi->td.mb;
   const MACROBLOCKD *const xd = &x->e_mbd;
+#endif
   const struct segmentation *const seg = &cm->seg;
 #if CONFIG_MISC_FIXES
   const struct segmentation_probs *const segp = &cm->fc->seg;
@@ -723,6 +745,19 @@ static void pack_inter_mode_mvs(AV1_COMP *cpi, const MODE_INFO *mi,
 
   skip = write_skip(cm, xd, segment_id, mi, w);
 
+#if CONFIG_DELTA_Q
+  if (cm->delta_q_present_flag) {
+    int mi_row = (-xd->mb_to_top_edge) >> 6;
+    int mi_col = (-xd->mb_to_left_edge) >> 6;
+    int super_block_upper_left = ((mi_row & 7) == 0) && ((mi_col & 7) == 0);
+    if ((bsize != BLOCK_64X64 || skip == 0) && super_block_upper_left) {
+      int delta_qindex = mbmi->current_q_index - xd->prev_qindex;
+      write_delta_qindex(delta_qindex, w);
+      xd->prev_qindex = mbmi->current_q_index;
+    }
+  }
+#endif
+
   if (!segfeature_active(seg, segment_id, SEG_LVL_REF_FRAME))
     aom_write(w, is_inter, av1_get_intra_inter_prob(cm, xd));
 
@@ -879,8 +914,14 @@ static void pack_inter_mode_mvs(AV1_COMP *cpi, const MODE_INFO *mi,
   }
 }
 
+#if CONFIG_DELTA_Q
+static void write_mb_modes_kf(const AV1_COMMON *cm, MACROBLOCKD *xd,
+                              MODE_INFO **mi_8x8, aom_writer *w) {
+  int skip;
+#else
 static void write_mb_modes_kf(const AV1_COMMON *cm, const MACROBLOCKD *xd,
                               MODE_INFO **mi_8x8, aom_writer *w) {
+#endif
   const struct segmentation *const seg = &cm->seg;
 #if CONFIG_MISC_FIXES
   const struct segmentation_probs *const segp = &cm->fc->seg;
@@ -895,7 +936,21 @@ static void write_mb_modes_kf(const AV1_COMMON *cm, const MACROBLOCKD *xd,
 
   if (seg->update_map) write_segment_id(w, seg, segp, mbmi->segment_id);
 
+#if CONFIG_DELTA_Q
+  skip = write_skip(cm, xd, mbmi->segment_id, mi, w);
+  if (cm->delta_q_present_flag) {
+    int mi_row = (-xd->mb_to_top_edge) >> 6;
+    int mi_col = (-xd->mb_to_left_edge) >> 6;
+    int super_block_upper_left = ((mi_row & 7) == 0) && ((mi_col & 7) == 0);
+    if ((bsize != BLOCK_64X64 || skip == 0) && super_block_upper_left) {
+      int delta_qindex = mbmi->current_q_index - xd->prev_qindex;
+      write_delta_qindex(delta_qindex, w);
+      xd->prev_qindex = mbmi->current_q_index;
+    }
+  }
+#else
   write_skip(cm, xd, mbmi->segment_id, mi, w);
+#endif
 
   if (bsize >= BLOCK_8X8 && cm->tx_mode == TX_MODE_SELECT &&
       !xd->lossless[mbmi->segment_id])
@@ -1109,6 +1164,12 @@ static void write_modes(AV1_COMP *cpi, const TileInfo *const tile,
   MACROBLOCKD *const xd = &cpi->td.mb.e_mbd;
   int mi_row, mi_col;
 
+#if CONFIG_DELTA_Q
+  if (cpi->common.delta_q_present_flag) {
+    xd->prev_qindex = cpi->common.base_qindex;
+  }
+#endif
+
   for (mi_row = tile->mi_row_start; mi_row < tile->mi_row_end;
        mi_row += MAX_MIB_SIZE) {
     av1_zero(xd->left_seg_context);
@@ -1946,6 +2007,26 @@ static void write_uncompressed_header(AV1_COMP *cpi,
 #endif  // CONFIG_DERING
   encode_quantization(cm, wb);
   encode_segmentation(cm, xd, wb);
+#if CONFIG_DELTA_Q
+  {
+    int i;
+    struct segmentation *const seg = &cm->seg;
+    int segment_quantizer_active = 0;
+    for (i = 0; i < MAX_SEGMENTS; i++) {
+      if (segfeature_active(seg, i, SEG_LVL_ALT_Q)) {
+        segment_quantizer_active = 1;
+      }
+    }
+    if (segment_quantizer_active == 0) {
+      cm->delta_q_present_flag = cpi->oxcf.aq_mode == DELTA_AQ;
+      aom_wb_write_bit(wb, cm->delta_q_present_flag);
+      if (cm->delta_q_present_flag) {
+        xd->prev_qindex = cm->base_qindex;
+      }
+    }
+  }
+#endif
+
 #if CONFIG_MISC_FIXES
   if (!cm->seg.enabled && xd->lossless[0])
     cm->tx_mode = TX_4X4;

av1/encoder/encodeframe.c

@@ -957,7 +957,12 @@ static void update_state(const AV1_COMP *const cpi, ThreadData *td,
         xd->mi[x_idx + y * mis] = mi_addr;
       }
 
+#if CONFIG_DELTA_Q
+  if (cpi->oxcf.aq_mode > NO_AQ && cpi->oxcf.aq_mode < DELTA_AQ)
+    av1_init_plane_quantizers(cpi, x);
+#else
   if (cpi->oxcf.aq_mode) av1_init_plane_quantizers(cpi, x);
+#endif
 
   if (is_inter_block(mbmi) && mbmi->sb_type < BLOCK_8X8) {
     mbmi->mv[0].as_int = mi->bmi[3].as_mv[0].as_int;
@@ -2560,6 +2565,22 @@ static void encode_rd_sb_row(AV1_COMP *cpi, ThreadData *td,
       seg_skip = segfeature_active(seg, segment_id, SEG_LVL_SKIP);
     }
 
+#if CONFIG_DELTA_Q
+    if (cpi->oxcf.aq_mode == DELTA_AQ) {
+      int sb_row = mi_row >> 3;
+      int sb_col = mi_col >> 3;
+      int sb_stride = (cm->width + MAX_SB_SIZE - 1) >> MAX_SB_SIZE_LOG2;
+      int index = ((sb_row * sb_stride + sb_col + 8) & 31) - 16;
+      int offset_qindex = index < 0 ? -index - 8 : index - 8;
+      int current_qindex = clamp(cm->base_qindex + offset_qindex, 1, 255);
+      xd->delta_qindex = current_qindex - cm->base_qindex;
+      set_offsets(cpi, tile_info, x, mi_row, mi_col, BLOCK_64X64);
+      xd->mi[0]->mbmi.current_q_index = current_qindex;
+      xd->mi[0]->mbmi.segment_id = 0;
+      av1_init_plane_quantizers(cpi, x);
+    }
+#endif
+
     x->source_variance = UINT_MAX;
     if (sf->partition_search_type == FIXED_PARTITION || seg_skip) {
       const BLOCK_SIZE bsize =

av1/encoder/encoder.h

@@ -132,6 +132,9 @@ typedef enum {
   VARIANCE_AQ = 1,
   COMPLEXITY_AQ = 2,
   CYCLIC_REFRESH_AQ = 3,
+#if CONFIG_DELTA_Q
+  DELTA_AQ = 4,
+#endif
   AQ_MODE_COUNT  // This should always be the last member of the enum
 } AQ_MODE;
 

av1/encoder/quantize.c

@@ -382,7 +382,15 @@ void av1_init_plane_quantizers(const AV1_COMP *cpi, MACROBLOCK *x) {
   MACROBLOCKD *const xd = &x->e_mbd;
   const QUANTS *const quants = &cpi->quants;
   const int segment_id = xd->mi[0]->mbmi.segment_id;
+
+#if CONFIG_DELTA_Q
+  int current_q_index = cpi->oxcf.aq_mode == DELTA_AQ
+                            ? cm->base_qindex + xd->delta_qindex
+                            : cm->base_qindex;
+  const int qindex = av1_get_qindex(&cm->seg, segment_id, current_q_index);
+#else
   const int qindex = av1_get_qindex(&cm->seg, segment_id, cm->base_qindex);
+#endif
   const int rdmult = av1_compute_rd_mult(cpi, qindex + cm->y_dc_delta_q);
   int i;
 #if CONFIG_AOM_QM

configure

@@ -270,6 +270,7 @@ EXPERIMENT_LIST="
     palette
     frame_size
     filter_7bit
+    delta_q
 "
 CONFIG_LIST="
     dependency_tracking