libvpx: Pull from upstream

source/libvpx/vp8/decoder/error_concealment.c

 /*
  *  Copyright (c) 2011 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 <assert.h>
 
 #include "error_concealment.h"
 #include "onyxd_int.h"
 #include "decodemv.h"
 #include "vpx_mem/vpx_mem.h"
 #include "vp8/common/findnearmv.h"
 #include "vp8/common/common.h"
+#include "vpx_dsp/vpx_dsp_common.h"
 
 #define FLOOR(x,q) ((x) & -(1 << (q)))
 
 #define NUM_NEIGHBORS 20
 
 typedef struct ec_position
 {
     int row;
     int col;
 } EC_POS;
@@ skipping 57 matching lines @@
     }
 }
 
 /* Calculates the overlap area between two 4x4 squares, where the first
  * square has its upper-left corner at (b1_row, b1_col) and the second
  * square has its upper-left corner at (b2_row, b2_col). Doesn't
  * properly handle squares which do not overlap.
  */
 static int block_overlap(int b1_row, int b1_col, int b2_row, int b2_col)
 {
-    const int int_top = MAX(b1_row, b2_row); // top
-    const int int_left = MAX(b1_col, b2_col); // left
+    const int int_top = VPXMAX(b1_row, b2_row); // top
+    const int int_left = VPXMAX(b1_col, b2_col); // left
     /* Since each block is 4x4 pixels, adding 4 (Q3) to the left/top edge
      * gives us the right/bottom edge.
      */
-    const int int_right = MIN(b1_col + (4<<3), b2_col + (4<<3)); // right
-    const int int_bottom = MIN(b1_row + (4<<3), b2_row + (4<<3)); // bottom
+    const int int_right = VPXMIN(b1_col + (4<<3), b2_col + (4<<3)); // right
+    const int int_bottom = VPXMIN(b1_row + (4<<3), b2_row + (4<<3)); // bottom
     return (int_bottom - int_top) * (int_right - int_left);
 }
 
 /* Calculates the overlap area for all blocks in a macroblock at position
  * (mb_row, mb_col) in macroblocks, which are being overlapped by a given
  * overlapping block at position (new_row, new_col) (in pixels, Q3). The
  * first block being overlapped in the macroblock has position (first_blk_row,
  * first_blk_col) in blocks relative the upper-left corner of the image.
  */
 static void calculate_overlaps_mb(B_OVERLAP *b_overlaps, union b_mode_info *bmi,
                                   int new_row, int new_col,
                                   int mb_row, int mb_col,
                                   int first_blk_row, int first_blk_col)
 {
     /* Find the blocks within this MB (defined by mb_row, mb_col) which are
      * overlapped by bmi and calculate and assign overlap for each of those
      * blocks. */
 
     /* Block coordinates relative the upper-left block */
     const int rel_ol_blk_row = first_blk_row - mb_row * 4;
     const int rel_ol_blk_col = first_blk_col - mb_col * 4;
     /* If the block partly overlaps any previous MB, these coordinates
      * can be < 0. We don't want to access blocks in previous MBs.
      */
-    const int blk_idx = MAX(rel_ol_blk_row,0) * 4 + MAX(rel_ol_blk_col,0);
+    const int blk_idx = VPXMAX(rel_ol_blk_row,0) * 4 + VPXMAX(rel_ol_blk_col,0);
     /* Upper left overlapping block */
     B_OVERLAP *b_ol_ul = &(b_overlaps[blk_idx]);
 
     /* Calculate and assign overlaps for all blocks in this MB
      * which the motion compensated block overlaps
      */
     /* Avoid calculating overlaps for blocks in later MBs */
-    int end_row = MIN(4 + mb_row * 4 - first_blk_row, 2);
-    int end_col = MIN(4 + mb_col * 4 - first_blk_col, 2);
+    int end_row = VPXMIN(4 + mb_row * 4 - first_blk_row, 2);
+    int end_col = VPXMIN(4 + mb_col * 4 - first_blk_col, 2);
     int row, col;
 
     /* Check if new_row and new_col are evenly divisible by 4 (Q3),
      * and if so we shouldn't check neighboring blocks
      */
     if (new_row >= 0 && (new_row & 0x1F) == 0)
         end_row = 1;
     if (new_col >= 0 && (new_col & 0x1F) == 0)
         end_col = 1;
 
@@ skipping 54 matching lines @@
     /* overlapping block's position in blocks */
     overlap_b_row = FLOOR(new_row / 4, 3) >> 3;
     overlap_b_col = FLOOR(new_col / 4, 3) >> 3;
 
     /* overlapping block's MB position in MBs
      * operations are done in Q3
      */
     overlap_mb_row = FLOOR((overlap_b_row << 3) / 4, 3) >> 3;
     overlap_mb_col = FLOOR((overlap_b_col << 3) / 4, 3) >> 3;
 
-    end_row = MIN(mb_rows - overlap_mb_row, 2);
-    end_col = MIN(mb_cols - overlap_mb_col, 2);
+    end_row = VPXMIN(mb_rows - overlap_mb_row, 2);
+    end_col = VPXMIN(mb_cols - overlap_mb_col, 2);
 
     /* Don't calculate overlap for MBs we don't overlap */
     /* Check if the new block row starts at the last block row of the MB */
     if (abs(new_row - ((16*overlap_mb_row) << 3)) < ((3*4) << 3))
         end_row = 1;
     /* Check if the new block col starts at the last block col of the MB */
     if (abs(new_col - ((16*overlap_mb_col) << 3)) < ((3*4) << 3))
         end_col = 1;
 
     /* find the MB(s) this block is overlapping */
@@ skipping 364 matching lines @@
 
 void vp8_conceal_corrupt_mb(MACROBLOCKD *xd)
 {
     /* This macroblock has corrupt residual, use the motion compensated
        image (predictor) for concealment */
 
     /* The build predictor functions now output directly into the dst buffer,
      * so the copies are no longer necessary */
 
 }