libvpx: Pull from upstream

source/libvpx/vp9/encoder/vp9_quantize.c

 /*
  *  Copyright (c) 2010 The WebM project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 134 matching lines @@
 
         if (y) {
           eob = idx_arr[i];                         // last nonzero coeffs
         }
       }
     }
   }
   *eob_ptr = eob + 1;
 }
 
+struct plane_block_idx {
+  int plane;
+  int block;
+};
+
+// TODO(jkoleszar): returning a struct so it can be used in a const context,
+// expect to refactor this further later.
+static INLINE struct plane_block_idx plane_block_idx(int y_blocks,
+                                                     int b_idx) {
+  const int v_offset = y_blocks * 5 / 4;
+  struct plane_block_idx res;
+
+  if (b_idx < y_blocks) {
+    res.plane = 0;
+    res.block = b_idx;
+  } else if (b_idx < v_offset) {
+    res.plane = 1;
+    res.block = b_idx - y_blocks;
+  } else {
+    assert(b_idx < y_blocks * 3 / 2);
+    res.plane = 2;
+    res.block = b_idx - v_offset;
+  }
+  return res;
+}
+
 void vp9_regular_quantize_b_4x4(MACROBLOCK *mb, int b_idx, TX_TYPE tx_type,
                                 int y_blocks) {
   MACROBLOCKD *const xd = &mb->e_mbd;
   const struct plane_block_idx pb_idx = plane_block_idx(y_blocks, b_idx);
   const int16_t *scan = get_scan_4x4(tx_type);
   const int16_t *iscan = get_iscan_4x4(tx_type);
 
-  vp9_quantize_b(BLOCK_OFFSET(mb->plane[pb_idx.plane].coeff, pb_idx.block, 16),
+  vp9_quantize_b(BLOCK_OFFSET(mb->plane[pb_idx.plane].coeff, pb_idx.block),
            16, mb->skip_block,
            mb->plane[pb_idx.plane].zbin,
            mb->plane[pb_idx.plane].round,
            mb->plane[pb_idx.plane].quant,
            mb->plane[pb_idx.plane].quant_shift,
-           BLOCK_OFFSET(xd->plane[pb_idx.plane].qcoeff, pb_idx.block, 16),
-           BLOCK_OFFSET(xd->plane[pb_idx.plane].dqcoeff, pb_idx.block, 16),
+           BLOCK_OFFSET(xd->plane[pb_idx.plane].qcoeff, pb_idx.block),
+           BLOCK_OFFSET(xd->plane[pb_idx.plane].dqcoeff, pb_idx.block),
            xd->plane[pb_idx.plane].dequant,
            mb->plane[pb_idx.plane].zbin_extra,
            &xd->plane[pb_idx.plane].eobs[pb_idx.block],
            scan, iscan);
 }
 
 static void invert_quant(int16_t *quant, int16_t *shift, int d) {
   unsigned t;
   int l;
   t = d;
   for (l = 0; t > 1; l++)
     t >>= 1;
   t = 1 + (1 << (16 + l)) / d;
   *quant = (int16_t)(t - (1 << 16));
   *shift = 1 << (16 - l);
 }
 
 void vp9_init_quantizer(VP9_COMP *cpi) {
-  int i;
-  int quant_val;
-  int quant_uv_val;
-#if CONFIG_ALPHA
-  int quant_alpha_val;
-#endif
-  int q;
+  int i, q;
+  VP9_COMMON *const cm = &cpi->common;
 
   for (q = 0; q < QINDEX_RANGE; q++) {
-    int qzbin_factor = (vp9_dc_quant(q, 0) < 148) ? 84 : 80;
-    int qrounding_factor = 48;
-    if (q == 0) {
-      qzbin_factor = 64;
-      qrounding_factor = 64;
+    const int qzbin_factor = q == 0 ? 64 : (vp9_dc_quant(q, 0) < 148 ? 84 : 80);
+    const int qrounding_factor = q == 0 ? 64 : 48;
+
+    // y
+    for (i = 0; i < 2; ++i) {
+      const int quant = i == 0 ? vp9_dc_quant(q, cm->y_dc_delta_q)
+                               : vp9_ac_quant(q, 0);
+      invert_quant(&cpi->y_quant[q][i], &cpi->y_quant_shift[q][i], quant);
+      cpi->y_zbin[q][i] = ROUND_POWER_OF_TWO(qzbin_factor * quant, 7);
+      cpi->y_round[q][i] = (qrounding_factor * quant) >> 7;
+      cm->y_dequant[q][i] = quant;
     }
 
-    // dc values
-    quant_val = vp9_dc_quant(q, cpi->common.y_dc_delta_q);
-    invert_quant(cpi->y_quant[q] + 0, cpi->y_quant_shift[q] + 0, quant_val);
-    cpi->y_zbin[q][0] = ROUND_POWER_OF_TWO(qzbin_factor * quant_val, 7);
-    cpi->y_round[q][0] = (qrounding_factor * quant_val) >> 7;
-    cpi->common.y_dequant[q][0] = quant_val;
-
-    quant_val = vp9_dc_quant(q, cpi->common.uv_dc_delta_q);
-    invert_quant(cpi->uv_quant[q] + 0, cpi->uv_quant_shift[q] + 0, quant_val);
-    cpi->uv_zbin[q][0] = ROUND_POWER_OF_TWO(qzbin_factor * quant_val, 7);
-    cpi->uv_round[q][0] = (qrounding_factor * quant_val) >> 7;
-    cpi->common.uv_dequant[q][0] = quant_val;
+    // uv
+    for (i = 0; i < 2; ++i) {
+      const int quant = i == 0 ? vp9_dc_quant(q, cm->uv_dc_delta_q)
+                               : vp9_ac_quant(q, cm->uv_ac_delta_q);
+      invert_quant(&cpi->uv_quant[q][i], &cpi->uv_quant_shift[q][i], quant);
+      cpi->uv_zbin[q][i] = ROUND_POWER_OF_TWO(qzbin_factor * quant, 7);
+      cpi->uv_round[q][i] = (qrounding_factor * quant) >> 7;
+      cm->uv_dequant[q][i] = quant;
+    }
 
 #if CONFIG_ALPHA
-    quant_val = vp9_dc_quant(q, cpi->common.a_dc_delta_q);
-    invert_quant(cpi->a_quant[q] + 0, cpi->a_quant_shift[q] + 0, quant_val);
-    cpi->a_zbin[q][0] = ROUND_POWER_OF_TWO(qzbin_factor * quant_val, 7);
-    cpi->a_round[q][0] = (qrounding_factor * quant_val) >> 7;
-    cpi->common.a_dequant[q][0] = quant_val;
-#endif
-
-    quant_val = vp9_ac_quant(q, 0);
-    invert_quant(cpi->y_quant[q] + 1, cpi->y_quant_shift[q] + 1, quant_val);
-    cpi->y_zbin[q][1] = ROUND_POWER_OF_TWO(qzbin_factor * quant_val, 7);
-    cpi->y_round[q][1] = (qrounding_factor * quant_val) >> 7;
-    cpi->common.y_dequant[q][1] = quant_val;
-
-    quant_uv_val = vp9_ac_quant(q, cpi->common.uv_ac_delta_q);
-    invert_quant(cpi->uv_quant[q] + 1, cpi->uv_quant_shift[q] + 1,
-                 quant_uv_val);
-    cpi->uv_zbin[q][1] = ROUND_POWER_OF_TWO(qzbin_factor * quant_uv_val, 7);
-    cpi->uv_round[q][1] = (qrounding_factor * quant_uv_val) >> 7;
-    cpi->common.uv_dequant[q][1] = quant_uv_val;
-
-#if CONFIG_ALPHA
-    quant_alpha_val = vp9_ac_quant(q, cpi->common.a_ac_delta_q);
-    invert_quant(cpi->a_quant[q] + 1, cpi->a_quant_shift[q] + 1,
-                 quant_alpha_val);
-    cpi->a_zbin[q][1] = ROUND_POWER_OF_TWO(qzbin_factor * quant_alpha_val, 7);
-    cpi->a_round[q][1] = (qrounding_factor * quant_alpha_val) >> 7;
-    cpi->common.a_dequant[q][1] = quant_alpha_val;
+    // alpha
+    for (i = 0; i < 2; ++i) {
+      const int quant = i == 0 ? vp9_dc_quant(q, cm->a_dc_delta_q)
+                               : vp9_ac_quant(q, cm->a_ac_delta_q);
+      invert_quant(&cpi->a_quant[q][i], &cpi->a_quant_shift[q][i], quant);
+      cpi->a_zbin[q][i] = ROUND_POWER_OF_TWO(qzbin_factor * quant, 7);
+      cpi->a_round[q][i] = (qrounding_factor * quant) >> 7;
+      cm->a_dequant[q][i] = quant;
+    }
 #endif
 
     for (i = 2; i < 8; i++) {
       cpi->y_quant[q][i] = cpi->y_quant[q][1];
       cpi->y_quant_shift[q][i] = cpi->y_quant_shift[q][1];
       cpi->y_zbin[q][i] = cpi->y_zbin[q][1];
       cpi->y_round[q][i] = cpi->y_round[q][1];
-      cpi->common.y_dequant[q][i] = cpi->common.y_dequant[q][1];
+      cm->y_dequant[q][i] = cm->y_dequant[q][1];
 
       cpi->uv_quant[q][i] = cpi->uv_quant[q][1];
       cpi->uv_quant_shift[q][i] = cpi->uv_quant_shift[q][1];
       cpi->uv_zbin[q][i] = cpi->uv_zbin[q][1];
       cpi->uv_round[q][i] = cpi->uv_round[q][1];
-      cpi->common.uv_dequant[q][i] = cpi->common.uv_dequant[q][1];
+      cm->uv_dequant[q][i] = cm->uv_dequant[q][1];
 
 #if CONFIG_ALPHA
       cpi->a_quant[q][i] = cpi->a_quant[q][1];
       cpi->a_quant_shift[q][i] = cpi->a_quant_shift[q][1];
       cpi->a_zbin[q][i] = cpi->a_zbin[q][1];
       cpi->a_round[q][i] = cpi->a_round[q][1];
-      cpi->common.a_dequant[q][i] = cpi->common.a_dequant[q][1];
+      cm->a_dequant[q][i] = cm->a_dequant[q][1];
 #endif
     }
   }
 }
 
 void vp9_mb_init_quantizer(VP9_COMP *cpi, MACROBLOCK *x) {
   int i;
   MACROBLOCKD *xd = &x->e_mbd;
   int zbin_extra;
   int segment_id = xd->mode_info_context->mbmi.segment_id;
-  const int qindex = vp9_get_qindex(xd, segment_id, cpi->common.base_qindex);
+  const int qindex = vp9_get_qindex(&cpi->common.seg, segment_id,
+                                    cpi->common.base_qindex);
 
   // Y
   zbin_extra = (cpi->common.y_dequant[qindex][1] *
                  (cpi->zbin_mode_boost + x->act_zbin_adj)) >> 7;
 
   x->plane[0].quant = cpi->y_quant[qindex];
   x->plane[0].quant_shift = cpi->y_quant_shift[qindex];
   x->plane[0].zbin = cpi->y_zbin[qindex];
   x->plane[0].round = cpi->y_round[qindex];
   x->plane[0].zbin_extra = (int16_t)zbin_extra;
@@ skipping 14 matching lines @@
 
 #if CONFIG_ALPHA
   x->plane[3].quant = cpi->a_quant[qindex];
   x->plane[3].quant_shift = cpi->a_quant_shift[qindex];
   x->plane[3].zbin = cpi->a_zbin[qindex];
   x->plane[3].round = cpi->a_round[qindex];
   x->plane[3].zbin_extra = (int16_t)zbin_extra;
   x->e_mbd.plane[3].dequant = cpi->common.a_dequant[qindex];
 #endif
 
-  x->skip_block = vp9_segfeature_active(&xd->seg, segment_id, SEG_LVL_SKIP);
+  x->skip_block = vp9_segfeature_active(&cpi->common.seg, segment_id,
+                                        SEG_LVL_SKIP);
 
   /* save this macroblock QIndex for vp9_update_zbin_extra() */
   x->e_mbd.q_index = qindex;
 }
 
 void vp9_update_zbin_extra(VP9_COMP *cpi, MACROBLOCK *x) {
   const int qindex = x->e_mbd.q_index;
   const int y_zbin_extra = (cpi->common.y_dequant[qindex][1] *
                 (cpi->zbin_mode_boost + x->act_zbin_adj)) >> 7;
   const int uv_zbin_extra = (cpi->common.uv_dequant[qindex][1] *
@@ skipping 21 matching lines @@
   // have to be set.
   cm->y_dc_delta_q = 0;
   cm->uv_dc_delta_q = 0;
   cm->uv_ac_delta_q = 0;
 
   // quantizer has to be reinitialized if any delta_q changes.
   // As there are not any here for now this is inactive code.
   // if(update)
   //    vp9_init_quantizer(cpi);
 }