libvpx: Pull from upstream

source/libvpx/vp9/encoder/vp9_dct.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 152 matching lines @@
   output[2] = (tran_low_t)fdct_round_shift(s2);
   output[3] = (tran_low_t)fdct_round_shift(s3);
 }
 
 void vp9_fht4x4_c(const int16_t *input, tran_low_t *output,
                   int stride, int tx_type) {
   if (tx_type == DCT_DCT) {
     vp9_fdct4x4_c(input, output, stride);
   } else {
     tran_low_t out[4 * 4];
-    tran_low_t *outptr = &out[0];
     int i, j;
     tran_low_t temp_in[4], temp_out[4];
     const transform_2d ht = FHT_4[tx_type];
 
     // Columns
     for (i = 0; i < 4; ++i) {
       for (j = 0; j < 4; ++j)
         temp_in[j] = input[j * stride + i] * 16;
       if (i == 0 && temp_in[0])
         temp_in[0] += 1;
       ht.cols(temp_in, temp_out);
       for (j = 0; j < 4; ++j)
-        outptr[j * 4 + i] = temp_out[j];
+        out[j * 4 + i] = temp_out[j];
     }
 
     // Rows
     for (i = 0; i < 4; ++i) {
       for (j = 0; j < 4; ++j)
         temp_in[j] = out[j + i * 4];
       ht.rows(temp_in, temp_out);
       for (j = 0; j < 4; ++j)
         output[j + i * 4] = (temp_out[j] + 1) >> 2;
     }
@@ skipping 135 matching lines @@
 }
 
 void vp9_fdct8x8_quant_c(const int16_t *input, int stride,
                          tran_low_t *coeff_ptr, intptr_t n_coeffs,
                          int skip_block,
                          const int16_t *zbin_ptr, const int16_t *round_ptr,
                          const int16_t *quant_ptr,
                          const int16_t *quant_shift_ptr,
                          tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr,
                          const int16_t *dequant_ptr,
-                         int zbin_oq_value, uint16_t *eob_ptr,
+                         uint16_t *eob_ptr,
                          const int16_t *scan, const int16_t *iscan) {
   int eob = -1;
 
   int i, j;
   tran_low_t intermediate[64];
 
   // Transform columns
   {
     tran_low_t *output = intermediate;
     tran_high_t s0, s1, s2, s3, s4, s5, s6, s7;  // canbe16
@@ skipping 56 matching lines @@
   for (i = 0; i < 8; ++i) {
     vp9_fdct8(&intermediate[i * 8], &coeff_ptr[i * 8]);
     for (j = 0; j < 8; ++j)
       coeff_ptr[j + i * 8] /= 2;
   }
 
   // TODO(jingning) Decide the need of these arguments after the
   // quantization process is completed.
   (void)zbin_ptr;
   (void)quant_shift_ptr;
-  (void)zbin_oq_value;
   (void)iscan;
 
   vpx_memset(qcoeff_ptr, 0, n_coeffs * sizeof(*qcoeff_ptr));
   vpx_memset(dqcoeff_ptr, 0, n_coeffs * sizeof(*dqcoeff_ptr));
 
   if (!skip_block) {
     // Quantization pass: All coefficients with index >= zero_flag are
     // skippable. Note: zero_flag can be zero.
     for (i = 0; i < n_coeffs; i++) {
       const int rc = scan[i];
@@ skipping 275 matching lines @@
   output[6] = (tran_low_t)x5;
   output[7] = (tran_low_t)-x1;
 }
 
 void vp9_fht8x8_c(const int16_t *input, tran_low_t *output,
                   int stride, int tx_type) {
   if (tx_type == DCT_DCT) {
     vp9_fdct8x8_c(input, output, stride);
   } else {
     tran_low_t out[64];
-    tran_low_t *outptr = &out[0];
     int i, j;
     tran_low_t temp_in[8], temp_out[8];
     const transform_2d ht = FHT_8[tx_type];
 
     // Columns
     for (i = 0; i < 8; ++i) {
       for (j = 0; j < 8; ++j)
         temp_in[j] = input[j * stride + i] * 4;
       ht.cols(temp_in, temp_out);
       for (j = 0; j < 8; ++j)
-        outptr[j * 8 + i] = temp_out[j];
+        out[j * 8 + i] = temp_out[j];
     }
 
     // Rows
     for (i = 0; i < 8; ++i) {
       for (j = 0; j < 8; ++j)
         temp_in[j] = out[j + i * 8];
       ht.rows(temp_in, temp_out);
       for (j = 0; j < 8; ++j)
         output[j + i * 8] = (temp_out[j] + (temp_out[j] < 0)) >> 1;
     }
@@ skipping 360 matching lines @@
   output[14] = (tran_low_t)x9;
   output[15] = (tran_low_t)-x1;
 }
 
 void vp9_fht16x16_c(const int16_t *input, tran_low_t *output,
                     int stride, int tx_type) {
   if (tx_type == DCT_DCT) {
     vp9_fdct16x16_c(input, output, stride);
   } else {
     tran_low_t out[256];
-    tran_low_t *outptr = &out[0];
     int i, j;
     tran_low_t temp_in[16], temp_out[16];
     const transform_2d ht = FHT_16[tx_type];
 
     // Columns
     for (i = 0; i < 16; ++i) {
       for (j = 0; j < 16; ++j)
         temp_in[j] = input[j * stride + i] * 4;
       ht.cols(temp_in, temp_out);
       for (j = 0; j < 16; ++j)
-        outptr[j * 16 + i] = (temp_out[j] + 1 + (temp_out[j] < 0)) >> 2;
+        out[j * 16 + i] = (temp_out[j] + 1 + (temp_out[j] < 0)) >> 2;
     }
 
     // Rows
     for (i = 0; i < 16; ++i) {
       for (j = 0; j < 16; ++j)
         temp_in[j] = out[j + i * 16];
       ht.rows(temp_in, temp_out);
       for (j = 0; j < 16; ++j)
         output[j + i * 16] = temp_out[j];
     }
@@ skipping 457 matching lines @@
 
 void vp9_highbd_fdct32x32_c(const int16_t *input, tran_low_t *out, int stride) {
   vp9_fdct32x32_c(input, out, stride);
 }
 
 void vp9_highbd_fdct32x32_rd_c(const int16_t *input, tran_low_t *out,
                                int stride) {
   vp9_fdct32x32_rd_c(input, out, stride);
 }
 #endif  // CONFIG_VP9_HIGHBITDEPTH