libvpx: Pull from upstream

source/libvpx/vp9/encoder/vp9_encodemb.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.
  */
 
 #include "./vpx_config.h"
 #include "vp9/encoder/vp9_encodemb.h"
 #include "vp9/common/vp9_reconinter.h"
 #include "vp9/encoder/vp9_quantize.h"
 #include "vp9/encoder/vp9_tokenize.h"
-#include "vp9/common/vp9_invtrans.h"
 #include "vp9/common/vp9_reconintra.h"
 #include "vpx_mem/vpx_mem.h"
 #include "vp9/encoder/vp9_rdopt.h"
 #include "vp9/common/vp9_systemdependent.h"
 #include "vp9_rtcd.h"
 
 DECLARE_ALIGNED(16, extern const uint8_t,
                 vp9_pt_energy_class[MAX_ENTROPY_TOKENS]);
 
 void vp9_subtract_block(int rows, int cols,
                         int16_t *diff_ptr, int diff_stride,
                         const uint8_t *src_ptr, int src_stride,
                         const uint8_t *pred_ptr, int pred_stride) {
   int r, c;
 
   for (r = 0; r < rows; r++) {
     for (c = 0; c < cols; c++)
       diff_ptr[c] = src_ptr[c] - pred_ptr[c];
 
     diff_ptr += diff_stride;
     pred_ptr += pred_stride;
     src_ptr  += src_stride;
   }
 }
 
+static void inverse_transform_b_4x4_add(MACROBLOCKD *xd, int eob,
+                                        int16_t *dqcoeff, uint8_t *dest,
+                                        int stride) {
+  if (eob <= 1)
+    xd->inv_txm4x4_1_add(dqcoeff, dest, stride);
+  else
+    xd->inv_txm4x4_add(dqcoeff, dest, stride);
+}
+
 
 static void subtract_plane(MACROBLOCK *x, BLOCK_SIZE_TYPE bsize, int plane) {
   struct macroblock_plane *const p = &x->plane[plane];
   const MACROBLOCKD *const xd = &x->e_mbd;
   const struct macroblockd_plane *const pd = &xd->plane[plane];
   const int bw = plane_block_width(bsize, pd);
   const int bh = plane_block_height(bsize, pd);
 
   vp9_subtract_block(bh, bw, p->src_diff, bw,
                      p->src.buf, p->src.stride,
@@ skipping 395 matching lines @@
   const int raster_block = txfrm_block_to_raster_block(xd, bsize, plane,
                                                        block, ss_txfrm_size);
   int16_t *const coeff = BLOCK_OFFSET(x->plane[plane].coeff, block, 16);
   int16_t *const src_diff = raster_block_offset_int16(xd, bsize, plane,
                                                       raster_block,
                                                       x->plane[plane].src_diff);
   TX_TYPE tx_type = DCT_DCT;
 
   switch (ss_txfrm_size / 2) {
     case TX_32X32:
-      vp9_short_fdct32x32(src_diff, coeff, bw * 2);
+      if (x->rd_search)
+        vp9_short_fdct32x32_rd(src_diff, coeff, bw * 2);
+      else
+        vp9_short_fdct32x32(src_diff, coeff, bw * 2);
       break;
     case TX_16X16:
       tx_type = plane == 0 ? get_tx_type_16x16(xd, raster_block) : DCT_DCT;
       if (tx_type != DCT_DCT)
         vp9_short_fht16x16(src_diff, coeff, bw, tx_type);
       else
         x->fwd_txm16x16(src_diff, coeff, bw * 2);
       break;
     case TX_8X8:
       tx_type = plane == 0 ? get_tx_type_8x8(xd, raster_block) : DCT_DCT;
@@ skipping 52 matching lines @@
         vp9_short_idct8x8_add(dqcoeff, dst, pd->dst.stride);
       else
         vp9_short_iht8x8_add(dqcoeff, dst, pd->dst.stride, tx_type);
       break;
     case TX_4X4:
       tx_type = plane == 0 ? get_tx_type_4x4(xd, raster_block) : DCT_DCT;
       if (tx_type == DCT_DCT)
         // this is like vp9_short_idct4x4 but has a special case around eob<=1
         // which is significant (not just an optimization) for the lossless
         // case.
-        vp9_inverse_transform_b_4x4_add(xd, pd->eobs[block], dqcoeff,
-                                        dst, pd->dst.stride);
+        inverse_transform_b_4x4_add(xd, pd->eobs[block], dqcoeff,
+                                    dst, pd->dst.stride);
       else
         vp9_short_iht4x4_add(dqcoeff, dst, pd->dst.stride, tx_type);
       break;
   }
 }
 
 void vp9_xform_quant_sby(VP9_COMMON *cm, MACROBLOCK *x, BLOCK_SIZE_TYPE bsize) {
   MACROBLOCKD* const xd = &x->e_mbd;
   struct encode_b_args arg = {cm, x, NULL};
 
@@ skipping 118 matching lines @@
         vp9_short_idct8x8_add(dqcoeff, dst, pd->dst.stride);
       else
         vp9_short_iht8x8_add(dqcoeff, dst, pd->dst.stride, tx_type);
       break;
     case TX_4X4:
       tx_type = plane == 0 ? get_tx_type_4x4(xd, raster_block) : DCT_DCT;
       if (tx_type == DCT_DCT)
         // this is like vp9_short_idct4x4 but has a special case around eob<=1
         // which is significant (not just an optimization) for the lossless
         // case.
-        vp9_inverse_transform_b_4x4_add(xd, pd->eobs[block], dqcoeff,
-                                        dst, pd->dst.stride);
+        inverse_transform_b_4x4_add(xd, pd->eobs[block], dqcoeff,
+                                    dst, pd->dst.stride);
       else
         vp9_short_iht4x4_add(dqcoeff, dst, pd->dst.stride, tx_type);
       break;
   }
 }
 
 void vp9_encode_intra_block_y(VP9_COMMON *cm, MACROBLOCK *x,
                               BLOCK_SIZE_TYPE bsize) {
   MACROBLOCKD* const xd = &x->e_mbd;
   struct optimize_ctx ctx;
   struct encode_b_args arg = {cm, x, &ctx};
 
   foreach_transformed_block_in_plane(xd, bsize, 0,
                                      encode_block_intra, &arg);
 }
 void vp9_encode_intra_block_uv(VP9_COMMON *cm, MACROBLOCK *x,
                               BLOCK_SIZE_TYPE bsize) {
   MACROBLOCKD* const xd = &x->e_mbd;
   struct optimize_ctx ctx;
   struct encode_b_args arg = {cm, x, &ctx};
   foreach_transformed_block_uv(xd, bsize, encode_block_intra, &arg);
 }