vp9_encodeframe.c

    unsigned int intra_count = 0, inter_count = 0;
    for (j = 0; j < INTRA_INTER_CONTEXTS; ++j) {
      intra_count += cpi->intra_inter_count[j][0];
      inter_count += cpi->intra_inter_count[j][1];
    }
    cpi->sf.skip_encode_frame = ((intra_count << 2) < inter_count);
    cpi->sf.skip_encode_frame &= (cm->frame_type != KEY_FRAME);
    cpi->sf.skip_encode_frame &= cm->show_frame;
  } else {
    cpi->sf.skip_encode_frame = 0;
  }

  // 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->seg, 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 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->seg, mbmi->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);
    }
  }
}

static int get_frame_type(VP9_COMP *cpi) {
  int frame_type;
  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;
  return frame_type;
}

static void select_txfm_mode(VP9_COMP *cpi) {
  if (cpi->oxcf.lossless) {
    cpi->common.txfm_mode = ONLY_4X4;
  } else if (cpi->common.current_video_frame == 0) {
    cpi->common.txfm_mode = TX_MODE_SELECT;
  } else {
    if (cpi->sf.tx_size_search_method == USE_LARGESTALL) {
      cpi->common.txfm_mode = ALLOW_32X32;
    } else if (cpi->sf.tx_size_search_method == USE_FULL_RD) {
      int frame_type = get_frame_type(cpi);
      cpi->common.txfm_mode =
          cpi->rd_tx_select_threshes[frame_type][ALLOW_32X32]
          > cpi->rd_tx_select_threshes[frame_type][TX_MODE_SELECT] ?
          ALLOW_32X32 : TX_MODE_SELECT;
    } else {
      unsigned int total = 0;
      int i;
      for (i = 0; i < TX_SIZE_MAX_SB; ++i)
        total += cpi->txfm_stepdown_count[i];
      if (total) {
        double fraction = (double)cpi->txfm_stepdown_count[0] / total;
        cpi->common.txfm_mode = fraction > 0.90 ? ALLOW_32X32 : TX_MODE_SELECT;
        // printf("fraction = %f\n", fraction);
      }  // else keep unchanged
    }
  }
}

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, pred_type;
    INTERPOLATIONFILTERTYPE filter_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.
     */
    int frame_type = get_frame_type(cpi);

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

    /* filter type selection */
    // FIXME(rbultje) for some odd reason, we often select smooth_filter
    // as default filter for ARF overlay frames. This is a REALLY BAD
    // IDEA so we explicitely disable it here.
    if (frame_type != 3 &&
        cpi->rd_filter_threshes[frame_type][1] >
            cpi->rd_filter_threshes[frame_type][0] &&
        cpi->rd_filter_threshes[frame_type][1] >
            cpi->rd_filter_threshes[frame_type][2] &&
        cpi->rd_filter_threshes[frame_type][1] >
            cpi->rd_filter_threshes[frame_type][VP9_SWITCHABLE_FILTERS]) {
      filter_type = vp9_switchable_interp[1];
    } else if (cpi->rd_filter_threshes[frame_type][2] >
            cpi->rd_filter_threshes[frame_type][0] &&
        cpi->rd_filter_threshes[frame_type][2] >
            cpi->rd_filter_threshes[frame_type][VP9_SWITCHABLE_FILTERS]) {
      filter_type = vp9_switchable_interp[2];
    } else if (cpi->rd_filter_threshes[frame_type][0] >
                  cpi->rd_filter_threshes[frame_type][VP9_SWITCHABLE_FILTERS]) {
      filter_type = vp9_switchable_interp[0];
    } else {
      filter_type = SWITCHABLE;
    }

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

    cpi->mb.e_mbd.lossless = 0;
    if (cpi->oxcf.lossless) {
      cpi->mb.e_mbd.lossless = 1;
    }

    select_txfm_mode(cpi);
    cpi->common.comp_pred_mode = pred_type;
    cpi->common.mcomp_filter_type = filter_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 <= VP9_SWITCHABLE_FILTERS; i++) {
      const int64_t diff = cpi->rd_filter_diff[i] / cpi->common.MBs;
      cpi->rd_filter_threshes[frame_type][i] =
          (cpi->rd_filter_threshes[frame_type][i] + diff) / 2;
    }

    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_counts.p32x32[i][TX_4X4];
      for (i = 0; i < TX_SIZE_CONTEXTS; i++)
        count4x4 += cm->fc.tx_counts.p16x16[i][TX_4X4];
      for (i = 0; i < TX_SIZE_CONTEXTS; i++)
        count4x4 += cm->fc.tx_counts.p8x8[i][TX_4X4];

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

      for (i = 0; i < TX_SIZE_CONTEXTS; i++)
        count8x8_8x8p += cm->fc.tx_counts.p8x8[i][TX_8X8];

      for (i = 0; i < TX_SIZE_CONTEXTS; i++)
        count16x16_16x16p += cm->fc.tx_counts.p16x16[i][TX_16X16];

      for (i = 0; i < TX_SIZE_CONTEXTS; i++)
        count16x16_lp += cm->fc.tx_counts.p32x32[i][TX_16X16];

      for (i = 0; i < TX_SIZE_CONTEXTS; i++)
        count32x32 += cm->fc.tx_counts.p32x32[i][TX_32X32];

      if (count4x4 == 0 && count16x16_lp == 0 && count16x16_16x16p == 0
          && count32x32 == 0) {
        cpi->common.txfm_mode = ALLOW_8X8;
        reset_skip_txfm_size(cpi, TX_8X8);
      } else if (count8x8_8x8p == 0 && count16x16_16x16p == 0
                 && count8x8_lp == 0 && count16x16_lp == 0 && count32x32 == 0) {
        cpi->common.txfm_mode = ONLY_4X4;
        reset_skip_txfm_size(cpi, TX_4X4);
      } else if (count8x8_lp == 0 && count16x16_lp == 0 && count4x4 == 0) {
        cpi->common.txfm_mode = ALLOW_32X32;
      } else if (count32x32 == 0 && count8x8_lp == 0 && count4x4 == 0) {
        cpi->common.txfm_mode = ALLOW_16X16;
        reset_skip_txfm_size(cpi, TX_16X16);
      }
    }
  } else {
    encode_frame_internal(cpi);
  }

}

static void sum_intra_stats(VP9_COMP *cpi, MACROBLOCK *x) {
  const MACROBLOCKD *xd = &x->e_mbd;
  const MB_PREDICTION_MODE m = xd->mode_info_context->mbmi.mode;
  const MB_PREDICTION_MODE uvm = xd->mode_info_context->mbmi.uv_mode;

  ++cpi->y_uv_mode_count[m][uvm];
  if (xd->mode_info_context->mbmi.sb_type >= BLOCK_SIZE_SB8X8) {
    const BLOCK_SIZE_TYPE bsize = xd->mode_info_context->mbmi.sb_type;
    const int bwl = b_width_log2(bsize), bhl = b_height_log2(bsize);
    const int bsl = MIN(bwl, bhl);
    ++cpi->y_mode_count[MIN(bsl, 3)][m];
  } else {
    int idx, idy;
    int bw = 1 << b_width_log2(xd->mode_info_context->mbmi.sb_type);
    int bh = 1 << b_height_log2(xd->mode_info_context->mbmi.sb_type);
    for (idy = 0; idy < 2; idy += bh) {
      for (idx = 0; idx < 2; idx += bw) {
        int m = xd->mode_info_context->bmi[idy * 2 + idx].as_mode;
        ++cpi->y_mode_count[0][m];
      }
    }
  }
}

// Experimental stub function to create a per MB zbin adjustment based on
// some previously calculated measure of MB activity.
static void adjust_act_zbin(VP9_COMP *cpi, MACROBLOCK *x) {
#if USE_ACT_INDEX
  x->act_zbin_adj = *(x->mb_activity_ptr);
#else
  int64_t a;
  int64_t b;
  int64_t act = *(x->mb_activity_ptr);

  // Apply the masking to the RD multiplier.
  a = act + 4 * cpi->activity_avg;
  b = 4 * act + cpi->activity_avg;

  if (act > cpi->activity_avg)
    x->act_zbin_adj = (int) (((int64_t) b + (a >> 1)) / a) - 1;
  else
    x->act_zbin_adj = 1 - (int) (((int64_t) a + (b >> 1)) / b);
#endif
}

static void encode_superblock(VP9_COMP *cpi, TOKENEXTRA **t, int output_enabled,
                              int mi_row, int mi_col, BLOCK_SIZE_TYPE bsize) {
  VP9_COMMON * const cm = &cpi->common;
  MACROBLOCK * const x = &cpi->mb;
  MACROBLOCKD * const xd = &x->e_mbd;
  MODE_INFO *mi = xd->mode_info_context;
  MB_MODE_INFO *mbmi = &mi->mbmi;
  unsigned int segment_id = mbmi->segment_id;
  const int mis = cm->mode_info_stride;
  const int bwl = mi_width_log2(bsize);
  const int bw = 1 << bwl, bh = 1 << mi_height_log2(bsize);
  x->rd_search = 0;
  x->skip_encode = (!output_enabled && cpi->sf.skip_encode_frame &&
                    xd->q_index < QIDX_SKIP_THRESH);
  if (x->skip_encode)
    return;

  if (cm->frame_type == KEY_FRAME) {
    if (cpi->oxcf.tuning == VP8_TUNE_SSIM) {
      adjust_act_zbin(cpi, x);
      vp9_update_zbin_extra(cpi, x);
    }
  } else {
    vp9_setup_interp_filters(xd, mbmi->interp_filter, cm);

    if (cpi->oxcf.tuning == VP8_TUNE_SSIM) {
      // Adjust the zbin based on this MB rate.
      adjust_act_zbin(cpi, x);
    }

    // Experimental code. Special case for gf and arf zeromv modes.
    // Increase zbin size to suppress noise
    cpi->zbin_mode_boost = 0;
    if (cpi->zbin_mode_boost_enabled) {
      if (mbmi->ref_frame[0] != INTRA_FRAME) {
        if (mbmi->mode == ZEROMV) {
          if (mbmi->ref_frame[0] != LAST_FRAME)
            cpi->zbin_mode_boost = GF_ZEROMV_ZBIN_BOOST;
          else
            cpi->zbin_mode_boost = LF_ZEROMV_ZBIN_BOOST;
        } else if (mbmi->sb_type < BLOCK_SIZE_SB8X8) {
          cpi->zbin_mode_boost = SPLIT_MV_ZBIN_BOOST;
        } else {
          cpi->zbin_mode_boost = MV_ZBIN_BOOST;
        }
      } else {
        cpi->zbin_mode_boost = INTRA_ZBIN_BOOST;
      }
    }

    vp9_update_zbin_extra(cpi, x);
  }

  if (mbmi->ref_frame[0] == INTRA_FRAME) {
    vp9_encode_intra_block_y(
        cm, x, (bsize < BLOCK_SIZE_SB8X8) ? BLOCK_SIZE_SB8X8 : bsize);
    vp9_encode_intra_block_uv(
        cm, x, (bsize < BLOCK_SIZE_SB8X8) ? BLOCK_SIZE_SB8X8 : bsize);
    if (output_enabled)
      sum_intra_stats(cpi, x);
  } else {
    int idx = cm->ref_frame_map[get_ref_frame_idx(cpi, mbmi->ref_frame[0])];
    YV12_BUFFER_CONFIG *ref_fb = &cm->yv12_fb[idx];
    YV12_BUFFER_CONFIG *second_ref_fb = NULL;
    if (mbmi->ref_frame[1] > 0) {
      idx = cm->ref_frame_map[get_ref_frame_idx(cpi, mbmi->ref_frame[1])];
      second_ref_fb = &cm->yv12_fb[idx];
    }

    assert(cm->frame_type != KEY_FRAME);

    setup_pre_planes(xd, 0, ref_fb, mi_row, mi_col,
                     &xd->scale_factor[0], &xd->scale_factor_uv[0]);
    setup_pre_planes(xd, 1, second_ref_fb, mi_row, mi_col,
                     &xd->scale_factor[1], &xd->scale_factor_uv[1]);


    vp9_build_inter_predictors_sb(
        xd, mi_row, mi_col,
        bsize < BLOCK_SIZE_SB8X8 ? BLOCK_SIZE_SB8X8 : bsize);
  }

  if (xd->mode_info_context->mbmi.ref_frame[0] == INTRA_FRAME) {
    vp9_tokenize_sb(cpi, t, !output_enabled,
                    (bsize < BLOCK_SIZE_SB8X8) ? BLOCK_SIZE_SB8X8 : bsize);
  } else if (!x->skip) {
    vp9_encode_sb(cm, x, (bsize < BLOCK_SIZE_SB8X8) ? BLOCK_SIZE_SB8X8 : bsize);
    vp9_tokenize_sb(cpi, t, !output_enabled,
                    (bsize < BLOCK_SIZE_SB8X8) ? BLOCK_SIZE_SB8X8 : bsize);
  } else {
    int mb_skip_context = xd->left_available ? (mi - 1)->mbmi.mb_skip_coeff : 0;
    mb_skip_context += (mi - mis)->mbmi.mb_skip_coeff;

    mbmi->mb_skip_coeff = 1;
    if (output_enabled)
      cm->fc.mbskip_count[mb_skip_context][1]++;
    vp9_reset_sb_tokens_context(
        xd, (bsize < BLOCK_SIZE_SB8X8) ? BLOCK_SIZE_SB8X8 : bsize);
  }

  // copy skip flag on all mb_mode_info contexts in this SB
  // if this was a skip at this txfm size
  vp9_set_pred_flag_mbskip(cm, bsize, mi_row, mi_col, mi->mbmi.mb_skip_coeff);

  if (output_enabled) {
    if (cm->txfm_mode == TX_MODE_SELECT &&
        mbmi->sb_type >= BLOCK_SIZE_SB8X8  &&
        !(mbmi->ref_frame[0] != INTRA_FRAME &&
            (mbmi->mb_skip_coeff ||
             vp9_segfeature_active(&xd->seg, segment_id, SEG_LVL_SKIP)))) {
      const int context = vp9_get_pred_context_tx_size(cm, xd);
      if (bsize >= BLOCK_SIZE_SB32X32) {
        cm->fc.tx_counts.p32x32[context][mbmi->txfm_size]++;
      } else if (bsize >= BLOCK_SIZE_MB16X16) {
        cm->fc.tx_counts.p16x16[context][mbmi->txfm_size]++;
      } else {
        cm->fc.tx_counts.p8x8[context][mbmi->txfm_size]++;
      }
    } else {
      int x, y;
      TX_SIZE sz = (cm->txfm_mode == TX_MODE_SELECT) ? TX_32X32 : cm->txfm_mode;
      // The new intra coding scheme requires no change of transform size
      if (mi->mbmi.ref_frame[0] != INTRA_FRAME) {
        if (sz == TX_32X32 && bsize < BLOCK_SIZE_SB32X32)
          sz = TX_16X16;
        if (sz == TX_16X16 && bsize < BLOCK_SIZE_MB16X16)
          sz = TX_8X8;
        if (sz == TX_8X8 && bsize < BLOCK_SIZE_SB8X8)
          sz = TX_4X4;
      } else if (bsize >= BLOCK_SIZE_SB8X8) {
        sz = mbmi->txfm_size;
      } else {
        sz = TX_4X4;
      }

      for (y = 0; y < bh; y++) {
        for (x = 0; x < bw; x++) {
          if (mi_col + x < cm->mi_cols && mi_row + y < cm->mi_rows) {
            mi[mis * y + x].mbmi.txfm_size = sz;
          }
        }
      }
    }
  }
}