1 files changed, 56 insertions, 63 deletions

diff --git a/vp9/encoder/vp9_rdopt.c b/vp9/encoder/vp9_rdopt.c
index ba521afa0..56a080377 100644
--- a/vp9/encoder/vp9_rdopt.c
+++ b/vp9/encoder/vp9_rdopt.c
@@ -161,10 +161,17 @@ void vp9_init_me_luts() {
   }
 }
 
-static int compute_rd_mult(int qindex) {
+int vp9_compute_rd_mult(VP9_COMP *cpi, int qindex) {
   const int q = vp9_dc_quant(qindex, 0);
   // TODO(debargha): Adjust the function below
-  return (88 * q * q / 25);
+  int rdmult = 88 * q * q / 25;
+  if (cpi->pass == 2 && (cpi->common.frame_type != KEY_FRAME)) {
+    if (cpi->twopass.next_iiratio > 31)
+      rdmult += (rdmult * rd_iifactor[31]) >> 4;
+    else
+      rdmult += (rdmult * rd_iifactor[cpi->twopass.next_iiratio]) >> 4;
+  }
+  return rdmult;
 }
 
 static int compute_rd_thresh_factor(int qindex) {
@@ -181,41 +188,47 @@ void vp9_initialize_me_consts(VP9_COMP *cpi, int qindex) {
   cpi->mb.sadperbit4 = sad_per_bit4lut[qindex];
 }
 
-static void set_block_thresholds(VP9_COMP *cpi, int qindex) {
-  int q, i, bsize;
-  q = compute_rd_thresh_factor(qindex);
+static void set_block_thresholds(VP9_COMP *cpi) {
+  int i, bsize, segment_id;
+  VP9_COMMON *cm = &cpi->common;
+
+  for (segment_id = 0; segment_id < MAX_SEGMENTS; ++segment_id) {
+    int q;
+    int segment_qindex = vp9_get_qindex(&cm->seg, segment_id, cm->base_qindex);
+    segment_qindex = clamp(segment_qindex + cm->y_dc_delta_q, 0, MAXQ);
+    q = compute_rd_thresh_factor(segment_qindex);
 
-  for (bsize = 0; bsize < BLOCK_SIZES; ++bsize) {
-    for (i = 0; i < MAX_MODES; ++i) {
+    for (bsize = 0; bsize < BLOCK_SIZES; ++bsize) {
       // Threshold here seem unecessarily harsh but fine given actual
       // range of values used for cpi->sf.thresh_mult[]
       int thresh_max = INT_MAX / (q * rd_thresh_block_size_factor[bsize]);
 
-      if (cpi->sf.thresh_mult[i] < thresh_max) {
-        cpi->rd_threshes[bsize][i] =
-            cpi->sf.thresh_mult[i] * q *
-            rd_thresh_block_size_factor[bsize] / 4;
-      } else {
-        cpi->rd_threshes[bsize][i] = INT_MAX;
+      for (i = 0; i < MAX_MODES; ++i) {
+        if (cpi->sf.thresh_mult[i] < thresh_max) {
+          cpi->rd_threshes[segment_id][bsize][i] =
+              cpi->sf.thresh_mult[i] * q *
+              rd_thresh_block_size_factor[bsize] / 4;
+        } else {
+          cpi->rd_threshes[segment_id][bsize][i] = INT_MAX;
+        }
       }
-    }
 
-    for (i = 0; i < MAX_REFS; ++i) {
-      int thresh_max = INT_MAX / (q * rd_thresh_block_size_factor[bsize]);
-
-      if (cpi->sf.thresh_mult_sub8x8[i] < thresh_max) {
-        cpi->rd_thresh_sub8x8[bsize][i] =
-            cpi->sf.thresh_mult_sub8x8[i] * q *
-            rd_thresh_block_size_factor[bsize] / 4;
-      } else {
-        cpi->rd_thresh_sub8x8[bsize][i] = INT_MAX;
+      for (i = 0; i < MAX_REFS; ++i) {
+        if (cpi->sf.thresh_mult_sub8x8[i] < thresh_max) {
+          cpi->rd_thresh_sub8x8[segment_id][bsize][i] =
+              cpi->sf.thresh_mult_sub8x8[i] * q *
+              rd_thresh_block_size_factor[bsize] / 4;
+        } else {
+          cpi->rd_thresh_sub8x8[segment_id][bsize][i] = INT_MAX;
+        }
       }
     }
   }
 }
 
-void vp9_initialize_rd_consts(VP9_COMP *cpi, int qindex) {
-  int i;
+void vp9_initialize_rd_consts(VP9_COMP *cpi) {
+  VP9_COMMON *cm = &cpi->common;
+  int qindex, i;
 
   vp9_clear_system_state();  // __asm emms;
 
@@ -223,23 +236,17 @@ void vp9_initialize_rd_consts(VP9_COMP *cpi, int qindex) {
   // for key frames, golden frames and arf frames.
   // if (cpi->common.refresh_golden_frame ||
   //     cpi->common.refresh_alt_ref_frame)
-  qindex = clamp(qindex, 0, MAXQ);
+  qindex = clamp(cm->base_qindex + cm->y_dc_delta_q, 0, MAXQ);
 
   cpi->RDDIV = RDDIV_BITS;  // in bits (to multiply D by 128)
-  cpi->RDMULT = compute_rd_mult(qindex);
-  if (cpi->pass == 2 && (cpi->common.frame_type != KEY_FRAME)) {
-    if (cpi->twopass.next_iiratio > 31)
-      cpi->RDMULT += (cpi->RDMULT * rd_iifactor[31]) >> 4;
-    else
-      cpi->RDMULT +=
-          (cpi->RDMULT * rd_iifactor[cpi->twopass.next_iiratio]) >> 4;
-  }
+  cpi->RDMULT = vp9_compute_rd_mult(cpi, qindex);
+
   cpi->mb.errorperbit = cpi->RDMULT / RD_MULT_EPB_RATIO;
   cpi->mb.errorperbit += (cpi->mb.errorperbit == 0);
 
   vp9_set_speed_features(cpi);
 
-  set_block_thresholds(cpi, qindex);
+  set_block_thresholds(cpi);
 
   fill_token_costs(cpi->mb.token_costs, cpi->common.fc.coef_probs);
 
@@ -251,7 +258,7 @@ void vp9_initialize_rd_consts(VP9_COMP *cpi, int qindex) {
   /*rough estimate for costing*/
   vp9_init_mode_costs(cpi);
 
-  if (cpi->common.frame_type != KEY_FRAME) {
+  if (!frame_is_intra_only(&cpi->common)) {
     vp9_build_nmv_cost_table(
         cpi->mb.nmvjointcost,
         cpi->mb.e_mbd.allow_high_precision_mv ?
@@ -2231,9 +2238,6 @@ static void store_coding_context(MACROBLOCK *x, PICK_MODE_CONTEXT *ctx,
   ctx->comp_pred_diff   = (int)comp_pred_diff[COMP_PREDICTION_ONLY];
   ctx->hybrid_pred_diff = (int)comp_pred_diff[HYBRID_PREDICTION];
 
-  vpx_memcpy(ctx->zcoeff_blk, x->zcoeff_blk[xd->this_mi->mbmi.tx_size],
-             sizeof(ctx->zcoeff_blk));
-
   vpx_memcpy(ctx->tx_rd_diff, tx_size_diff, sizeof(ctx->tx_rd_diff));
   vpx_memcpy(ctx->best_filter_diff, best_filter_diff,
              sizeof(*best_filter_diff) * (SWITCHABLE_FILTERS + 1));
@@ -3149,11 +3153,8 @@ int64_t vp9_rd_pick_inter_mode_sb(VP9_COMP *cpi, MACROBLOCK *x,
   const int bws = num_8x8_blocks_wide_lookup[bsize] / 2;
   const int bhs = num_8x8_blocks_high_lookup[bsize] / 2;
   int best_skip2 = 0;
-  unsigned char best_zcoeff_blk[256] = { 0 };
 
   x->skip_encode = cpi->sf.skip_encode_frame && xd->q_index < QIDX_SKIP_THRESH;
-  vp9_zero(x->zcoeff_blk);
-  vp9_zero(ctx->zcoeff_blk);
 
   // Everywhere the flag is set the error is much higher than its neighbors.
   ctx->frames_with_high_error = 0;
@@ -3270,9 +3271,9 @@ int64_t vp9_rd_pick_inter_mode_sb(VP9_COMP *cpi, MACROBLOCK *x,
       continue;
 
     // Test best rd so far against threshold for trying this mode.
-    if ((best_rd < ((int64_t)cpi->rd_threshes[bsize][mode_index] *
+    if ((best_rd < ((int64_t)cpi->rd_threshes[segment_id][bsize][mode_index] *
                      cpi->rd_thresh_freq_fact[bsize][mode_index] >> 5)) ||
-        cpi->rd_threshes[bsize][mode_index] == INT_MAX)
+        cpi->rd_threshes[segment_id][bsize][mode_index] == INT_MAX)
       continue;
 
     // Do not allow compound prediction if the segment level reference
@@ -3584,8 +3585,8 @@ int64_t vp9_rd_pick_inter_mode_sb(VP9_COMP *cpi, MACROBLOCK *x,
         best_rd = this_rd;
         best_mbmode = *mbmi;
         best_skip2 = this_skip2;
-        vpx_memcpy(best_zcoeff_blk, x->zcoeff_blk[mbmi->tx_size],
-                   sizeof(best_zcoeff_blk));
+        vpx_memcpy(ctx->zcoeff_blk, x->zcoeff_blk[mbmi->tx_size],
+                   sizeof(ctx->zcoeff_blk));
 
         // TODO(debargha): enhance this test with a better distortion prediction
         // based on qp, activity mask and history
@@ -3751,9 +3752,6 @@ int64_t vp9_rd_pick_inter_mode_sb(VP9_COMP *cpi, MACROBLOCK *x,
   *mbmi = best_mbmode;
   x->skip |= best_skip2;
 
-  vpx_memcpy(x->zcoeff_blk[mbmi->tx_size], best_zcoeff_blk,
-             sizeof(best_zcoeff_blk));
-
   for (i = 0; i < NB_PREDICTION_TYPES; ++i) {
     if (best_pred_rd[i] == INT64_MAX)
       best_pred_diff[i] = INT_MIN;
@@ -3847,11 +3845,9 @@ int64_t vp9_rd_pick_inter_mode_sub8x8(VP9_COMP *cpi, MACROBLOCK *x,
   int_mv seg_mvs[4][MAX_REF_FRAMES];
   b_mode_info best_bmodes[4];
   int best_skip2 = 0;
-  unsigned char best_zcoeff_blk[256] = { 0 };
 
   x->skip_encode = cpi->sf.skip_encode_frame && xd->q_index < QIDX_SKIP_THRESH;
   vp9_zero(x->zcoeff_blk);
-  vp9_zero(ctx->zcoeff_blk);
 
   for (i = 0; i < 4; i++) {
     int j;
@@ -3945,9 +3941,10 @@ int64_t vp9_rd_pick_inter_mode_sub8x8(VP9_COMP *cpi, MACROBLOCK *x,
       continue;
 
     // Test best rd so far against threshold for trying this mode.
-    if ((best_rd < ((int64_t)cpi->rd_thresh_sub8x8[bsize][mode_index] *
-                     cpi->rd_thresh_freq_sub8x8[bsize][mode_index] >> 5)) ||
-        cpi->rd_thresh_sub8x8[bsize][mode_index] == INT_MAX)
+    if ((best_rd <
+         ((int64_t)cpi->rd_thresh_sub8x8[segment_id][bsize][mode_index] *
+          cpi->rd_thresh_freq_sub8x8[bsize][mode_index] >> 5)) ||
+        cpi->rd_thresh_sub8x8[segment_id][bsize][mode_index] == INT_MAX)
       continue;
 
     // Do not allow compound prediction if the segment level reference
@@ -4092,10 +4089,10 @@ int64_t vp9_rd_pick_inter_mode_sub8x8(VP9_COMP *cpi, MACROBLOCK *x,
       int uv_skippable;
 
       this_rd_thresh = (ref_frame == LAST_FRAME) ?
-          cpi->rd_thresh_sub8x8[bsize][THR_LAST] :
-          cpi->rd_thresh_sub8x8[bsize][THR_ALTR];
+          cpi->rd_thresh_sub8x8[segment_id][bsize][THR_LAST] :
+          cpi->rd_thresh_sub8x8[segment_id][bsize][THR_ALTR];
       this_rd_thresh = (ref_frame == GOLDEN_FRAME) ?
-          cpi->rd_thresh_sub8x8[bsize][THR_GOLD] : this_rd_thresh;
+          cpi->rd_thresh_sub8x8[segment_id][bsize][THR_GOLD] : this_rd_thresh;
       xd->this_mi->mbmi.tx_size = TX_4X4;
 
       cpi->rd_filter_cache[SWITCHABLE_FILTERS] = INT64_MAX;
@@ -4328,8 +4325,8 @@ int64_t vp9_rd_pick_inter_mode_sub8x8(VP9_COMP *cpi, MACROBLOCK *x,
                    RDCOST(x->rdmult, x->rddiv, rate_uv, distortion_uv);
         best_mbmode = *mbmi;
         best_skip2 = this_skip2;
-        vpx_memcpy(best_zcoeff_blk, x->zcoeff_blk[mbmi->tx_size],
-                   sizeof(best_zcoeff_blk));
+        vpx_memcpy(ctx->zcoeff_blk, x->zcoeff_blk[mbmi->tx_size],
+                   sizeof(ctx->zcoeff_blk));
 
         for (i = 0; i < 4; i++)
           best_bmodes[i] = xd->this_mi->bmi[i];
@@ -4492,9 +4489,6 @@ int64_t vp9_rd_pick_inter_mode_sub8x8(VP9_COMP *cpi, MACROBLOCK *x,
     mbmi->mv[1].as_int = xd->this_mi->bmi[3].as_mv[1].as_int;
   }
 
-  vpx_memcpy(x->zcoeff_blk[mbmi->tx_size], best_zcoeff_blk,
-             sizeof(best_zcoeff_blk));
-
   for (i = 0; i < NB_PREDICTION_TYPES; ++i) {
     if (best_pred_rd[i] == INT64_MAX)
       best_pred_diff[i] = INT_MIN;
@@ -4536,4 +4530,3 @@ int64_t vp9_rd_pick_inter_mode_sub8x8(VP9_COMP *cpi, MACROBLOCK *x,
 
   return best_rd;
 }
-