analyse.c

H.264改进解码软件

            a->l0.me16x16 = m;

        /* save mv for predicting neighbors */
        a->l0.mvc[i_ref][0][0] =
        h->mb.mvr[0][i_ref][h->mb.i_mb_xy][0] = m.mv[0];
        a->l0.mvc[i_ref][0][1] =
        h->mb.mvr[0][i_ref][h->mb.i_mb_xy][1] = m.mv[1];
    }

    x264_macroblock_cache_ref( h, 0, 0, 4, 4, 0, a->l0.me16x16.i_ref );//更新 h->mb.cache.ref[]的部分值

    h->mb.i_type = P_L0;
    if( a->b_mbrd )
    {
        a->i_best_satd = a->l0.me16x16.cost;
        h->mb.i_partition = D_16x16;
        x264_macroblock_cache_mv ( h, 0, 0, 4, 4, 0, a->l0.me16x16.mv[0], a->l0.me16x16.mv[1] );
//        a->l0.me16x16.cost = x264_rd_cost_mb( h, a->i_lambda2 );
    }
}

static void x264_mb_analyse_inter_p8x8_mixed_ref( x264_t *h, x264_mb_analysis_t *a )
{
    x264_me_t m;
    int i_ref;
    uint8_t  **p_fenc = h->mb.pic.p_fenc;
    int i_halfpel_thresh = INT_MAX;
    int *p_halfpel_thresh = /*h->i_ref0>1 ? &i_halfpel_thresh : */NULL;
    int i;
    int i_maxref = h->i_ref0-1;

    h->mb.i_partition = D_8x8;

    /* early termination: if 16x16 chose ref 0, then evalute no refs older
     * than those used by the neighbors */
    if( i_maxref > 0 && a->l0.me16x16.i_ref == 0 &&
        h->mb.i_mb_type_top && h->mb.i_mb_type_left )
    {
        i_maxref = 0;
        i_maxref = X264_MAX( i_maxref, h->mb.cache.ref[0][ X264_SCAN8_0 - 8 - 1 ] );
        i_maxref = X264_MAX( i_maxref, h->mb.cache.ref[0][ X264_SCAN8_0 - 8 + 0 ] );
        i_maxref = X264_MAX( i_maxref, h->mb.cache.ref[0][ X264_SCAN8_0 - 8 + 2 ] );
        i_maxref = X264_MAX( i_maxref, h->mb.cache.ref[0][ X264_SCAN8_0 - 8 + 4 ] );
        i_maxref = X264_MAX( i_maxref, h->mb.cache.ref[0][ X264_SCAN8_0 + 0 - 1 ] );
        i_maxref = X264_MAX( i_maxref, h->mb.cache.ref[0][ X264_SCAN8_0 + 2*8 - 1 ] );
    }

    for( i_ref = 0; i_ref <= i_maxref; i_ref++ )
    {
         a->l0.mvc[i_ref][0][0] = h->mb.mvr[0][i_ref][h->mb.i_mb_xy][0];
         a->l0.mvc[i_ref][0][1] = h->mb.mvr[0][i_ref][h->mb.i_mb_xy][1];
    }

    for( i = 0; i < 4; i++ )
    {
        x264_me_t *l0m = &a->l0.me8x8[i];
        const int x8 = i%2;
        const int y8 = i/2;

        m.i_pixel = PIXEL_8x8;
        m.p_cost_mv = a->p_cost_mv;

        LOAD_FENC( &m, p_fenc, 8*x8, 8*y8 );
        l0m->cost = INT_MAX;
        for( i_ref = 0; i_ref <= i_maxref; i_ref++ )
        {
             const int i_ref_cost = REF_COST( 0, i_ref );
             i_halfpel_thresh -= i_ref_cost;
             m.i_ref_cost = i_ref_cost;
             m.i_ref = i_ref;

             LOAD_HPELS( &m, h->mb.pic.p_fref[0][i_ref], 0, i_ref, 8*x8, 8*y8 );
             x264_macroblock_cache_ref( h, 2*x8, 2*y8, 2, 2, 0, i_ref );
             x264_mb_predict_mv( h, 0, 4*i, 2, m.mvp );
             x264_me_search_ref( h, &m, a->l0.mvc[i_ref], i+1, p_halfpel_thresh );

             m.cost += i_ref_cost;
             i_halfpel_thresh += i_ref_cost;
             *(uint64_t*)a->l0.mvc[i_ref][i+1] = *(uint64_t*)m.mv;

             if( m.cost < l0m->cost )
                 *l0m = m;
        }
        x264_macroblock_cache_mv( h, 2*x8, 2*y8, 2, 2, 0, l0m->mv[0], l0m->mv[1] );
        x264_macroblock_cache_ref( h, 2*x8, 2*y8, 2, 2, 0, l0m->i_ref );

        /* mb type cost */
        l0m->cost += a->i_lambda * i_sub_mb_p_cost_table[D_L0_8x8];
    }

    a->l0.i_cost8x8 = a->l0.me8x8[0].cost + a->l0.me8x8[1].cost +
                      a->l0.me8x8[2].cost + a->l0.me8x8[3].cost;
    if( a->b_mbrd )
    {
        if( a->i_best_satd > a->l0.i_cost8x8 )
            a->i_best_satd = a->l0.i_cost8x8;
        h->mb.i_type = P_8x8;
        h->mb.i_sub_partition[0] = h->mb.i_sub_partition[1] =
        h->mb.i_sub_partition[2] = h->mb.i_sub_partition[3] = D_L0_8x8;
//        a->l0.i_cost8x8 = x264_rd_cost_mb( h, a->i_lambda2 );
    }
}

static void x264_mb_analyse_inter_p8x8( x264_t *h, x264_mb_analysis_t *a )
{
    const int i_ref = a->l0.me16x16.i_ref;
    const int i_ref_cost = REF_COST( 0, i_ref );
    uint8_t  **p_fref = h->mb.pic.p_fref[0][i_ref];//参考帧
    uint8_t  **p_fenc = h->mb.pic.p_fenc;//待编码宏块数据缓存
    int i_mvc;
    int (*mvc)[2] = a->l0.mvc[i_ref];//分别指向16*16和第一个8*8的可能预测矢量
    int i;

    /* XXX Needed for x264_mb_predict_mv */
    h->mb.i_partition = D_8x8;

    i_mvc = 1;
    *(uint64_t*)mvc[0] = *(uint64_t*)a->l0.me16x16.mv;

    for( i = 0; i < 4; i++ )//每宏块有4个8*8
    {
        x264_me_t *m = &a->l0.me8x8[i];
        const int x8 = i%2;//宏块内8*8块的行列坐标
        const int y8 = i/2;

        m->i_pixel = PIXEL_8x8;
        m->p_cost_mv = a->p_cost_mv;
        m->i_ref_cost = i_ref_cost;
        m->i_ref = i_ref;

        LOAD_FENC( m, p_fenc, 8*x8, 8*y8 );
        LOAD_HPELS( m, p_fref, 0, i_ref, 8*x8, 8*y8 );//后两个参数是当前8*8块首像素爱宏块内的行列坐标
        x264_mb_predict_mv( h, 0, 4*i, 2, m->mvp );//4*i,表示当前8*8的首个4*4在宏块内的索引号,求分割的初始预测矢量
        x264_me_search( h, m, mvc, i_mvc );//求得最佳矢量信息写入m->mv[]

        x264_macroblock_cache_mv( h, 2*x8, 2*y8, 2, 2, 0, m->mv[0], m->mv[1] );//将最佳矢量写入h->mb.cache.mv[i_list]中当前分割所有4*4块对应的位置

        *(uint64_t*)mvc[i_mvc] = *(uint64_t*)m->mv;//将前一分割的最佳运动矢量写入下一分割的可能预测矢量指针
        i_mvc++;

        /* mb type cost */
        m->cost += i_ref_cost;
        m->cost += a->i_lambda * i_sub_mb_p_cost_table[D_L0_8x8];
    }

    /* theoretically this should include 4*ref_cost,
     * but 3 seems a better approximation of cabac. */
    a->l0.i_cost8x8 = a->l0.me8x8[0].cost + a->l0.me8x8[1].cost +
                      a->l0.me8x8[2].cost + a->l0.me8x8[3].cost -
                      REF_COST( 0, a->l0.me16x16.i_ref );
    if( a->b_mbrd )
    {
        if( a->i_best_satd > a->l0.i_cost8x8 )
            a->i_best_satd = a->l0.i_cost8x8;
        h->mb.i_type = P_8x8;
        h->mb.i_sub_partition[0] = h->mb.i_sub_partition[1] =
        h->mb.i_sub_partition[2] = h->mb.i_sub_partition[3] = D_L0_8x8;
//        a->l0.i_cost8x8 = x264_rd_cost_mb( h, a->i_lambda2 );
    }
}

static void x264_mb_analyse_inter_p16x8( x264_t *h, x264_mb_analysis_t *a )
{
    x264_me_t m;
    uint8_t  **p_fenc = h->mb.pic.p_fenc;
    int mvc[3][2];
    int i, j;

    /* XXX Needed for x264_mb_predict_mv */
    h->mb.i_partition = D_16x8;

    for( i = 0; i < 2; i++ )
    {
        x264_me_t *l0m = &a->l0.me16x8[i];
        int ref8[2];
        int i_ref8s;
        ref8[0]=a->l0.me8x8[2*i].i_ref;
        ref8[1]=a->l0.me8x8[2*i+1].i_ref;
        i_ref8s = ( ref8[0] == ref8[1] ) ? 1 : 2;

        m.i_pixel = PIXEL_16x8;
        m.p_cost_mv = a->p_cost_mv;

        LOAD_FENC( &m, p_fenc, 0, 8*i );
        l0m->cost = INT_MAX;
        for( j = 0; j < i_ref8s; j++ )
        {
             const int i_ref = ref8[j];
             const int i_ref_cost = REF_COST( 0, i_ref );
             m.i_ref_cost = i_ref_cost;
             m.i_ref = i_ref;

             /* if we skipped the 16x16 predictor, we wouldn't have to copy anything... */
             *(uint64_t*)mvc[0] = *(uint64_t*)a->l0.mvc[i_ref][0];
             *(uint64_t*)mvc[1] = *(uint64_t*)a->l0.mvc[i_ref][2*i+1];
             *(uint64_t*)mvc[2] = *(uint64_t*)a->l0.mvc[i_ref][2*i+2];

             LOAD_HPELS( &m, h->mb.pic.p_fref[0][i_ref], 0, i_ref, 0, 8*i );
             x264_macroblock_cache_ref( h, 0, 2*i, 4, 2, 0, i_ref );
             x264_mb_predict_mv( h, 0, 8*i, 4, m.mvp );
             x264_me_search( h, &m, mvc, 3 );

             m.cost += i_ref_cost;

             if( m.cost < l0m->cost )
                 *l0m = m;
        }
        x264_macroblock_cache_mv( h, 0, 2*i, 4, 2, 0, l0m->mv[0], l0m->mv[1] );
        x264_macroblock_cache_ref( h, 0, 2*i, 4, 2, 0, l0m->i_ref );
    }

    a->l0.i_cost16x8 = a->l0.me16x8[0].cost + a->l0.me16x8[1].cost;
    if( a->b_mbrd )
    {
        if( a->i_best_satd > a->l0.i_cost16x8 )
            a->i_best_satd = a->l0.i_cost16x8;
        h->mb.i_type = P_L0;
//        a->l0.i_cost16x8 = x264_rd_cost_mb( h, a->i_lambda2 );
    }
}

static void x264_mb_analyse_inter_p8x16( x264_t *h, x264_mb_analysis_t *a )
{
    x264_me_t m;
    uint8_t  **p_fenc = h->mb.pic.p_fenc;
    int mvc[3][2];
    int i, j;

    /* XXX Needed for x264_mb_predict_mv */
    h->mb.i_partition = D_8x16;

    for( i = 0; i < 2; i++ )
    {
        x264_me_t *l0m = &a->l0.me8x16[i];
        int ref8[2];
        int i_ref8s;
        ref8[0]=a->l0.me8x8[i].i_ref;
        ref8[1]=a->l0.me8x8[i+2].i_ref;
        i_ref8s = ( ref8[0] == ref8[1] ) ? 1 : 2;        

        m.i_pixel = PIXEL_8x16;
        m.p_cost_mv = a->p_cost_mv;

        LOAD_FENC( &m, p_fenc, 8*i, 0 );
        l0m->cost = INT_MAX;
        for( j = 0; j < i_ref8s; j++ )
        {
             const int i_ref = ref8[j];
             const int i_ref_cost = REF_COST( 0, i_ref );
             m.i_ref_cost = i_ref_cost;
             m.i_ref = i_ref;

             *(uint64_t*)mvc[0] = *(uint64_t*)a->l0.mvc[i_ref][0];
             *(uint64_t*)mvc[1] = *(uint64_t*)a->l0.mvc[i_ref][i+1];
             *(uint64_t*)mvc[2] = *(uint64_t*)a->l0.mvc[i_ref][i+3];

             LOAD_HPELS( &m, h->mb.pic.p_fref[0][i_ref], 0, i_ref, 8*i, 0 );
             x264_macroblock_cache_ref( h, 2*i, 0, 2, 4, 0, i_ref );
             x264_mb_predict_mv( h, 0, 4*i, 2, m.mvp );
             x264_me_search( h, &m, mvc, 3 );

             m.cost += i_ref_cost;

             if( m.cost < l0m->cost )
                 *l0m = m;
        }
        x264_macroblock_cache_mv( h, 2*i, 0, 2, 4, 0, l0m->mv[0], l0m->mv[1] );
        x264_macroblock_cache_ref( h, 2*i, 0, 2, 4, 0, l0m->i_ref );
    }

    a->l0.i_cost8x16 = a->l0.me8x16[0].cost + a->l0.me8x16[1].cost;
    if( a->b_mbrd )
    {
        if( a->i_best_satd > a->l0.i_cost8x16 )
            a->i_best_satd = a->l0.i_cost8x16;
        h->mb.i_type = P_L0;
//        a->l0.i_cost8x16 = x264_rd_cost_mb( h, a->i_lambda2 );
    }
}

static int x264_mb_analyse_inter_p4x4_chroma( x264_t *h, x264_mb_analysis_t *a, uint8_t **p_fref, int i8x8, int pixel )
{
    DECLARE_ALIGNED( uint8_t, pix1[8*8], 8 );
    DECLARE_ALIGNED( uint8_t, pix2[8*8], 8 );
    const int i_stride = h->mb.pic.i_stride[1];
    const int or = 4*(i8x8&1) + 2*(i8x8&2)*i_stride;
    const int oe = 4*(i8x8&1) + 2*(i8x8&2)*FENC_STRIDE;

#define CHROMA4x4MC( width, height, me, x, y ) \
    h->mc.mc_chroma( &p_fref[4][or+x+y*i_stride], i_stride, &pix1[x+y*8], 8, (me).mv[0], (me).mv[1], width, height ); \
    h->mc.mc_chroma( &p_fref[5][or+x+y*i_stride], i_stride, &pix2[x+y*8], 8, (me).mv[0], (me).mv[1], width, height );

    if( pixel == PIXEL_4x4 )
    {
        CHROMA4x4MC( 2,2, a->l0.me4x4[i8x8][0], 0,0 );
        CHROMA4x4MC( 2,2, a->l0.me4x4[i8x8][1], 0,2 );
        CHROMA4x4MC( 2,2, a->l0.me4x4[i8x8][2], 2,0 );
        CHROMA4x4MC( 2,2, a->l0.me4x4[i8x8][3], 2,2 );
    }
    else if( pixel == PIXEL_8x4 )
    {
        CHROMA4x4MC( 4,2, a->l0.me8x4[i8x8][0], 0,0 );
        CHROMA4x4MC( 4,2, a->l0.me8x4[i8x8][1], 0,2 );
    }
    else
    {
        CHROMA4x4MC( 2,4, a->l0.me4x8[i8x8][0], 0,0 );
        CHROMA4x4MC( 2,4, a->l0.me4x8[i8x8][1], 2,0 );
    }

    return h->pixf.mbcmp[PIXEL_4x4]( &h->mb.pic.p_fenc[1][oe], FENC_STRIDE, pix1, 8 )
         + h->pixf.mbcmp[PIXEL_4x4]( &h->mb.pic.p_fenc[2][oe], FENC_STRIDE, pix2, 8 );
}

static void x264_mb_analyse_inter_p4x4( x264_t *h, x264_mb_analysis_t *a, int i8x8 )
{
    uint8_t  **p_fref = h->mb.pic.p_fref[0][a->l0.me8x8[i8x8].i_ref];
    uint8_t  **p_fenc = h->mb.pic.p_fenc;
    const int i_ref = a->l0.me8x8[i8x8].i_ref;
    int i4x4;

    /* XXX Needed for x264_mb_predict_mv */
    h->mb.i_partition = D_8x8;

    for( i4x4 = 0; i4x4 < 4; i4x4++ )//每个8*8有4个4*4,搜索得到每个4*4的最佳运动矢量,写入h->mb.cache.mv[相应位置][]
    {
        const int idx = 4*i8x8 + i4x4;//当前4*4在宏块内的序号
        const int x4 = block_idx_x[idx];//4*4块在宏块内的行列坐标
        const int y4 = block_idx_y[idx];
        const int i_mvc = (i4x4 == 0);//是8*8首个4*4块时

        x264_me_t *m = &a->l0.me4x4[i8x8][i4x4];

        m->i_pixel = PIXEL_4x4;
        m->p_cost_mv = a->p_cost_mv;

        LOAD_FENC( m, p_fenc, 4*x4, 4*y4 );
        LOAD_HPELS( m, p_fref, 0, i_ref, 4*x4, 4*y4 );

        x264_mb_predict_mv( h, 0, idx, 1, m->mvp );
        x264_me_search( h, m, &a->l0.me8x8[i8x8].mv, i_mvc );

        x264_macroblock_cache_mv( h, x4, y4, 1, 1, 0, m->mv[0], m->mv[1] );
    }
    a->l0.i_cost4x4[i8x8] = a->l0.me4x4[i8x8][0].cost +
                            a->l0.me4x4[i8x8][1].cost +
                            a->l0.me4x4[i8x8][2].cost +
                            a->l0.me4x4[i8x8][3].cost +
                            REF_COST( 0, i_ref ) +
                            a->i_lambda * i_sub_mb_p_cost_table[D_L0_4x4];
    if( h->mb.b_chroma_me )
        a->l0.i_cost4x4[i8x8] += x264_mb_analyse_inter_p4x4_chroma( h, a, p_fref, i8x8, PIXEL_4x4 );
}

static void x264_mb_analyse_inter_p8x4( x264_t *h, x264_mb_analysis_t *a, int i8x8 )
{
    uint8_t  **p_fref = h->mb.pic.p_fref[0][a->l0.me8x8[i8x8].i_ref];
    uint8_t  **p_fenc = h->mb.pic.p_fenc;
    const int i_ref = a->l0.me8x8[i8x8].i_ref;
    int i8x4;

    /* XXX Needed for x264_mb_predict_mv */
    h->mb.i_partition = D_8x8;