android-8.1.0_r81/s

/*
 *  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;

/*
 * Regenerate the table in Matlab with:
 * x = meshgrid((1:4), (1:4));
 * y = meshgrid((1:4), (1:4))';
 * W = round((1./(sqrt(x.^2 + y.^2))*2^7));
 * W(1,1) = 0;
 */
static const int weights_q7[5][5] = { { 0, 128, 64, 43, 32 },
                                      { 128, 91, 57, 40, 31 },
                                      { 64, 57, 45, 36, 29 },
                                      { 43, 40, 36, 30, 26 },
                                      { 32, 31, 29, 26, 23 } };

int vp8_alloc_overlap_lists(VP8D_COMP *pbi) {
  if (pbi->overlaps != NULL) {
    vpx_free(pbi->overlaps);
    pbi->overlaps = NULL;
  }

  pbi->overlaps =
      vpx_calloc(pbi->common.mb_rows * pbi->common.mb_cols, sizeof(MB_OVERLAP));

  if (pbi->overlaps == NULL) return -1;

  return 0;
}

void vp8_de_alloc_overlap_lists(VP8D_COMP *pbi) {
  vpx_free(pbi->overlaps);
  pbi->overlaps = NULL;
}

/* Inserts a new overlap area value to the list of overlaps of a block */
static void assign_overlap(OVERLAP_NODE *overlaps, union b_mode_info *bmi,
                           int overlap) {
  int i;
  if (overlap <= 0) return;
  /* Find and assign to the next empty overlap node in the list of overlaps.
   * Empty is defined as bmi == NULL */
  for (i = 0; i < MAX_OVERLAPS; ++i) {
    if (overlaps[i].bmi == NULL) {
      overlaps[i].bmi = bmi;
      overlaps[i].overlap = overlap;
      break;
    }
  }
}

/* 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 = 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 = 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 = 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 = 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;

  /* Check if the overlapping block partly overlaps a previous MB
   * and if so, we're overlapping fewer blocks in this MB.
   */
  if (new_row < (mb_row * 16) << 3) end_row = 1;
  if (new_col < (mb_col * 16) << 3) end_col = 1;

  for (row = 0; row < end_row; ++row) {
    for (col = 0; col < end_col; ++col) {
      /* input in Q3, result in Q6 */
      const int overlap =
          block_overlap(new_row, new_col, (((first_blk_row + row) * 4) << 3),
                        (((first_blk_col + col) * 4) << 3));
      assign_overlap(b_ol_ul[row * 4 + col].overlaps, bmi, overlap);
    }
  }
}

void vp8_calculate_overlaps(MB_OVERLAP *overlap_ul, int mb_rows, int mb_cols,
                            union b_mode_info *bmi, int b_row, int b_col) {
  MB_OVERLAP *mb_overlap;
  int row, col, rel_row, rel_col;
  int new_row, new_col;
  int end_row, end_col;
  int overlap_b_row, overlap_b_col;
  int overlap_mb_row, overlap_mb_col;

  /* mb subpixel position */
  row = (4 * b_row) << 3; /* Q3 */
  col = (4 * b_col) << 3; /* Q3 */

  /* reverse compensate for motion */
  new_row = row - bmi->mv.as_mv.row;
  new_col = col - bmi->mv.as_mv.col;

  if (new_row >= ((16 * mb_rows) << 3) || new_col >= ((16 * mb_cols) << 3)) {
    /* the new block ended up outside the frame */
    return;
  }

  if (new_row <= -32 || new_col <= -32) {
    /* outside the frame */
    return;
  }
  /* 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 = 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 */
  for (rel_row = 0; rel_row < end_row; ++rel_row) {
    for (rel_col = 0; rel_col < end_col; ++rel_col) {
      if (overlap_mb_row + rel_row < 0 || overlap_mb_col + rel_col < 0)
        continue;
      mb_overlap = overlap_ul + (overlap_mb_row + rel_row) * mb_cols +
                   overlap_mb_col + rel_col;

      calculate_overlaps_mb(mb_overlap->overlaps, bmi, new_row, new_col,
                            overlap_mb_row + rel_row, overlap_mb_col + rel_col,
                            overlap_b_row + rel_row, overlap_b_col + rel_col);
    }
  }
}

/* Estimates a motion vector given the overlapping blocks' motion vectors.
 * Filters out all overlapping blocks which do not refer to the correct
 * reference frame type.
 */
static void estimate_mv(const OVERLAP_NODE *overlaps, union b_mode_info *bmi) {
  int i;
  int overlap_sum = 0;
  int row_acc = 0;
  int col_acc = 0;

  bmi->mv.as_int = 0;
  for (i = 0; i < MAX_OVERLAPS; ++i) {
    if (overlaps[i].bmi == NULL) break;
    col_acc += overlaps[i].overlap * overlaps[i].bmi->mv.as_mv.col;
    row_acc += overlaps[i].overlap * overlaps[i].bmi->mv.as_mv.row;
    overlap_sum += overlaps[i].overlap;
  }
  if (overlap_sum > 0) {
    /* Q9 / Q6 = Q3 */
    bmi->mv.as_mv.col = col_acc / overlap_sum;
    bmi->mv.as_mv.row = row_acc / overlap_sum;
  } else {
    bmi->mv.as_mv.col = 0;
    bmi->mv.as_mv.row = 0;
  }
}

/* Estimates all motion vectors for a macroblock given the lists of
 * overlaps for each block. Decides whether or not the MVs must be clamped.
 */
static void estimate_mb_mvs(const B_OVERLAP *block_overlaps, MODE_INFO *mi,
                            int mb_to_left_edge, int mb_to_right_edge,
                            int mb_to_top_edge, int mb_to_bottom_edge) {
  int row, col;
  int non_zero_count = 0;
  MV *const filtered_mv = &(mi->mbmi.mv.as_mv);
  union b_mode_info *const bmi = mi->bmi;
  filtered_mv->col = 0;
  filtered_mv->row = 0;
  mi->mbmi.need_to_clamp_mvs = 0;
  for (row = 0; row < 4; ++row) {
    int this_b_to_top_edge = mb_to_top_edge + ((row * 4) << 3);
    int this_b_to_bottom_edge = mb_to_bottom_edge - ((row * 4) << 3);
    for (col = 0; col < 4; ++col) {
      int i = row * 4 + col;
      int this_b_to_left_edge = mb_to_left_edge + ((col * 4) << 3);
      int this_b_to_right_edge = mb_to_right_edge - ((col * 4) << 3);
      /* Estimate vectors for all blocks which are overlapped by this */
      /* type. Interpolate/extrapolate the rest of the block's MVs */
      estimate_mv(block_overlaps[i].overlaps, &(bmi[i]));
      mi->mbmi.need_to_clamp_mvs |= vp8_check_mv_bounds(
          &bmi[i].mv, this_b_to_left_edge, this_b_to_right_edge,
          this_b_to_top_edge, this_b_to_bottom_edge);
      if (bmi[i].mv.as_int != 0) {
        ++non_zero_count;
        filtered_mv->col += bmi[i].mv.as_mv.col;
        filtered_mv->row += bmi[i].mv.as_mv.row;
      }
    }
  }
  if (non_zero_count > 0) {
    filtered_mv->col /= non_zero_count;
    filtered_mv->row /= non_zero_count;
  }
}

static void calc_prev_mb_overlaps(MB_OVERLAP *overlaps, MODE_INFO *prev_mi,
                                  int mb_row, int mb_col, int mb_rows,
                                  int mb_cols) {
  int sub_row;
  int sub_col;
  for (sub_row = 0; sub_row < 4; ++sub_row) {
    for (sub_col = 0; sub_col < 4; ++sub_col) {
      vp8_calculate_overlaps(overlaps, mb_rows, mb_cols,
                             &(prev_mi->bmi[sub_row * 4 + sub_col]),
                             4 * mb_row + sub_row, 4 * mb_col + sub_col);
    }
  }
}

/* Estimate all missing motion vectors. This function does the same as the one
 * above, but has different input arguments. */
static void estimate_missing_mvs(MB_OVERLAP *overlaps, MODE_INFO *mi,
                                 MODE_INFO *prev_mi, int mb_rows, int mb_cols,
                                 unsigned int first_corrupt) {
  int mb_row, mb_col;
  memset(overlaps, 0, sizeof(MB_OVERLAP) * mb_rows * mb_cols);
  /* First calculate the overlaps for all blocks */
  for (mb_row = 0; mb_row < mb_rows; ++mb_row) {
    for (mb_col = 0; mb_col < mb_cols; ++mb_col) {
      /* We're only able to use blocks referring to the last frame
       * when extrapolating new vectors.
       */
      if (prev_mi->mbmi.ref_frame == LAST_FRAME) {
        calc_prev_mb_overlaps(overlaps, prev_mi, mb_row, mb_col, mb_rows,
                              mb_cols);
      }
      ++prev_mi;
    }
    ++prev_mi;
  }

  mb_row = first_corrupt / mb_cols;
  mb_col = first_corrupt - mb_row * mb_cols;
  mi += mb_row * (mb_cols + 1) + mb_col;
  /* Go through all macroblocks in the current image with missing MVs
   * and calculate new MVs using the overlaps.
   */
  for (; mb_row < mb_rows; ++mb_row) {
    int mb_to_top_edge = -((mb_row * 16)) << 3;
    int mb_to_bottom_edge = ((mb_rows - 1 - mb_row) * 16) << 3;
    for (; mb_col < mb_cols; ++mb_col) {
      int mb_to_left_edge = -((mb_col * 16) << 3);
      int mb_to_right_edge = ((mb_cols - 1 - mb_col) * 16) << 3;
      const B_OVERLAP *block_overlaps =
          overlaps[mb_row * mb_cols + mb_col].overlaps;
      mi->mbmi.ref_frame = LAST_FRAME;
      mi->mbmi.mode = SPLITMV;
      mi->mbmi.uv_mode = DC_PRED;
      mi->mbmi.partitioning = 3;
      mi->mbmi.segment_id = 0;
      estimate_mb_mvs(block_overlaps, mi, mb_to_left_edge, mb_to_right_edge,
                      mb_to_top_edge, mb_to_bottom_edge);
      ++mi;
    }
    mb_col = 0;
    ++mi;
  }
}

void vp8_estimate_missing_mvs(VP8D_COMP *pbi) {
  VP8_COMMON *const pc = &pbi->common;
  estimate_missing_mvs(pbi->overlaps, pc->mi, pc->prev_mi, pc->mb_rows,
                       pc->mb_cols, pbi->mvs_corrupt_from_mb);
}

static void assign_neighbor(EC_BLOCK *neighbor, MODE_INFO *mi, int block_idx) {
  assert(mi->mbmi.ref_frame < MAX_REF_FRAMES);
  neighbor->ref_frame = mi->mbmi.ref_frame;
  neighbor->mv = mi->bmi[block_idx].mv.as_mv;
}

/* Finds the neighboring blocks of a macroblocks. In the general case
 * 20 blocks are found. If a fewer number of blocks are found due to
 * image boundaries, those positions in the EC_BLOCK array are left "empty".
 * The neighbors are enumerated with the upper-left neighbor as the first
 * element, the second element refers to the neighbor to right of the previous
 * neighbor, and so on. The last element refers to the neighbor below the first
 * neighbor.
 */
static void find_neighboring_blocks(MODE_INFO *mi, EC_BLOCK *neighbors,
                                    int mb_row, int mb_col, int mb_rows,
                                    int mb_cols, int mi_stride) {
  int i = 0;
  int j;
  if (mb_row > 0) {
    /* upper left */
    if (mb_col > 0) assign_neighbor(&neighbors[i], mi - mi_stride - 1, 15);
    ++i;
    /* above */
    for (j = 12; j < 16; ++j, ++i)
      assign_neighbor(&neighbors[i], mi - mi_stride, j);
  } else
    i += 5;
  if (mb_col < mb_cols - 1) {
    /* upper right */
    if (mb_row > 0) assign_neighbor(&neighbors[i], mi - mi_stride + 1, 12);
    ++i;
    /* right */
    for (j = 0; j <= 12; j += 4, ++i) assign_neighbor(&neighbors[i], mi + 1, j);
  } else
    i += 5;
  if (mb_row < mb_rows - 1) {
    /* lower right */
    if (mb_col < mb_cols - 1)
      assign_neighbor(&neighbors[i], mi + mi_stride + 1, 0);
    ++i;
    /* below */
    for (j = 0; j < 4; ++j, ++i)
      assign_neighbor(&neighbors[i], mi + mi_stride, j);
  } else
    i += 5;
  if (mb_col > 0) {
    /* lower left */
    if (mb_row < mb_rows - 1)
      assign_neighbor(&neighbors[i], mi + mi_stride - 1, 4);
    ++i;
    /* left */
    for (j = 3; j < 16; j += 4, ++i) {
      assign_neighbor(&neighbors[i], mi - 1, j);
    }
  } else
    i += 5;
  assert(i == 20);
}

/* Interpolates all motion vectors for a macroblock from the neighboring blocks'
 * motion vectors.
 */
static void interpolate_mvs(MACROBLOCKD *mb, EC_BLOCK *neighbors,
                            MV_REFERENCE_FRAME dom_ref_frame) {
  int row, col, i;
  MODE_INFO *const mi = mb->mode_info_context;
  /* Table with the position of the neighboring blocks relative the position
   * of the upper left block of the current MB. Starting with the upper left
   * neighbor and going to the right.
   */
  const EC_POS neigh_pos[NUM_NEIGHBORS] = {
    { -1, -1 }, { -1, 0 }, { -1, 1 }, { -1, 2 }, { -1, 3 }, { -1, 4 }, { 0, 4 },
    { 1, 4 },   { 2, 4 },  { 3, 4 },  { 4, 4 },  { 4, 3 },  { 4, 2 },  { 4, 1 },
    { 4, 0 },   { 4, -1 }, { 3, -1 }, { 2, -1 }, { 1, -1 }, { 0, -1 }
  };
  mi->mbmi.need_to_clamp_mvs = 0;
  for (row = 0; row < 4; ++row) {
    int mb_to_top_edge = mb->mb_to_top_edge + ((row * 4) << 3);
    int mb_to_bottom_edge = mb->mb_to_bottom_edge - ((row * 4) << 3);
    for (col = 0; col < 4; ++col) {
      int mb_to_left_edge = mb->mb_to_left_edge + ((col * 4) << 3);
      int mb_to_right_edge = mb->mb_to_right_edge - ((col * 4) << 3);
      int w_sum = 0;
      int mv_row_sum = 0;
      int mv_col_sum = 0;
      int_mv *const mv = &(mi->bmi[row * 4 + col].mv);
      mv->as_int = 0;
      for (i = 0; i < NUM_NEIGHBORS; ++i) {
        /* Calculate the weighted sum of neighboring MVs referring
         * to the dominant frame type.
         */
        const int w = weights_q7[abs(row - neigh_pos[i].row)]
                                [abs(col - neigh_pos[i].col)];
        if (neighbors[i].ref_frame != dom_ref_frame) continue;
        w_sum += w;
        /* Q7 * Q3 = Q10 */
        mv_row_sum += w * neighbors[i].mv.row;
        mv_col_sum += w * neighbors[i].mv.col;
      }
      if (w_sum > 0) {
        /* Avoid division by zero.
         * Normalize with the sum of the coefficients
         * Q3 = Q10 / Q7
         */
        mv->as_mv.row = mv_row_sum / w_sum;
        mv->as_mv.col = mv_col_sum / w_sum;
        mi->mbmi.need_to_clamp_mvs |=
            vp8_check_mv_bounds(mv, mb_to_left_edge, mb_to_right_edge,
                                mb_to_top_edge, mb_to_bottom_edge);
      }
    }
  }
}

void vp8_interpolate_motion(MACROBLOCKD *mb, int mb_row, int mb_col,
                            int mb_rows, int mb_cols) {
  /* Find relevant neighboring blocks */
  EC_BLOCK neighbors[NUM_NEIGHBORS];
  int i;
  /* Initialize the array. MAX_REF_FRAMES is interpreted as "doesn't exist" */
  for (i = 0; i < NUM_NEIGHBORS; ++i) {
    neighbors[i].ref_frame = MAX_REF_FRAMES;
    neighbors[i].mv.row = neighbors[i].mv.col = 0;
  }
  find_neighboring_blocks(mb->mode_info_context, neighbors, mb_row, mb_col,
                          mb_rows, mb_cols, mb->mode_info_stride);
  /* Interpolate MVs for the missing blocks from the surrounding
   * blocks which refer to the last frame. */
  interpolate_mvs(mb, neighbors, LAST_FRAME);

  mb->mode_info_context->mbmi.ref_frame = LAST_FRAME;
  mb->mode_info_context->mbmi.mode = SPLITMV;
  mb->mode_info_context->mbmi.uv_mode = DC_PRED;
  mb->mode_info_context->mbmi.partitioning = 3;
  mb->mode_info_context->mbmi.segment_id = 0;
}