encodeframe.c

#endif
    }

    // this is to account for the border
    x->gf_active_ptr += mb_cols - (mb_cols & 0x1);
    x->partition_info += xd->mode_info_stride + 1 - (mb_cols & 0x1);
    xd->mode_info_context += xd->mode_info_stride + 1 - (mb_cols & 0x1);
    xd->prev_mode_info_context += xd->mode_info_stride + 1 - (mb_cols & 0x1);

#if CONFIG_DEBUG
    assert((xd->prev_mode_info_context - cpi->common.prev_mip) ==
           (xd->mode_info_context - cpi->common.mip));
#endif
}

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

    // GF active flags data structure
    x->gf_active_ptr = (signed char *)cpi->gf_active_flags;

    // Activity map pointer
    x->mb_activity_ptr = cpi->mb_activity_map;

    x->act_zbin_adj = 0;
    cpi->seg0_idx = 0;
    vpx_memset(cpi->ref_pred_count, 0, sizeof(cpi->ref_pred_count));

    x->partition_info = x->pi;

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

    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)
        vp8_init_mbmode_probs(cm);

    // Copy data over into macro block data structures.
    x->src = * cpi->Source;
    xd->pre = cm->yv12_fb[cm->lst_fb_idx];
    xd->dst = cm->yv12_fb[cm->new_fb_idx];

    // set up frame for intra coded blocks
    vp8_setup_intra_recon(&cm->yv12_fb[cm->new_fb_idx]);

    vp8_build_block_offsets(x);

    vp8_setup_block_dptrs(&x->e_mbd);

    vp8_setup_block_ptrs(x);

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

    xd->left_context = &cm->left_context;

    vp8_zero(cpi->count_mb_ref_frame_usage)
    vp8_zero(cpi->bmode_count)
    vp8_zero(cpi->ymode_count)
    vp8_zero(cpi->i8x8_mode_count)
    vp8_zero(cpi->y_uv_mode_count)
    //vp8_zero(cpi->uv_mode_count)

    x->mvc = cm->fc.mvc;
#if CONFIG_HIGH_PRECISION_MV
    x->mvc_hp = cm->fc.mvc_hp;
#endif

    vpx_memset(cm->above_context, 0,
               sizeof(ENTROPY_CONTEXT_PLANES) * cm->mb_cols);

    xd->fullpixel_mask = 0xffffffff;
    if(cm->full_pixel)
        xd->fullpixel_mask = 0xfffffff8;
}

static void encode_frame_internal(VP8_COMP *cpi)
{
    int mb_row;
    MACROBLOCK *const x = & cpi->mb;
    VP8_COMMON *const cm = & cpi->common;
    MACROBLOCKD *const xd = & x->e_mbd;

    TOKENEXTRA *tp = cpi->tok;
    int totalrate;

    // Compute a modified set of reference frame probabilities to use when
    // prediction fails. These are based on the current general estimates for
    // this frame which may be updated with each iteration of the recode loop.
    compute_mod_refprobs( cm );

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

    totalrate = 0;

    // Functions setup for all frame types so we can use MC in AltRef
    if (cm->mcomp_filter_type == SIXTAP)
    {
        xd->subpixel_predict        = SUBPIX_INVOKE(
                                        &cpi->common.rtcd.subpix, sixtap4x4);
        xd->subpixel_predict8x4     = SUBPIX_INVOKE(
                                        &cpi->common.rtcd.subpix, sixtap8x4);
        xd->subpixel_predict8x8     = SUBPIX_INVOKE(
                                        &cpi->common.rtcd.subpix, sixtap8x8);
        xd->subpixel_predict16x16   = SUBPIX_INVOKE(
                                        &cpi->common.rtcd.subpix, sixtap16x16);
        xd->subpixel_predict_avg    = SUBPIX_INVOKE(
                                        &cpi->common.rtcd.subpix, sixtap_avg4x4);
        xd->subpixel_predict_avg8x8 = SUBPIX_INVOKE(
                                        &cpi->common.rtcd.subpix, sixtap_avg8x8);
        xd->subpixel_predict_avg16x16 = SUBPIX_INVOKE(
                                        &cpi->common.rtcd.subpix, sixtap_avg16x16);
    }
#if CONFIG_ENHANCED_INTERP
    else if (cm->mcomp_filter_type == EIGHTTAP)
    {
        xd->subpixel_predict        = SUBPIX_INVOKE(
                                        &cpi->common.rtcd.subpix, eighttap4x4);
        xd->subpixel_predict8x4     = SUBPIX_INVOKE(
                                        &cpi->common.rtcd.subpix, eighttap8x4);
        xd->subpixel_predict8x8     = SUBPIX_INVOKE(
                                        &cpi->common.rtcd.subpix, eighttap8x8);
        xd->subpixel_predict16x16   = SUBPIX_INVOKE(
                                        &cpi->common.rtcd.subpix, eighttap16x16);
        xd->subpixel_predict_avg    = SUBPIX_INVOKE(
                                        &cpi->common.rtcd.subpix, eighttap_avg4x4);
        xd->subpixel_predict_avg8x8 = SUBPIX_INVOKE(
                                        &cpi->common.rtcd.subpix, eighttap_avg8x8);
        xd->subpixel_predict_avg16x16 = SUBPIX_INVOKE(
                                        &cpi->common.rtcd.subpix, eighttap_avg16x16);
    }
    else if (cm->mcomp_filter_type == EIGHTTAP_SHARP)
    {
        xd->subpixel_predict        = SUBPIX_INVOKE(
                                        &cpi->common.rtcd.subpix, eighttap4x4_sharp);
        xd->subpixel_predict8x4     = SUBPIX_INVOKE(
                                        &cpi->common.rtcd.subpix, eighttap8x4_sharp);
        xd->subpixel_predict8x8     = SUBPIX_INVOKE(
                                        &cpi->common.rtcd.subpix, eighttap8x8_sharp);
        xd->subpixel_predict16x16   = SUBPIX_INVOKE(
                                        &cpi->common.rtcd.subpix, eighttap16x16_sharp);
        xd->subpixel_predict_avg    = SUBPIX_INVOKE(
                                        &cpi->common.rtcd.subpix, eighttap_avg4x4_sharp);
        xd->subpixel_predict_avg8x8 = SUBPIX_INVOKE(
                                        &cpi->common.rtcd.subpix, eighttap_avg8x8_sharp);
        xd->subpixel_predict_avg16x16 = SUBPIX_INVOKE(
                                        &cpi->common.rtcd.subpix, eighttap_avg16x16_sharp);
    }
#endif
    else
    {
        xd->subpixel_predict        = SUBPIX_INVOKE(
                                        &cpi->common.rtcd.subpix, bilinear4x4);
        xd->subpixel_predict8x4     = SUBPIX_INVOKE(
                                        &cpi->common.rtcd.subpix, bilinear8x4);
        xd->subpixel_predict8x8     = SUBPIX_INVOKE(
                                        &cpi->common.rtcd.subpix, bilinear8x8);
        xd->subpixel_predict16x16   = SUBPIX_INVOKE(
                                      &cpi->common.rtcd.subpix, bilinear16x16);
        xd->subpixel_predict_avg    = SUBPIX_INVOKE(
                                      &cpi->common.rtcd.subpix, bilinear_avg4x4);
        xd->subpixel_predict_avg8x8 = SUBPIX_INVOKE(
                                      &cpi->common.rtcd.subpix, bilinear_avg8x8);
        xd->subpixel_predict_avg16x16 = SUBPIX_INVOKE(
                                      &cpi->common.rtcd.subpix, bilinear_avg16x16);
    }

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

    cpi->prediction_error = 0;
    cpi->intra_error = 0;
#if CONFIG_NEWENTROPY
    cpi->skip_true_count[0] = cpi->skip_true_count[1] = cpi->skip_true_count[2] = 0;
    cpi->skip_false_count[0] = cpi->skip_false_count[1] = cpi->skip_false_count[2] = 0;
#else
    cpi->skip_true_count = 0;
    cpi->skip_false_count = 0;
#endif

#if 0
    // Experimental code
    cpi->frame_distortion = 0;
    cpi->last_mb_distortion = 0;
#endif

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

    vp8_zero(cpi->MVcount);
#if CONFIG_HIGH_PRECISION_MV
    vp8_zero(cpi->MVcount_hp);
#endif
    vp8_zero(cpi->coef_counts);
    vp8_zero(cpi->coef_counts_8x8);

    vp8cx_frame_init_quantizer(cpi);

    vp8_initialize_rd_consts(cpi, cm->base_qindex + cm->y1dc_delta_q);
    vp8cx_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);

    cpi->rd_single_diff = cpi->rd_comp_diff = cpi->rd_hybrid_diff = 0;
    vpx_memset(cpi->single_pred_count, 0, sizeof(cpi->single_pred_count));
    vpx_memset(cpi->comp_pred_count, 0, sizeof(cpi->comp_pred_count));

    {
        struct vpx_usec_timer  emr_timer;
        vpx_usec_timer_start(&emr_timer);

        {
            // For each row of SBs in the frame
            for (mb_row = 0; mb_row < cm->mb_rows; mb_row+=2)
            {
                int offset = (cm->mb_cols+1) & ~0x1;

                encode_sb_row(cpi, cm, mb_row, x, xd, &tp, &totalrate);

                // adjust to the next row of SBs
                x->src.y_buffer += 32 * x->src.y_stride - 16 * offset;
                x->src.u_buffer += 16 * x->src.uv_stride - 8 * offset;
                x->src.v_buffer += 16 * x->src.uv_stride - 8 * offset;
            }

            cpi->tok_count = tp - cpi->tok;
        }

        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(VP8_COMP *cpi)
{
    MACROBLOCKD *xd = &cpi->mb.e_mbd;
    int ref_flags = cpi->ref_frame_flags;

    if (segfeature_active(xd, 1, SEG_LVL_REF_FRAME))
    {
        if ((ref_flags & (VP8_LAST_FLAG | VP8_GOLD_FLAG)) == (VP8_LAST_FLAG | VP8_GOLD_FLAG) &&
            check_segref(xd, 1, LAST_FRAME))
            return 1;
        if ((ref_flags & (VP8_GOLD_FLAG | VP8_ALT_FLAG )) == (VP8_GOLD_FLAG | VP8_ALT_FLAG ) &&
            check_segref(xd, 1, GOLDEN_FRAME))
            return 1;
        if ((ref_flags & (VP8_ALT_FLAG  | VP8_LAST_FLAG)) == (VP8_ALT_FLAG  | VP8_LAST_FLAG) &&
            check_segref(xd, 1, ALTREF_FRAME))
            return 1;
        return 0;
    }
    else
    {
        return (!!(ref_flags & VP8_GOLD_FLAG) +
                !!(ref_flags & VP8_LAST_FLAG) +
                !!(ref_flags & VP8_ALT_FLAG)    ) >= 2;
    }
}

void vp8_encode_frame(VP8_COMP *cpi)
{
    if (cpi->sf.RD)
    {
        int frame_type, pred_type;
        int redo = 0;
        int single_diff, comp_diff, hybrid_diff;

        /*
         * 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. If the difference is above a certain
         * threshold, it will actually re-encode the current frame using
         * that different coding mode.
         */
        if (cpi->common.frame_type == KEY_FRAME)
            frame_type = 0;
        else if (cpi->is_src_frame_alt_ref && cpi->common.refresh_golden_frame)
            frame_type = 3;
        else if (cpi->common.refresh_golden_frame || cpi->common.refresh_alt_ref_frame)
            frame_type = 1;
        else
            frame_type = 2;

        if (frame_type == 3)
            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))
            pred_type = COMP_PREDICTION_ONLY;
        else if (cpi->rd_prediction_type_threshes[frame_type][0] >
                    cpi->rd_prediction_type_threshes[frame_type][1] &&
                 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;

        cpi->common.comp_pred_mode = pred_type;
        encode_frame_internal(cpi);

        single_diff = cpi->rd_single_diff / cpi->common.MBs;
        cpi->rd_prediction_type_threshes[frame_type][0] += single_diff;
        cpi->rd_prediction_type_threshes[frame_type][0] >>= 1;
        comp_diff   = cpi->rd_comp_diff   / cpi->common.MBs;
        cpi->rd_prediction_type_threshes[frame_type][1] += comp_diff;
        cpi->rd_prediction_type_threshes[frame_type][1] >>= 1;
        hybrid_diff = cpi->rd_hybrid_diff / cpi->common.MBs;
        cpi->rd_prediction_type_threshes[frame_type][2] += hybrid_diff;
        cpi->rd_prediction_type_threshes[frame_type][2] >>= 1;

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

            for ( i = 0; i < COMP_PRED_CONTEXTS; i++ )
            {
                single_count_zero += cpi->single_pred_count[i];
                comp_count_zero += cpi->comp_pred_count[i];
            }

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

}

void vp8_setup_block_ptrs(MACROBLOCK *x)
{
    int r, c;
    int i;

    for (r = 0; r < 4; r++)
    {
        for (c = 0; c < 4; c++)
        {
            x->block[r*4+c].src_diff = x->src_diff + r * 4 * 16 + c * 4;
        }
    }

    for (r = 0; r < 2; r++)
    {
        for (c = 0; c < 2; c++)
        {
            x->block[16 + r*2+c].src_diff = x->src_diff + 256 + r * 4 * 8 + c * 4;
        }
    }


    for (r = 0; r < 2; r++)
    {
        for (c = 0; c < 2; c++)
        {
            x->block[20 + r*2+c].src_diff = x->src_diff + 320 + r * 4 * 8 + c * 4;
        }
    }

    x->block[24].src_diff = x->src_diff + 384;


    for (i = 0; i < 25; i++)
    {
        x->block[i].coeff = x->coeff + i * 16;
    }
}

void vp8_build_block_offsets(MACROBLOCK *x)
{
    int block = 0;
    int br, bc;

    vp8_build_block_doffsets(&x->e_mbd);

    // y blocks
    x->thismb_ptr = &x->thismb[0];
    for (br = 0; br < 4; br++)
    {
        for (bc = 0; bc < 4; bc++)
        {
            BLOCK *this_block = &x->block[block];
            //this_block->base_src = &x->src.y_buffer;
            //this_block->src_stride = x->src.y_stride;
            //this_block->src = 4 * br * this_block->src_stride + 4 * bc;
            this_block->base_src = &x->thismb_ptr;
            this_block->src_stride = 16;
            this_block->src = 4 * br * 16 + 4 * bc;
            ++block;
        }
    }

    // u blocks
    for (br = 0; br < 2; br++)
    {
        for (bc = 0; bc < 2; bc++)
        {
            BLOCK *this_block = &x->block[block];
            this_block->base_src = &x->src.u_buffer;
            this_block->src_stride = x->src.uv_stride;
            this_block->src = 4 * br * this_block->src_stride + 4 * bc;
            ++block;
        }
    }

    // v blocks
    for (br = 0; br < 2; br++)
    {
        for (bc = 0; bc < 2; bc++)
        {
            BLOCK *this_block = &x->block[block];
            this_block->base_src = &x->src.v_buffer;
            this_block->src_stride = x->src.uv_stride;
            this_block->src = 4 * br * this_block->src_stride + 4 * bc;
            ++block;
        }
    }
}

static void sum_intra_stats(VP8_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;

#ifdef MODE_STATS
    const int is_key = cpi->common.frame_type == KEY_FRAME;

    ++ (is_key ? uv_modes : inter_uv_modes)[uvm];
    ++ uv_modes_y[m][uvm];

    if (m == B_PRED)
    {
        unsigned int *const bct = is_key ? b_modes : inter_b_modes;

        int b = 0;

        do
        {
            ++ bct[xd->block[b].bmi.as_mode.first];
        }
        while (++b < 16);
    }

    if(m==I8X8_PRED)
    {
        i8x8_modes[xd->block[0].bmi.as_mode.first]++;
        i8x8_modes[xd->block[2].bmi.as_mode.first]++;
        i8x8_modes[xd->block[8].bmi.as_mode.first]++;
        i8x8_modes[xd->block[10].bmi.as_mode.first]++;
    }
#endif

    ++cpi->ymode_count[m];
    if (m!=I8X8_PRED)
        ++cpi->y_uv_mode_count[m][uvm];
    else
    {
        cpi->i8x8_mode_count[xd->block[0].bmi.as_mode.first]++;
        cpi->i8x8_mode_count[xd->block[2].bmi.as_mode.first]++;
        cpi->i8x8_mode_count[xd->block[8].bmi.as_mode.first]++;
        cpi->i8x8_mode_count[xd->block[10].bmi.as_mode.first]++;
    }
    if (m == B_PRED)
    {
        int b = 0;
        do
        {
            ++ cpi->bmode_count[xd->block[b].bmi.as_mode.first];
        }
        while (++b < 16);
    }
}

// Experimental stub function to create a per MB zbin adjustment based on
// some previously calculated measure of MB activity.
static void adjust_act_zbin( VP8_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
}

void vp8cx_encode_intra_macro_block(VP8_COMP *cpi,
                                   MACROBLOCK *x,
                                   TOKENEXTRA **t,
                                   int output_enabled)
{
    if((cpi->oxcf.tuning == VP8_TUNE_SSIM) && output_enabled)
    {
        adjust_act_zbin( cpi, x );
        vp8_update_zbin_extra(cpi, x);
    }

    /* test code: set transform size based on mode selection */
    if(cpi->common.txfm_mode == ALLOW_8X8
        && ( x->e_mbd.mode_info_context->mbmi.mode == DC_PRED
           || x->e_mbd.mode_info_context->mbmi.mode == TM_PRED))
    {
        x->e_mbd.mode_info_context->mbmi.txfm_size = TX_8X8;
        cpi->t8x8_count++;
    }
    else
    {
        x->e_mbd.mode_info_context->mbmi.txfm_size = TX_4X4;
        cpi->t4x4_count ++;
    }

    if(x->e_mbd.mode_info_context->mbmi.mode == I8X8_PRED)
    {
        vp8_encode_intra8x8mby(IF_RTCD(&cpi->rtcd), x);
        vp8_encode_intra8x8mbuv(IF_RTCD(&cpi->rtcd), x);
    }
    else if (x->e_mbd.mode_info_context->mbmi.mode == B_PRED)
        vp8_encode_intra4x4mby(IF_RTCD(&cpi->rtcd), x);
    else
        vp8_encode_intra16x16mby(IF_RTCD(&cpi->rtcd), x);

    if(x->e_mbd.mode_info_context->mbmi.mode != I8X8_PRED)
        vp8_encode_intra16x16mbuv(IF_RTCD(&cpi->rtcd), x);

    if (output_enabled)
    {
        // Tokenize
        sum_intra_stats(cpi, x);
        vp8_tokenize_mb(cpi, &x->e_mbd, t);
    }
}
#ifdef SPEEDSTATS
extern int cnt_pm;
#endif

extern void vp8_fix_contexts(MACROBLOCKD *x);

void vp8cx_encode_inter_macroblock
(
    VP8_COMP *cpi, MACROBLOCK *x, TOKENEXTRA **t,
    int recon_yoffset, int recon_uvoffset,
    int output_enabled
)
{
    VP8_COMMON *cm = &cpi->common;
    MACROBLOCKD *const xd = &x->e_mbd;
    int intra_error = 0;
    int rate;
    int distortion;
    unsigned char *segment_id = &xd->mode_info_context->mbmi.segment_id;
    int seg_ref_active;
    unsigned char ref_pred_flag;

    x->skip = 0;

    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 ( xd->mode_info_context->mbmi.ref_frame != INTRA_FRAME )
            {
                if (xd->mode_info_context->mbmi.mode == ZEROMV)
                {
                    if (xd->mode_info_context->mbmi.ref_frame != LAST_FRAME)
                        cpi->zbin_mode_boost = GF_ZEROMV_ZBIN_BOOST;
                    else
                        cpi->zbin_mode_boost = LF_ZEROMV_ZBIN_BOOST;
                }
                else if (xd->mode_info_context->mbmi.mode == SPLITMV)
                    cpi->zbin_mode_boost = 0;
                else
                    cpi->zbin_mode_boost = MV_ZBIN_BOOST;
            }
        }

        vp8_update_zbin_extra(cpi, x);
    }

    seg_ref_active = segfeature_active( xd, *segment_id, SEG_LVL_REF_FRAME );

    // SET VARIOUS PREDICTION FLAGS

    // Did the chosen reference frame match its predicted value.
    ref_pred_flag = ( (xd->mode_info_context->mbmi.ref_frame ==
                           get_pred_ref( cm, xd )) );
    set_pred_flag( xd, PRED_REF, ref_pred_flag );

    /* test code: set transform size based on mode selection */
    if( cpi->common.txfm_mode == ALLOW_8X8
        && x->e_mbd.mode_info_context->mbmi.mode != I8X8_PRED
        && x->e_mbd.mode_info_context->mbmi.mode != B_PRED
        && x->e_mbd.mode_info_context->mbmi.mode != SPLITMV)
    {
        x->e_mbd.mode_info_context->mbmi.txfm_size = TX_8X8;
        cpi->t8x8_count ++;
    }
    else
    {
        x->e_mbd.mode_info_context->mbmi.txfm_size = TX_4X4;
        cpi->t4x4_count++;
    }

    // If we have just a single reference frame coded for a segment then
    // exclude from the reference frame counts used to work out
    // probabilities. NOTE: At the moment we dont support custom trees
    // for the reference frame coding for each segment but this is a
    // possible future action.
    if ( !seg_ref_active ||
         ( ( check_segref( xd, *segment_id, INTRA_FRAME ) +
             check_segref( xd, *segment_id, LAST_FRAME ) +
             check_segref( xd, *segment_id, GOLDEN_FRAME ) +
             check_segref( xd, *segment_id, ALTREF_FRAME ) ) > 1 ) )
    {
// TODO this may not be a good idea as it makes sample size small and means
// the predictor functions cannot use data about most likely value only most
// likely unpredicted value.
//#if CONFIG_COMPRED
//        // Only update count for incorrectly predicted cases
//        if ( !ref_pred_flag )
//#endif
        {
            cpi->count_mb_ref_frame_usage
                [xd->mode_info_context->mbmi.ref_frame]++;
        }
    }

    if (xd->mode_info_context->mbmi.ref_frame == INTRA_FRAME)
    {
        if (xd->mode_info_context->mbmi.mode == B_PRED)
        {
            vp8_encode_intra16x16mbuv(IF_RTCD(&cpi->rtcd), x);
            vp8_encode_intra4x4mby(IF_RTCD(&cpi->rtcd), x);
        }
        else if(xd->mode_info_context->mbmi.mode == I8X8_PRED)
        {
            vp8_encode_intra8x8mby(IF_RTCD(&cpi->rtcd), x);
            vp8_encode_intra8x8mbuv(IF_RTCD(&cpi->rtcd), x);
        }
        else
        {
            vp8_encode_intra16x16mbuv(IF_RTCD(&cpi->rtcd), x);
            vp8_encode_intra16x16mby(IF_RTCD(&cpi->rtcd), x);
        }

        if (output_enabled)
            sum_intra_stats(cpi, x);
    }
    else
    {
        int ref_fb_idx;

        if (xd->mode_info_context->mbmi.ref_frame == LAST_FRAME)
            ref_fb_idx = cpi->common.lst_fb_idx;
        else if (xd->mode_info_context->mbmi.ref_frame == GOLDEN_FRAME)
            ref_fb_idx = cpi->common.gld_fb_idx;
        else
            ref_fb_idx = cpi->common.alt_fb_idx;

        xd->pre.y_buffer = cpi->common.yv12_fb[ref_fb_idx].y_buffer + recon_yoffset;
        xd->pre.u_buffer = cpi->common.yv12_fb[ref_fb_idx].u_buffer + recon_uvoffset;
        xd->pre.v_buffer = cpi->common.yv12_fb[ref_fb_idx].v_buffer + recon_uvoffset;

        if (xd->mode_info_context->mbmi.second_ref_frame) {
            int second_ref_fb_idx;

            if (xd->mode_info_context->mbmi.second_ref_frame == LAST_FRAME)
                second_ref_fb_idx = cpi->common.lst_fb_idx;
            else if (xd->mode_info_context->mbmi.second_ref_frame == GOLDEN_FRAME)
                second_ref_fb_idx = cpi->common.gld_fb_idx;
            else
                second_ref_fb_idx = cpi->common.alt_fb_idx;

            xd->second_pre.y_buffer = cpi->common.yv12_fb[second_ref_fb_idx].y_buffer +
                                            recon_yoffset;
            xd->second_pre.u_buffer = cpi->common.yv12_fb[second_ref_fb_idx].u_buffer +
                                            recon_uvoffset;
            xd->second_pre.v_buffer = cpi->common.yv12_fb[second_ref_fb_idx].v_buffer +
                                            recon_uvoffset;
        }

        if (!x->skip)
        {
            vp8_encode_inter16x16(IF_RTCD(&cpi->rtcd), x);

            // Clear mb_skip_coeff if mb_no_coeff_skip is not set
            if (!cpi->common.mb_no_coeff_skip)
                xd->mode_info_context->mbmi.mb_skip_coeff = 0;

        }
        else
        {
            vp8_build_inter16x16_predictors_mb(xd, xd->dst.y_buffer,
                                           xd->dst.u_buffer, xd->dst.v_buffer,
                                           xd->dst.y_stride, xd->dst.uv_stride);
        }
    }

    if (!x->skip)
    {
#ifdef ENC_DEBUG
        if (enc_debug)
        {
          int i;
            printf("Segment=%d [%d, %d]: %d %d:\n", x->e_mbd.mode_info_context->mbmi.segment_id, mb_col_debug, mb_row_debug, xd->mb_to_left_edge, xd->mb_to_top_edge);
            for (i =0; i<400; i++) {
              printf("%3d ", xd->qcoeff[i]);
              if (i%16 == 15) printf("\n");
            }
            printf("\n");
            printf("eobs = ");
            for (i=0;i<25;i++)
              printf("%d:%d ", i, xd->block[i].eob);
            printf("\n");
            fflush(stdout);
        }
#endif
        if (output_enabled)
            vp8_tokenize_mb(cpi, xd, t);
#ifdef ENC_DEBUG
        if (enc_debug) {
          printf("Tokenized\n");
          fflush(stdout);
        }
#endif
    }
    else
    {
#if CONFIG_NEWENTROPY
        int mb_skip_context =
            cpi->common.mb_no_coeff_skip ?
            (x->e_mbd.mode_info_context-1)->mbmi.mb_skip_coeff +
            (x->e_mbd.mode_info_context-cpi->common.mode_info_stride)->mbmi.mb_skip_coeff :
            0;
#endif
        if (cpi->common.mb_no_coeff_skip)
        {
            xd->mode_info_context->mbmi.mb_skip_coeff = 1;
#if CONFIG_NEWENTROPY
            cpi->skip_true_count[mb_skip_context] ++;
#else
            cpi->skip_true_count ++;
#endif
            vp8_fix_contexts(xd);
        }
        else
        {
            vp8_stuff_mb(cpi, xd, t);
            xd->mode_info_context->mbmi.mb_skip_coeff = 0;
#if CONFIG_NEWENTROPY
            cpi->skip_false_count[mb_skip_context] ++;
#else
            cpi->skip_false_count ++;
#endif
        }
    }
}