predict-c.c

法国人的264代码 大家看看啊,里面有很多可以借鉴的东西啊

    const int t1t2 = t1 + t2 + 1;
    const int t2t3 = t2 + t3 + 1;
    const int l0lt = l0 + lt + 1;
    const int l1l0 = l1 + l0 + 1;
    const int l2l1 = l2 + l1 + 1;
    src[0*FDEC_STRIDE+0]=
    src[2*FDEC_STRIDE+1]= ltt0 >> 1;
    src[0*FDEC_STRIDE+1]=
    src[2*FDEC_STRIDE+2]= t0t1 >> 1;
    src[0*FDEC_STRIDE+2]=
    src[2*FDEC_STRIDE+3]= t1t2 >> 1;
    src[0*FDEC_STRIDE+3]= t2t3 >> 1;
    src[1*FDEC_STRIDE+0]=
    src[3*FDEC_STRIDE+1]= (l0lt + ltt0) >> 2;
    src[1*FDEC_STRIDE+1]=
    src[3*FDEC_STRIDE+2]= (ltt0 + t0t1) >> 2;
    src[1*FDEC_STRIDE+2]=
    src[3*FDEC_STRIDE+3]= (t0t1 + t1t2) >> 2;
    src[1*FDEC_STRIDE+3]= (t1t2 + t2t3) >> 2;
    src[2*FDEC_STRIDE+0]= (l1l0 + l0lt) >> 2;
    src[3*FDEC_STRIDE+0]= (l2l1 + l1l0) >> 2;
}
static void predict_4x4_hd( uint8_t *src )
{
    const int lt= src[-1-1*FDEC_STRIDE];
    PREDICT_4x4_LOAD_LEFT
    PREDICT_4x4_LOAD_TOP
    const int ltt0 = lt + t0 + 1;
    const int t0t1 = t0 + t1 + 1;
    const int t1t2 = t1 + t2 + 1;
    const int l0lt = l0 + lt + 1;
    const int l1l0 = l1 + l0 + 1;
    const int l2l1 = l2 + l1 + 1;
    const int l3l2 = l3 + l2 + 1;
    src[0*FDEC_STRIDE+0]=
    src[1*FDEC_STRIDE+2]= l0lt >> 1;
    src[0*FDEC_STRIDE+1]=
    src[1*FDEC_STRIDE+3]= (l0lt + ltt0) >> 2;
    src[0*FDEC_STRIDE+2]= (ltt0 + t0t1) >> 2;
    src[0*FDEC_STRIDE+3]= (t0t1 + t1t2) >> 2;
    src[1*FDEC_STRIDE+0]=
    src[2*FDEC_STRIDE+2]= l1l0 >> 1;
    src[1*FDEC_STRIDE+1]=
    src[2*FDEC_STRIDE+3]= (l0lt + l1l0) >> 2;
    src[2*FDEC_STRIDE+0]=
    src[3*FDEC_STRIDE+2]= l2l1 >> 1;
    src[2*FDEC_STRIDE+1]=
    src[3*FDEC_STRIDE+3]= (l1l0 + l2l1) >> 2;
    src[3*FDEC_STRIDE+0]= l3l2 >> 1;
    src[3*FDEC_STRIDE+1]= (l2l1 + l3l2) >> 2;
}
#if 0
static void predict_4x4_vl( uint8_t *src )
{
    PREDICT_4x4_LOAD_TOP
    PREDICT_4x4_LOAD_TOP_RIGHT
    const int t0t1 = t0 + t1 + 1;
    const int t1t2 = t1 + t2 + 1;
    const int t2t3 = t2 + t3 + 1;
    const int t3t4 = t3 + t4 + 1;
    const int t4t5 = t4 + t5 + 1;
    const int t5t6 = t5 + t6 + 1;
    src[0*FDEC_STRIDE+0]= t0t1 >> 1;
    src[0*FDEC_STRIDE+1]=
    src[2*FDEC_STRIDE+0]= t1t2 >> 1;
    src[0*FDEC_STRIDE+2]=
    src[2*FDEC_STRIDE+1]= t2t3 >> 1;
    src[0*FDEC_STRIDE+3]=
    src[2*FDEC_STRIDE+2]= t3t4 >> 1;
    src[2*FDEC_STRIDE+3]= t4t5 >> 1;
    src[1*FDEC_STRIDE+0]= (t0t1 + t1t2) >> 2;
    src[1*FDEC_STRIDE+1]=
    src[3*FDEC_STRIDE+0]= (t1t2 + t2t3) >> 2;
    src[1*FDEC_STRIDE+2]=
    src[3*FDEC_STRIDE+1]= (t2t3 + t3t4) >> 2;
    src[1*FDEC_STRIDE+3]=
    src[3*FDEC_STRIDE+2]= (t3t4 + t4t5) >> 2;
    src[3*FDEC_STRIDE+3]= (t4t5 + t5t6) >> 2;
}
#endif
static void predict_4x4_hu( uint8_t *src )
{
    PREDICT_4x4_LOAD_LEFT
    const int l1l0 = l1 + l0 + 1;
    const int l2l1 = l2 + l1 + 1;
    const int l3l2 = l3 + l2 + 1;
    src[0*FDEC_STRIDE+0]= l1l0 >> 1;
    src[0*FDEC_STRIDE+1]= (l1l0 + l2l1) >> 2;
    src[0*FDEC_STRIDE+2]=
    src[1*FDEC_STRIDE+0]= l2l1 >> 1;
    src[0*FDEC_STRIDE+3]=
    src[1*FDEC_STRIDE+1]= (l2l1 + l3l2) >> 2;
    src[1*FDEC_STRIDE+2]=
    src[2*FDEC_STRIDE+0]= l3l2 >> 1;
    src[1*FDEC_STRIDE+3]=
    src[2*FDEC_STRIDE+1]= (l2 + 3*l3 + 2) >> 2;
    src[2*FDEC_STRIDE+3]=
    src[3*FDEC_STRIDE+1]=
    src[3*FDEC_STRIDE+0]=
    src[2*FDEC_STRIDE+2]=
    src[3*FDEC_STRIDE+2]=
    src[3*FDEC_STRIDE+3]= l3;
}
#endif
/****************************************************************************
 * 8x8 prediction for intra luma block
 ****************************************************************************/
#define PL(y) \
    UNUSED int l##y = edge[14-y];
#define PT(x) \
    UNUSED int t##x = edge[16+x];
#define PREDICT_8x8_LOAD_TOPLEFT \
    int lt = edge[15];
#define PREDICT_8x8_LOAD_LEFT \
    PL(0) PL(1) PL(2) PL(3) PL(4) PL(5) PL(6) PL(7)
#define PREDICT_8x8_LOAD_TOP \
    PT(0) PT(1) PT(2) PT(3) PT(4) PT(5) PT(6) PT(7)
#define PREDICT_8x8_DC(v) \
    int y; \
    for( y = 0; y < 8; y++ ) { \
        ((uint32_t*)src)[0] = \
        ((uint32_t*)src)[1] = v; \
        src += FDEC_STRIDE; \
    }
#define SRC(x,y) src[(x)+(y)*FDEC_STRIDE]
static void predict_8x8_vr_mmxext( uint8_t *src, uint8_t edge[33] )
{
    predict_8x8_vr_core_mmxext( src, edge );
    {
        PREDICT_8x8_LOAD_TOPLEFT
        PREDICT_8x8_LOAD_LEFT
        SRC(0,2)=SRC(1,4)=SRC(2,6)= (l1 + 2*l0 + lt + 2) >> 2;
        SRC(0,3)=SRC(1,5)=SRC(2,7)= (l2 + 2*l1 + l0 + 2) >> 2;
        SRC(0,4)=SRC(1,6)= (l3 + 2*l2 + l1 + 2) >> 2;
        SRC(0,5)=SRC(1,7)= (l4 + 2*l3 + l2 + 2) >> 2;
        SRC(0,6)= (l5 + 2*l4 + l3 + 2) >> 2;
        SRC(0,7)= (l6 + 2*l5 + l4 + 2) >> 2;
    }
}
#define SUMSUB(a,b,c,d,e,f,g,h)\
    t=a; a+=b; b-=t;\
    t=c; c+=d; d-=t;\
    t=e; e+=f; f-=t;\
    t=g; g+=h; h-=t;
#ifdef ARCH_X86_64
void x264_intra_sa8d_x3_8x8_sse2( uint8_t *fenc, uint8_t edge[33], int res[3] )
#else
void x264_intra_sa8d_x3_8x8_mmxext( uint8_t *fenc, uint8_t edge[33], int res[3] )
#endif
{
    PREDICT_8x8_LOAD_TOP
    PREDICT_8x8_LOAD_LEFT
    int t;
    DECLARE_ALIGNED( int16_t, sa8d_1d[2][8], 16 );
    SUMSUB(l0,l4,l1,l5,l2,l6,l3,l7);
    SUMSUB(l0,l2,l1,l3,l4,l6,l5,l7);
    SUMSUB(l0,l1,l2,l3,l4,l5,l6,l7);
    sa8d_1d[0][0] = l0;
    sa8d_1d[0][1] = l1;
    sa8d_1d[0][2] = l2;
    sa8d_1d[0][3] = l3;
    sa8d_1d[0][4] = l4;
    sa8d_1d[0][5] = l5;
    sa8d_1d[0][6] = l6;
    sa8d_1d[0][7] = l7;
    SUMSUB(t0,t4,t1,t5,t2,t6,t3,t7);
    SUMSUB(t0,t2,t1,t3,t4,t6,t5,t7);
    SUMSUB(t0,t1,t2,t3,t4,t5,t6,t7);
    sa8d_1d[1][0] = t0;
    sa8d_1d[1][1] = t1;
    sa8d_1d[1][2] = t2;
    sa8d_1d[1][3] = t3;
    sa8d_1d[1][4] = t4;
    sa8d_1d[1][5] = t5;
    sa8d_1d[1][6] = t6;
    sa8d_1d[1][7] = t7;
//#ifdef ARCH_X86_64
//    x264_intra_sa8d_x3_8x8_core_sse2( fenc, sa8d_1d, res );
//#else
//    x264_intra_sa8d_x3_8x8_core_mmxext( fenc, sa8d_1d, res );
//#endif
}
/****************************************************************************
 * Exported functions:
 ****************************************************************************/
void x264_predict_16x16_init_mmxext( x264_predict_t pf[7] )
{
    pf[I_PRED_16x16_V]       = predict_16x16_v_mmx;
    pf[I_PRED_16x16_DC]      = predict_16x16_dc;
    pf[I_PRED_16x16_DC_TOP]  = predict_16x16_dc_top_mmxext;
    pf[I_PRED_16x16_P]       = predict_16x16_p;
#ifdef ARCH_X86_64
    pf[I_PRED_16x16_H]       = predict_16x16_h;
    pf[I_PRED_16x16_DC_LEFT] = predict_16x16_dc_left;
#endif
}
void x264_predict_8x8c_init_mmxext( x264_predict_t pf[7] )
{
    pf[I_PRED_CHROMA_V]       = predict_8x8c_v_mmx;
    pf[I_PRED_CHROMA_P]       = predict_8x8c_p;
    pf[I_PRED_CHROMA_DC]      = predict_8x8c_dc;
#ifdef ARCH_X86_64
    pf[I_PRED_CHROMA_H]       = predict_8x8c_h;
    pf[I_PRED_CHROMA_DC_LEFT] = predict_8x8c_dc_left;
    pf[I_PRED_CHROMA_DC_TOP]  = predict_8x8c_dc_top;
#endif
}
void x264_predict_8x8_init_mmxext( x264_predict8x8_t pf[12] )
{
    pf[I_PRED_8x8_V]   = predict_8x8_v_mmxext;
    pf[I_PRED_8x8_DC]  = predict_8x8_dc_mmxext;
    pf[I_PRED_8x8_DC_TOP] = predict_8x8_dc_top_mmxext;
    pf[I_PRED_8x8_DC_LEFT]= predict_8x8_dc_left_mmxext;
    pf[I_PRED_8x8_DDL] = predict_8x8_ddl_mmxext;
    pf[I_PRED_8x8_VR]  = predict_8x8_vr_mmxext;
#ifdef ARCH_X86
    pf[I_PRED_8x8_DDR] = predict_8x8_ddr_mmxext;
#endif
}
void x264_predict_8x8_init_sse2( x264_predict8x8_t pf[12] )
{
#ifdef ARCH_X86_64 // x86 not written yet
    pf[I_PRED_8x8_DDL] = predict_8x8_ddl_sse2;
    pf[I_PRED_8x8_DDR] = predict_8x8_ddr_sse2;
    pf[I_PRED_8x8_VL]  = predict_8x8_vl_sse2;
#endif
}
void x264_predict_4x4_init_mmxext( x264_predict_t pf[12] )
{
#ifdef ARCH_X86_64 // x86 not written yet
    pf[I_PRED_4x4_DDL] = predict_4x4_ddl_mmxext;
    pf[I_PRED_4x4_VL]  = predict_4x4_vl_mmxext;
#endif
#ifdef ARCH_X86_64 // slower on x86
    pf[I_PRED_4x4_DDR] = predict_4x4_ddr;
    pf[I_PRED_4x4_VR]  = predict_4x4_vr;
    pf[I_PRED_4x4_HD]  = predict_4x4_hd;
    pf[I_PRED_4x4_HU]  = predict_4x4_hu;
#endif
}