vp9_encodeframe.c

  sum_2_variances(&node.vt->vert[1], node.split[1], node.split[3]);
  sum_2_variances(&node.vt->none, &node.vt->vert[0], &node.vt->vert[1]);
}

#if PERFORM_RANDOM_PARTITIONING
static int set_vt_partitioning(VP9_COMP *cpi, void *data, MODE_INFO *m,
    BLOCK_SIZE_TYPE block_size, int mi_row,
    int mi_col, int mi_size) {
  VP9_COMMON * const cm = &cpi->common;
  vt_node vt;
  const int mis = cm->mode_info_stride;
  int64_t threshold = 4 * cpi->common.base_qindex * cpi->common.base_qindex;

  tree_to_node(data, block_size, &vt);

  // split none is available only if we have more than half a block size
  // in width and height inside the visible image
  if (mi_col + mi_size < cm->mi_cols && mi_row + mi_size < cm->mi_rows &&
      (rand() & 3) < 1) {
    set_block_size(cm, m, block_size, mis, mi_row, mi_col);
    return 1;
  }

  // vertical split is available on all but the bottom border
  if (mi_row + mi_size < cm->mi_rows && vt.vt->vert[0].variance < threshold
      && (rand() & 3) < 1) {
    set_block_size(cm, m, get_subsize(block_size, PARTITION_VERT), mis, mi_row,
        mi_col);
    return 1;
  }

  // horizontal split is available on all but the right border
  if (mi_col + mi_size < cm->mi_cols && vt.vt->horz[0].variance < threshold
      && (rand() & 3) < 1) {
    set_block_size(cm, m, get_subsize(block_size, PARTITION_HORZ), mis, mi_row,
        mi_col);
    return 1;
  }

  return 0;
}

#else

static int set_vt_partitioning(VP9_COMP *cpi, void *data, MODE_INFO *m,
                               BLOCK_SIZE_TYPE block_size, int mi_row,
                               int mi_col, int mi_size) {
  VP9_COMMON * const cm = &cpi->common;
  vt_node vt;
  const int mis = cm->mode_info_stride;
  int64_t threshold = 50 * cpi->common.base_qindex;

  tree_to_node(data, block_size, &vt);

  // split none is available only if we have more than half a block size
  // in width and height inside the visible image
  if (mi_col + mi_size < cm->mi_cols && mi_row + mi_size < cm->mi_rows
      && vt.vt->none.variance < threshold) {
    set_block_size(cm, m, block_size, mis, mi_row, mi_col);
    return 1;
  }

  // vertical split is available on all but the bottom border
  if (mi_row + mi_size < cm->mi_rows && vt.vt->vert[0].variance < threshold
      && vt.vt->vert[1].variance < threshold) {
    set_block_size(cm, m, get_subsize(block_size, PARTITION_VERT), mis, mi_row,
                   mi_col);
    return 1;
  }

  // horizontal split is available on all but the right border
  if (mi_col + mi_size < cm->mi_cols && vt.vt->horz[0].variance < threshold
      && vt.vt->horz[1].variance < threshold) {
    set_block_size(cm, m, get_subsize(block_size, PARTITION_HORZ), mis, mi_row,
                   mi_col);
    return 1;
  }

  return 0;
}
#endif

static void choose_partitioning(VP9_COMP *cpi, MODE_INFO *m, int mi_row,
                                int mi_col) {
  VP9_COMMON * const cm = &cpi->common;
  MACROBLOCK *x = &cpi->mb;
  MACROBLOCKD *xd = &cpi->mb.e_mbd;
  const int mis = cm->mode_info_stride;
  // TODO(JBB): More experimentation or testing of this threshold;
  int64_t threshold = 4;
  int i, j, k;
  v64x64 vt;
  unsigned char * s;
  int sp;
  const unsigned char * d;
  int dp;
  int pixels_wide = 64, pixels_high = 64;

  vpx_memset(&vt, 0, sizeof(vt));

  set_offsets(cpi, mi_row, mi_col, BLOCK_SIZE_SB64X64);

  if (xd->mb_to_right_edge < 0)
    pixels_wide += (xd->mb_to_right_edge >> 3);

  if (xd->mb_to_bottom_edge < 0)
    pixels_high += (xd->mb_to_bottom_edge >> 3);

  s = x->plane[0].src.buf;
  sp = x->plane[0].src.stride;

  // TODO(JBB): Clearly the higher the quantizer the fewer partitions we want
  // but this needs more experimentation.
  threshold = threshold * cpi->common.base_qindex * cpi->common.base_qindex;

  d = vp9_64x64_zeros;
  dp = 64;
  if (cm->frame_type != KEY_FRAME) {
    int_mv nearest_mv, near_mv;
    YV12_BUFFER_CONFIG *ref_fb = &cm->yv12_fb[0];
    YV12_BUFFER_CONFIG *second_ref_fb = NULL;

    setup_pre_planes(xd, ref_fb, second_ref_fb, mi_row, mi_col,
                     xd->scale_factor, xd->scale_factor_uv);
    xd->mode_info_context->mbmi.ref_frame[0] = LAST_FRAME;
    xd->mode_info_context->mbmi.sb_type = BLOCK_SIZE_SB64X64;
    vp9_find_best_ref_mvs(xd, m->mbmi.ref_mvs[m->mbmi.ref_frame[0]],
                          &nearest_mv, &near_mv);

    xd->mode_info_context->mbmi.mv[0] = nearest_mv;
    vp9_build_inter_predictors_sby(xd, mi_row, mi_col, BLOCK_SIZE_SB64X64);
    d = xd->plane[0].dst.buf;
    dp = xd->plane[0].dst.stride;

  }

  // Fill in the entire tree of 8x8 variances for splits.
  for (i = 0; i < 4; i++) {
    const int x32_idx = ((i & 1) << 5);
    const int y32_idx = ((i >> 1) << 5);
    for (j = 0; j < 4; j++) {
      const int x16_idx = x32_idx + ((j & 1) << 4);
      const int y16_idx = y32_idx + ((j >> 1) << 4);
      v16x16 *vst = &vt.split[i].split[j];
      for (k = 0; k < 4; k++) {
        int x_idx = x16_idx + ((k & 1) << 3);
        int y_idx = y16_idx + ((k >> 1) << 3);
        unsigned int sse = 0;
        int sum = 0;
        if (x_idx < pixels_wide && y_idx < pixels_high)
          vp9_get_sse_sum_8x8(s + y_idx * sp + x_idx, sp,
                              d + y_idx * dp + x_idx, dp, &sse, &sum);
        fill_variance(&vst->split[k].vt.none, sse, sum, 64);
      }
    }
  }
  // Fill the rest of the variance tree by summing the split partition
  // values.
  for (i = 0; i < 4; i++) {
    for (j = 0; j < 4; j++) {
      fill_variance_tree(&vt.split[i].split[j], BLOCK_SIZE_MB16X16);
    }
    fill_variance_tree(&vt.split[i], BLOCK_SIZE_SB32X32);
  }
  fill_variance_tree(&vt, BLOCK_SIZE_SB64X64);
  // Now go through the entire structure,  splitting every block size until
  // we get to one that's got a variance lower than our threshold,  or we
  // hit 8x8.
  if (!set_vt_partitioning(cpi, &vt, m, BLOCK_SIZE_SB64X64, mi_row, mi_col,
                           4)) {
    for (i = 0; i < 4; ++i) {
      const int x32_idx = ((i & 1) << 2);
      const int y32_idx = ((i >> 1) << 2);
      if (!set_vt_partitioning(cpi, &vt.split[i], m, BLOCK_SIZE_SB32X32,
                               (mi_row + y32_idx), (mi_col + x32_idx), 2)) {
        for (j = 0; j < 4; ++j) {
          const int x16_idx = ((j & 1) << 1);
          const int y16_idx = ((j >> 1) << 1);
          if (!set_vt_partitioning(cpi, &vt.split[i].split[j], m,
                                   BLOCK_SIZE_MB16X16,
                                   (mi_row + y32_idx + y16_idx),
                                   (mi_col + x32_idx + x16_idx), 1)) {
            for (k = 0; k < 4; ++k) {
              const int x8_idx = (k & 1);
              const int y8_idx = (k >> 1);
              set_block_size(cm, m, BLOCK_SIZE_SB8X8, mis,
                             (mi_row + y32_idx + y16_idx + y8_idx),
                             (mi_col + x32_idx + x16_idx + x8_idx));
            }
          }
        }
      }
    }
  }
}
static void rd_use_partition(VP9_COMP *cpi, MODE_INFO *m, TOKENEXTRA **tp,
                             int mi_row, int mi_col, BLOCK_SIZE_TYPE bsize,
                             int *rate, int64_t *dist) {
  VP9_COMMON * const cm = &cpi->common;
  MACROBLOCK * const x = &cpi->mb;
  MACROBLOCKD *xd = &cpi->mb.e_mbd;
  const int mis = cm->mode_info_stride;
  int bwl = b_width_log2(m->mbmi.sb_type);
  int bhl = b_height_log2(m->mbmi.sb_type);
  int bsl = b_width_log2(bsize);
  int bh = (1 << bhl);
  int bs = (1 << bsl);
  int bss = (1 << bsl) / 4;
  int i, pl;
  PARTITION_TYPE partition;
  BLOCK_SIZE_TYPE subsize;
  ENTROPY_CONTEXT l[16 * MAX_MB_PLANE], a[16 * MAX_MB_PLANE];
  PARTITION_CONTEXT sl[8], sa[8];
  int r = 0;
  int64_t d = 0;

  if (mi_row >= cm->mi_rows || mi_col >= cm->mi_cols)
    return;

  // parse the partition type
  if ((bwl == bsl) && (bhl == bsl))
    partition = PARTITION_NONE;
  else if ((bwl == bsl) && (bhl < bsl))
    partition = PARTITION_HORZ;
  else if ((bwl < bsl) && (bhl == bsl))
    partition = PARTITION_VERT;
  else if ((bwl < bsl) && (bhl < bsl))
    partition = PARTITION_SPLIT;
  else
    assert(0);

  subsize = get_subsize(bsize, partition);

  if (bsize < BLOCK_SIZE_SB8X8) {
    if (xd->ab_index != 0) {
      *rate = 0;
      *dist = 0;
      return;
    }
  } else {
    *(get_sb_partitioning(x, bsize)) = subsize;
  }
  pl = partition_plane_context(xd, bsize);
  save_context(cpi, mi_row, mi_col, a, l, sa, sl, bsize);
  switch (partition) {
    case PARTITION_NONE:
      pick_sb_modes(cpi, mi_row, mi_col, tp, &r, &d, bsize,
                    get_block_context(x, bsize));
      r += x->partition_cost[pl][PARTITION_NONE];
      break;
    case PARTITION_HORZ:
      *(get_sb_index(xd, subsize)) = 0;
      pick_sb_modes(cpi, mi_row, mi_col, tp, &r, &d, subsize,
                    get_block_context(x, subsize));
      if (mi_row + (bh >> 1) <= cm->mi_rows) {
        int rt;
        int64_t dt;
        update_state(cpi, get_block_context(x, subsize), subsize, 0);
        encode_superblock(cpi, tp, 0, mi_row, mi_col, subsize);
        *(get_sb_index(xd, subsize)) = 1;
        pick_sb_modes(cpi, mi_row + (bs >> 2), mi_col, tp, &rt, &dt, subsize,
                      get_block_context(x, subsize));
        r += rt;
        d += dt;
      }
      set_partition_seg_context(cm, xd, mi_row, mi_col);
      pl = partition_plane_context(xd, bsize);
      r += x->partition_cost[pl][PARTITION_HORZ];
      break;
    case PARTITION_VERT:
      *(get_sb_index(xd, subsize)) = 0;
      pick_sb_modes(cpi, mi_row, mi_col, tp, &r, &d, subsize,
                    get_block_context(x, subsize));
      if (mi_col + (bs >> 1) <= cm->mi_cols) {
        int rt;
        int64_t dt;
        update_state(cpi, get_block_context(x, subsize), subsize, 0);
        encode_superblock(cpi, tp, 0, mi_row, mi_col, subsize);
        *(get_sb_index(xd, subsize)) = 1;
        pick_sb_modes(cpi, mi_row, mi_col + (bs >> 2), tp, &rt, &dt, subsize,
                      get_block_context(x, subsize));
        r += rt;
        d += dt;
      }
      set_partition_seg_context(cm, xd, mi_row, mi_col);
      pl = partition_plane_context(xd, bsize);
      r += x->partition_cost[pl][PARTITION_VERT];
      restore_context(cpi, mi_row, mi_col, a, l, sa, sl, bsize);
      break;
    case PARTITION_SPLIT:
      for (i = 0; i < 4; i++) {
        int x_idx = (i & 1) * (bs >> 2);
        int y_idx = (i >> 1) * (bs >> 2);
        int jj = i >> 1, ii = i & 0x01;
        int rt;
        int64_t dt;

        if ((mi_row + y_idx >= cm->mi_rows) || (mi_col + x_idx >= cm->mi_cols))
          continue;

        *(get_sb_index(xd, subsize)) = i;

        rd_use_partition(cpi, m + jj * bss * mis + ii * bss, tp, mi_row + y_idx,
                         mi_col + x_idx, subsize, &rt, &dt);
        r += rt;
        d += dt;
      }
      set_partition_seg_context(cm, xd, mi_row, mi_col);
      pl = partition_plane_context(xd, bsize);
      r += x->partition_cost[pl][PARTITION_SPLIT];
      break;
    default:
      assert(0);
  }

  restore_context(cpi, mi_row, mi_col, a, l, sa, sl, bsize);

  if (r < INT_MAX && d < INT_MAX)
    encode_sb(cpi, tp, mi_row, mi_col, bsize == BLOCK_SIZE_SB64X64, bsize);
  *rate = r;
  *dist = d;
}


// TODO(jingning,jimbankoski,rbultje): properly skip partition types that are
// unlikely to be selected depending on previously rate-distortion optimization
// results, for encoding speed-up.
static void rd_pick_partition(VP9_COMP *cpi, TOKENEXTRA **tp, int mi_row,
                              int mi_col, BLOCK_SIZE_TYPE bsize, int *rate,
                              int64_t *dist) {
  VP9_COMMON * const cm = &cpi->common;
  MACROBLOCK * const x = &cpi->mb;
  MACROBLOCKD * const xd = &x->e_mbd;
  int bsl = b_width_log2(bsize), bs = 1 << bsl;
  int ms = bs / 2;
  ENTROPY_CONTEXT l[16 * MAX_MB_PLANE], a[16 * MAX_MB_PLANE];
  PARTITION_CONTEXT sl[8], sa[8];
  TOKENEXTRA *tp_orig = *tp;
  int i, pl;
  BLOCK_SIZE_TYPE subsize;
  int srate = INT_MAX;
  int64_t sdist = INT_MAX;

  if (bsize < BLOCK_SIZE_SB8X8)
    if (xd->ab_index != 0) {
      *rate = 0;
      *dist = 0;
      return;
    }
  assert(mi_height_log2(bsize) == mi_width_log2(bsize));

  save_context(cpi, mi_row, mi_col, a, l, sa, sl, bsize);

  // PARTITION_SPLIT
  if (!cpi->sf.use_partitions_greater_than
      || (cpi->sf.use_partitions_greater_than
          && bsize > cpi->sf.greater_than_block_size)) {
    if (bsize >= BLOCK_SIZE_SB8X8) {
      int r4 = 0;
      int64_t d4 = 0;
      subsize = get_subsize(bsize, PARTITION_SPLIT);
      *(get_sb_partitioning(x, bsize)) = subsize;

      for (i = 0; i < 4; ++i) {
        int x_idx = (i & 1) * (ms >> 1);
        int y_idx = (i >> 1) * (ms >> 1);
        int r = 0;
        int64_t d = 0;

        if ((mi_row + y_idx >= cm->mi_rows) || (mi_col + x_idx >= cm->mi_cols))
          continue;

        *(get_sb_index(xd, subsize)) = i;
        rd_pick_partition(cpi, tp, mi_row + y_idx, mi_col + x_idx, subsize, &r,
                          &d);

        r4 += r;
        d4 += d;
      }
      set_partition_seg_context(cm, xd, mi_row, mi_col);
      pl = partition_plane_context(xd, bsize);
      if (r4 < INT_MAX)
        r4 += x->partition_cost[pl][PARTITION_SPLIT];
      assert(r4 >= 0);
      assert(d4 >= 0);
      srate = r4;
      sdist = d4;
      restore_context(cpi, mi_row, mi_col, a, l, sa, sl, bsize);
    }
  }
  if (!cpi->sf.use_partitions_less_than
      || (cpi->sf.use_partitions_less_than
          && bsize <= cpi->sf.less_than_block_size)) {
    // PARTITION_HORZ
    if (bsize >= BLOCK_SIZE_SB8X8 && mi_col + (ms >> 1) < cm->mi_cols) {
      int r2, r = 0;
      int64_t d2, d = 0;
      subsize = get_subsize(bsize, PARTITION_HORZ);
      *(get_sb_index(xd, subsize)) = 0;
      pick_sb_modes(cpi, mi_row, mi_col, tp, &r2, &d2, subsize,
                    get_block_context(x, subsize));

      if (mi_row + (ms >> 1) < cm->mi_rows) {
        update_state(cpi, get_block_context(x, subsize), subsize, 0);
        encode_superblock(cpi, tp, 0, mi_row, mi_col, subsize);

        *(get_sb_index(xd, subsize)) = 1;
        pick_sb_modes(cpi, mi_row + (ms >> 1), mi_col, tp, &r, &d, subsize,
                      get_block_context(x, subsize));
        r2 += r;
        d2 += d;
      }
      set_partition_seg_context(cm, xd, mi_row, mi_col);
      pl = partition_plane_context(xd, bsize);
      if (r2 < INT_MAX)
        r2 += x->partition_cost[pl][PARTITION_HORZ];
      if (RDCOST(x->rdmult, x->rddiv, r2, d2)
          < RDCOST(x->rdmult, x->rddiv, srate, sdist)) {
        srate = r2;
        sdist = d2;
        *(get_sb_partitioning(x, bsize)) = subsize;
      }
      restore_context(cpi, mi_row, mi_col, a, l, sa, sl, bsize);
    }

    // PARTITION_VERT
    if (bsize >= BLOCK_SIZE_SB8X8 && mi_row + (ms >> 1) < cm->mi_rows) {
      int r2;
      int64_t d2;
      subsize = get_subsize(bsize, PARTITION_VERT);
      *(get_sb_index(xd, subsize)) = 0;
      pick_sb_modes(cpi, mi_row, mi_col, tp, &r2, &d2, subsize,
                    get_block_context(x, subsize));
      if (mi_col + (ms >> 1) < cm->mi_cols) {
        int r = 0;
        int64_t d = 0;
        update_state(cpi, get_block_context(x, subsize), subsize, 0);
        encode_superblock(cpi, tp, 0, mi_row, mi_col, subsize);

        *(get_sb_index(xd, subsize)) = 1;
        pick_sb_modes(cpi, mi_row, mi_col + (ms >> 1), tp, &r, &d, subsize,
                      get_block_context(x, subsize));
        r2 += r;
        d2 += d;
      }
      set_partition_seg_context(cm, xd, mi_row, mi_col);
      pl = partition_plane_context(xd, bsize);
      if (r2 < INT_MAX)
        r2 += x->partition_cost[pl][PARTITION_VERT];
      if (RDCOST(x->rdmult, x->rddiv, r2, d2)
          < RDCOST(x->rdmult, x->rddiv, srate, sdist)) {
        srate = r2;
        sdist = d2;
        *(get_sb_partitioning(x, bsize)) = subsize;
      }
      restore_context(cpi, mi_row, mi_col, a, l, sa, sl, bsize);
    }

    // PARTITION_NONE
    if ((mi_row + (ms >> 1) < cm->mi_rows) &&
        (mi_col + (ms >> 1) < cm->mi_cols)) {
      int r;
      int64_t d;
      pick_sb_modes(cpi, mi_row, mi_col, tp, &r, &d, bsize,
                    get_block_context(x, bsize));
      if (bsize >= BLOCK_SIZE_SB8X8) {
        set_partition_seg_context(cm, xd, mi_row, mi_col);
        pl = partition_plane_context(xd, bsize);
        r += x->partition_cost[pl][PARTITION_NONE];
      }

      if (RDCOST(x->rdmult, x->rddiv, r, d)
          < RDCOST(x->rdmult, x->rddiv, srate, sdist)) {
        srate = r;
        sdist = d;
        if (bsize >= BLOCK_SIZE_SB8X8)
          *(get_sb_partitioning(x, bsize)) = bsize;
      }
    }
  }
  *rate = srate;
  *dist = sdist;

  restore_context(cpi, mi_row, mi_col, a, l, sa, sl, bsize);

  if (srate < INT_MAX && sdist < INT_MAX)
    encode_sb(cpi, tp, mi_row, mi_col, bsize == BLOCK_SIZE_SB64X64, bsize);

  if (bsize == BLOCK_SIZE_SB64X64) {
    assert(tp_orig < *tp);
    assert(srate < INT_MAX);
    assert(sdist < INT_MAX);
  } else {
    assert(tp_orig == *tp);
  }
}

static void encode_sb_row(VP9_COMP *cpi, int mi_row, TOKENEXTRA **tp,
                          int *totalrate) {
  VP9_COMMON * const cm = &cpi->common;
  int mi_col;

  // Initialize the left context for the new SB row
  vpx_memset(&cm->left_context, 0, sizeof(cm->left_context));
  vpx_memset(cm->left_seg_context, 0, sizeof(cm->left_seg_context));

  // Code each SB in the row
  for (mi_col = cm->cur_tile_mi_col_start; mi_col < cm->cur_tile_mi_col_end;
      mi_col += 64 / MI_SIZE) {
    int dummy_rate;
    int64_t dummy_dist;
    if (cpi->sf.partition_by_variance || cpi->sf.use_lastframe_partitioning ||
        cpi->sf.use_one_partition_size_always ) {
      const int idx_str = cm->mode_info_stride * mi_row + mi_col;
      MODE_INFO *m = cm->mi + idx_str;
      MODE_INFO *p = cm->prev_mi + idx_str;

      if (cpi->sf.use_one_partition_size_always) {
        set_offsets(cpi, mi_row, mi_col, BLOCK_SIZE_SB64X64);
        set_partitioning(cpi, m, cpi->sf.always_this_block_size);
        rd_use_partition(cpi, m, tp, mi_row, mi_col, BLOCK_SIZE_SB64X64,
                         &dummy_rate, &dummy_dist);
      } else if (cpi->sf.partition_by_variance) {
        choose_partitioning(cpi, cm->mi, mi_row, mi_col);
        rd_use_partition(cpi, m, tp, mi_row, mi_col, BLOCK_SIZE_SB64X64,
                         &dummy_rate, &dummy_dist);
      } else {
        if ((cpi->common.current_video_frame & 1) == 0 || cm->prev_mi == 0
            || cpi->common.show_frame == 0
            || cpi->common.frame_type == KEY_FRAME
            || cpi->is_src_frame_alt_ref) {
          rd_pick_partition(cpi, tp, mi_row, mi_col, BLOCK_SIZE_SB64X64,
                            &dummy_rate, &dummy_dist);
        } else {
          copy_partitioning(cpi, m, p);
          rd_use_partition(cpi, m, tp, mi_row, mi_col, BLOCK_SIZE_SB64X64,
                           &dummy_rate, &dummy_dist);
        }
      }
    } else {
      rd_pick_partition(cpi, tp, mi_row, mi_col, BLOCK_SIZE_SB64X64,
                        &dummy_rate, &dummy_dist);
    }
  }
}

static void init_encode_frame_mb_context(VP9_COMP *cpi) {
  MACROBLOCK * const x = &cpi->mb;
  VP9_COMMON * const cm = &cpi->common;
  MACROBLOCKD * const xd = &x->e_mbd;

  x->act_zbin_adj = 0;
  cpi->seg0_idx = 0;

  xd->mode_info_stride = cm->mode_info_stride;
  xd->frame_type = cm->frame_type;

  xd->frames_since_golden = cm->frames_since_golden;
  xd->frames_till_alt_ref_frame = cm->frames_till_alt_ref_frame;

  // reset intra mode contexts
  if (cm->frame_type == KEY_FRAME)
    vp9_init_mbmode_probs(cm);

  // Copy data over into macro block data structures.
  vp9_setup_src_planes(x, cpi->Source, 0, 0);

  // TODO(jkoleszar): are these initializations required?
  setup_pre_planes(xd, &cm->yv12_fb[cm->ref_frame_map[cpi->lst_fb_idx]], NULL,
                   0, 0, NULL, NULL );
  setup_dst_planes(xd, &cm->yv12_fb[cm->new_fb_idx], 0, 0);

  vp9_build_block_offsets(x);

  vp9_setup_block_dptrs(&x->e_mbd, cm->subsampling_x, cm->subsampling_y);

  xd->mode_info_context->mbmi.mode = DC_PRED;
  xd->mode_info_context->mbmi.uv_mode = DC_PRED;

  vp9_zero(cpi->y_mode_count)
  vp9_zero(cpi->y_uv_mode_count)
  vp9_zero(cm->fc.inter_mode_counts)
  vp9_zero(cpi->partition_count);
  vp9_zero(cpi->intra_inter_count);
  vp9_zero(cpi->comp_inter_count);
  vp9_zero(cpi->single_ref_count);
  vp9_zero(cpi->comp_ref_count);
  vp9_zero(cm->fc.tx_count_32x32p);
  vp9_zero(cm->fc.tx_count_16x16p);
  vp9_zero(cm->fc.tx_count_8x8p);
  vp9_zero(cm->fc.mbskip_count);

  // Note: this memset assumes above_context[0], [1] and [2]
  // are allocated as part of the same buffer.
  vpx_memset(
      cm->above_context[0], 0,
      sizeof(ENTROPY_CONTEXT) * 2 * MAX_MB_PLANE * mi_cols_aligned_to_sb(cm));
  vpx_memset(cm->above_seg_context, 0,
             sizeof(PARTITION_CONTEXT) * mi_cols_aligned_to_sb(cm));
}

static void switch_lossless_mode(VP9_COMP *cpi, int lossless) {
  if (lossless) {
    cpi->mb.fwd_txm8x4 = vp9_short_walsh8x4;
    cpi->mb.fwd_txm4x4 = vp9_short_walsh4x4;
    cpi->mb.e_mbd.inv_txm4x4_1_add = vp9_short_iwalsh4x4_1_add;
    cpi->mb.e_mbd.inv_txm4x4_add = vp9_short_iwalsh4x4_add;
    cpi->mb.optimize = 0;
    cpi->common.filter_level = 0;
    cpi->zbin_mode_boost_enabled = 0;
    cpi->common.txfm_mode = ONLY_4X4;
  } else {
    cpi->mb.fwd_txm8x4 = vp9_short_fdct8x4;
    cpi->mb.fwd_txm4x4 = vp9_short_fdct4x4;
    cpi->mb.e_mbd.inv_txm4x4_1_add = vp9_short_idct4x4_1_add;
    cpi->mb.e_mbd.inv_txm4x4_add = vp9_short_idct4x4_add;
  }
}

static void encode_frame_internal(VP9_COMP *cpi) {
  int mi_row;
  MACROBLOCK * const x = &cpi->mb;
  VP9_COMMON * const cm = &cpi->common;
  MACROBLOCKD * const xd = &x->e_mbd;
  int totalrate;

//  fprintf(stderr, "encode_frame_internal frame %d (%d) type %d\n",
//           cpi->common.current_video_frame, cpi->common.show_frame,
//           cm->frame_type);

// debug output
#if DBG_PRNT_SEGMAP
  {
    FILE *statsfile;
    statsfile = fopen("segmap2.stt", "a");
    fprintf(statsfile, "\n");
    fclose(statsfile);
  }
#endif

  totalrate = 0;

  // Reset frame count of inter 0,0 motion vector usage.
  cpi->inter_zz_count = 0;

  vp9_zero(cm->fc.switchable_interp_count);
  vp9_zero(cpi->best_switchable_interp_count);

  xd->mode_info_context = cm->mi;
  xd->prev_mode_info_context = cm->prev_mi;

  vp9_zero(cpi->NMVcount);
  vp9_zero(cpi->coef_counts);
  vp9_zero(cm->fc.eob_branch_counts);

  cpi->mb.e_mbd.lossless = cm->base_qindex == 0 && cm->y_dc_delta_q == 0
      && cm->uv_dc_delta_q == 0 && cm->uv_ac_delta_q == 0;
  switch_lossless_mode(cpi, cpi->mb.e_mbd.lossless);

  vp9_frame_init_quantizer(cpi);

  vp9_initialize_rd_consts(cpi, cm->base_qindex + cm->y_dc_delta_q);
  vp9_initialize_me_consts(cpi, cm->base_qindex);

  if (cpi->oxcf.tuning == VP8_TUNE_SSIM) {
    // Initialize encode frame context.
    init_encode_frame_mb_context(cpi);

    // Build a frame level activity map
    build_activity_map(cpi);
  }

  // re-initencode frame context.
  init_encode_frame_mb_context(cpi);

  vpx_memset(cpi->rd_comp_pred_diff, 0, sizeof(cpi->rd_comp_pred_diff));
  vpx_memset(cpi->rd_tx_select_diff, 0, sizeof(cpi->rd_tx_select_diff));
  vpx_memset(cpi->rd_tx_select_threshes, 0, sizeof(cpi->rd_tx_select_threshes));

  set_prev_mi(cm);

  {
    struct vpx_usec_timer emr_timer;
    vpx_usec_timer_start(&emr_timer);

    {
      // Take tiles into account and give start/end MB
      int tile_col, tile_row;
      TOKENEXTRA *tp = cpi->tok;

      for (tile_row = 0; tile_row < cm->tile_rows; tile_row++) {
        vp9_get_tile_row_offsets(cm, tile_row);

        for (tile_col = 0; tile_col < cm->tile_columns; tile_col++) {
          TOKENEXTRA *tp_old = tp;

          // For each row of SBs in the frame
          vp9_get_tile_col_offsets(cm, tile_col);
          for (mi_row = cm->cur_tile_mi_row_start;
              mi_row < cm->cur_tile_mi_row_end; mi_row += 8)
            encode_sb_row(cpi, mi_row, &tp, &totalrate);

          cpi->tok_count[tile_row][tile_col] = (unsigned int)(tp - tp_old);
          assert(tp - cpi->tok <=
                 get_token_alloc(cm->mb_rows, cm->mb_cols));
        }
      }
    }

    vpx_usec_timer_mark(&emr_timer);
    cpi->time_encode_mb_row += vpx_usec_timer_elapsed(&emr_timer);
  }

  // 256 rate units to the bit,
  // projected_frame_size in units of BYTES
  cpi->projected_frame_size = totalrate >> 8;

#if 0
  // Keep record of the total distortion this time around for future use
  cpi->last_frame_distortion = cpi->frame_distortion;
#endif

}

static int check_dual_ref_flags(VP9_COMP *cpi) {
  MACROBLOCKD *xd = &cpi->mb.e_mbd;
  int ref_flags = cpi->ref_frame_flags;

  if (vp9_segfeature_active(xd, 1, SEG_LVL_REF_FRAME)) {
    return 0;
  } else {
    return (!!(ref_flags & VP9_GOLD_FLAG) + !!(ref_flags & VP9_LAST_FLAG)
        + !!(ref_flags & VP9_ALT_FLAG)) >= 2;
  }
}

static int get_skip_flag(MODE_INFO *mi, int mis, int ymbs, int xmbs) {
  int x, y;

  for (y = 0; y < ymbs; y++) {
    for (x = 0; x < xmbs; x++) {
      if (!mi[y * mis + x].mbmi.mb_skip_coeff)
        return 0;
    }
  }

  return 1;
}

static void set_txfm_flag(MODE_INFO *mi, int mis, int ymbs, int xmbs,
                          TX_SIZE txfm_size) {
  int x, y;

  for (y = 0; y < ymbs; y++) {
    for (x = 0; x < xmbs; x++)
      mi[y * mis + x].mbmi.txfm_size = txfm_size;
  }
}

static void reset_skip_txfm_size_b(VP9_COMP *cpi, MODE_INFO *mi, int mis,
                                   TX_SIZE txfm_max, int bw, int bh, int mi_row,
                                   int mi_col, BLOCK_SIZE_TYPE bsize) {
  VP9_COMMON * const cm = &cpi->common;
  MB_MODE_INFO * const mbmi = &mi->mbmi;

  if (mi_row >= cm->mi_rows || mi_col >= cm->mi_cols)
    return;

  if (mbmi->txfm_size > txfm_max) {
    MACROBLOCK * const x = &cpi->mb;
    MACROBLOCKD * const xd = &x->e_mbd;
    const int segment_id = mbmi->segment_id;
    const int ymbs = MIN(bh, cm->mi_rows - mi_row);
    const int xmbs = MIN(bw, cm->mi_cols - mi_col);

    xd->mode_info_context = mi;
    assert(
        vp9_segfeature_active(xd, segment_id, SEG_LVL_SKIP) || get_skip_flag(mi, mis, ymbs, xmbs));
    set_txfm_flag(mi, mis, ymbs, xmbs, txfm_max);
  }
}

static void reset_skip_txfm_size_sb(VP9_COMP *cpi, MODE_INFO *mi,
                                    TX_SIZE txfm_max, int mi_row, int mi_col,
                                    BLOCK_SIZE_TYPE bsize) {
  VP9_COMMON * const cm = &cpi->common;
  const int mis = cm->mode_info_stride;
  int bwl, bhl;
  const int bsl = mi_width_log2(bsize), bs = 1 << (bsl - 1);

  if (mi_row >= cm->mi_rows || mi_col >= cm->mi_cols)
    return;

  bwl = mi_width_log2(mi->mbmi.sb_type);
  bhl = mi_height_log2(mi->mbmi.sb_type);

  if (bwl == bsl && bhl == bsl) {
    reset_skip_txfm_size_b(cpi, mi, mis, txfm_max, 1 << bsl, 1 << bsl, mi_row,
                           mi_col, bsize);
  } else if (bwl == bsl && bhl < bsl) {
    reset_skip_txfm_size_b(cpi, mi, mis, txfm_max, 1 << bsl, bs, mi_row, mi_col,
                           bsize);
    reset_skip_txfm_size_b(cpi, mi + bs * mis, mis, txfm_max, 1 << bsl, bs,
                           mi_row + bs, mi_col, bsize);
  } else if (bwl < bsl && bhl == bsl) {
    reset_skip_txfm_size_b(cpi, mi, mis, txfm_max, bs, 1 << bsl, mi_row, mi_col,
                           bsize);
    reset_skip_txfm_size_b(cpi, mi + bs, mis, txfm_max, bs, 1 << bsl, mi_row,
                           mi_col + bs, bsize);
  } else {
    BLOCK_SIZE_TYPE subsize;
    int n;

    assert(bwl < bsl && bhl < bsl);
    if (bsize == BLOCK_SIZE_SB64X64) {
      subsize = BLOCK_SIZE_SB32X32;
    } else if (bsize == BLOCK_SIZE_SB32X32) {
      subsize = BLOCK_SIZE_MB16X16;
    } else {
      assert(bsize == BLOCK_SIZE_MB16X16);
      subsize = BLOCK_SIZE_SB8X8;
    }

    for (n = 0; n < 4; n++) {
      const int y_idx = n >> 1, x_idx = n & 0x01;

      reset_skip_txfm_size_sb(cpi, mi + y_idx * bs * mis + x_idx * bs, txfm_max,
                              mi_row + y_idx * bs, mi_col + x_idx * bs,
                              subsize);
    }
  }
}

static void reset_skip_txfm_size(VP9_COMP *cpi, TX_SIZE txfm_max) {
  VP9_COMMON * const cm = &cpi->common;
  int mi_row, mi_col;
  const int mis = cm->mode_info_stride;
  MODE_INFO *mi, *mi_ptr = cm->mi;

  for (mi_row = 0; mi_row < cm->mi_rows; mi_row += 8, mi_ptr += 8 * mis) {
    mi = mi_ptr;
    for (mi_col = 0; mi_col < cm->mi_cols; mi_col += 8, mi += 8) {
      reset_skip_txfm_size_sb(cpi, mi, txfm_max, mi_row, mi_col,
                              BLOCK_SIZE_SB64X64);
    }
  }
}

void vp9_encode_frame(VP9_COMP *cpi) {
  VP9_COMMON * const cm = &cpi->common;

  // In the longer term the encoder should be generalized to match the
  // decoder such that we allow compound where one of the 3 buffers has a
  // differnt sign bias and that buffer is then the fixed ref. However, this
  // requires further work in the rd loop. For now the only supported encoder
  // side behaviour is where the ALT ref buffer has oppositie sign bias to
  // the other two.
  if ((cm->ref_frame_sign_bias[ALTREF_FRAME]
      == cm->ref_frame_sign_bias[GOLDEN_FRAME])
      || (cm->ref_frame_sign_bias[ALTREF_FRAME]
          == cm->ref_frame_sign_bias[LAST_FRAME])) {
    cm->allow_comp_inter_inter = 0;
  } else {
    cm->allow_comp_inter_inter = 1;
    cm->comp_fixed_ref = ALTREF_FRAME;
    cm->comp_var_ref[0] = LAST_FRAME;
    cm->comp_var_ref[1] = GOLDEN_FRAME;
  }

  if (cpi->sf.RD) {
    int i, frame_type, pred_type;
    TXFM_MODE txfm_type;

    /*
     * This code does a single RD pass over the whole frame assuming
     * either compound, single or hybrid prediction as per whatever has
     * worked best for that type of frame in the past.
     * It also predicts whether another coding mode would have worked
     * better that this coding mode. If that is the case, it remembers
     * that for subsequent frames.
     * It does the same analysis for transform size selection also.
     */
    if (cpi->common.frame_type == KEY_FRAME)
      frame_type = 0;
    else if (cpi->is_src_frame_alt_ref && cpi->refresh_golden_frame)
      frame_type = 3;
    else if (cpi->refresh_golden_frame || cpi->refresh_alt_ref_frame)
      frame_type = 1;
    else
      frame_type = 2;

    /* prediction (compound, single or hybrid) mode selection */
    if (frame_type == 3 || !cm->allow_comp_inter_inter)
      pred_type = SINGLE_PREDICTION_ONLY;
    else if (cpi->rd_prediction_type_threshes[frame_type][1]
        > cpi->rd_prediction_type_threshes[frame_type][0]
        && cpi->rd_prediction_type_threshes[frame_type][1]
            > cpi->rd_prediction_type_threshes[frame_type][2]
        && check_dual_ref_flags(cpi) && cpi->static_mb_pct == 100)
      pred_type = COMP_PREDICTION_ONLY;
    else if (cpi->rd_prediction_type_threshes[frame_type][0]
        > cpi->rd_prediction_type_threshes[frame_type][2])
      pred_type = SINGLE_PREDICTION_ONLY;
    else
      pred_type = HYBRID_PREDICTION;

    /* transform size (4x4, 8x8, 16x16 or select-per-mb) selection */

    cpi->mb.e_mbd.lossless = 0;
    if (cpi->oxcf.lossless) {
      txfm_type = ONLY_4X4;
      cpi->mb.e_mbd.lossless = 1;
    } else
#if 0
      /* FIXME (rbultje): this code is disabled until we support cost updates
       * while a frame is being encoded; the problem is that each time we
       * "revert" to 4x4 only (or even 8x8 only), the coefficient probabilities
       * for 16x16 (and 8x8) start lagging behind, thus leading to them lagging
       * further behind and not being chosen for subsequent frames either. This
       * is essentially a local minimum problem that we can probably fix by
       * estimating real costs more closely within a frame, perhaps by re-
       * calculating costs on-the-fly as frame encoding progresses. */
      if (cpi->rd_tx_select_threshes[frame_type][TX_MODE_SELECT] >
          cpi->rd_tx_select_threshes[frame_type][ONLY_4X4] &&
          cpi->rd_tx_select_threshes[frame_type][TX_MODE_SELECT] >
          cpi->rd_tx_select_threshes[frame_type][ALLOW_16X16] &&
          cpi->rd_tx_select_threshes[frame_type][TX_MODE_SELECT] >
          cpi->rd_tx_select_threshes[frame_type][ALLOW_8X8]) {
        txfm_type = TX_MODE_SELECT;
      } else if (cpi->rd_tx_select_threshes[frame_type][ONLY_4X4] >
          cpi->rd_tx_select_threshes[frame_type][ALLOW_8X8]
          && cpi->rd_tx_select_threshes[frame_type][ONLY_4X4] >
          cpi->rd_tx_select_threshes[frame_type][ALLOW_16X16]
      ) {
        txfm_type = ONLY_4X4;
      } else if (cpi->rd_tx_select_threshes[frame_type][ALLOW_16X16] >=
          cpi->rd_tx_select_threshes[frame_type][ALLOW_8X8]) {
        txfm_type = ALLOW_16X16;
      } else
      txfm_type = ALLOW_8X8;
#else
      txfm_type =
          cpi->rd_tx_select_threshes[frame_type][ALLOW_32X32]
              > cpi->rd_tx_select_threshes[frame_type][TX_MODE_SELECT] ?
              ALLOW_32X32 : TX_MODE_SELECT;
#endif
    cpi->common.txfm_mode = txfm_type;
    cpi->common.comp_pred_mode = pred_type;
    encode_frame_internal(cpi);

    for (i = 0; i < NB_PREDICTION_TYPES; ++i) {
      const int diff = (int) (cpi->rd_comp_pred_diff[i] / cpi->common.MBs);
      cpi->rd_prediction_type_threshes[frame_type][i] += diff;
      cpi->rd_prediction_type_threshes[frame_type][i] >>= 1;
    }

    for (i = 0; i < NB_TXFM_MODES; ++i) {
      int64_t pd = cpi->rd_tx_select_diff[i];
      int diff;
      if (i == TX_MODE_SELECT)
        pd -= RDCOST(cpi->mb.rdmult, cpi->mb.rddiv,
            2048 * (TX_SIZE_MAX_SB - 1), 0);
      diff = (int) (pd / cpi->common.MBs);
      cpi->rd_tx_select_threshes[frame_type][i] += diff;
      cpi->rd_tx_select_threshes[frame_type][i] /= 2;
    }

    if (cpi->common.comp_pred_mode == HYBRID_PREDICTION) {
      int single_count_zero = 0;
      int comp_count_zero = 0;

      for (i = 0; i < COMP_INTER_CONTEXTS; i++) {
        single_count_zero += cpi->comp_inter_count[i][0];
        comp_count_zero += cpi->comp_inter_count[i][1];
      }

      if (comp_count_zero == 0) {
        cpi->common.comp_pred_mode = SINGLE_PREDICTION_ONLY;
        vp9_zero(cpi->comp_inter_count);
      } else if (single_count_zero == 0) {
        cpi->common.comp_pred_mode = COMP_PREDICTION_ONLY;
        vp9_zero(cpi->comp_inter_count);
      }
    }

    if (cpi->common.txfm_mode == TX_MODE_SELECT) {
      int count4x4 = 0;
      int count8x8_lp = 0, count8x8_8x8p = 0;
      int count16x16_16x16p = 0, count16x16_lp = 0;
      int count32x32 = 0;

      for (i = 0; i < TX_SIZE_CONTEXTS; i++)
        count4x4 += cm->fc.tx_count_32x32p[i][TX_4X4];
      for (i = 0; i < TX_SIZE_CONTEXTS; i++)
        count4x4 += cm->fc.tx_count_16x16p[i][TX_4X4];
      for (i = 0; i < TX_SIZE_CONTEXTS; i++)
        count4x4 += cm->fc.tx_count_8x8p[i][TX_4X4];

      for (i = 0; i < TX_SIZE_CONTEXTS; i++)
        count8x8_lp += cm->fc.tx_count_32x32p[i][TX_8X8];