[置顶] x264中16x16帧内预测模式函数分析

/****************************************************************************
 * 16x16 prediction for intra luma block
 ****************************************************************************/
//! p指向32位无符号整型变量，即src(像素起始位置)，指针加1后移32位，即4个字节，实现每个赋值语句
//! 同时给4个像素赋值，每个循环供给16个像素赋值
#define PREDICT_16x16_DC(v) \
	for( i = 0; i < 16; i++ )\
	{\
	uint32_t *p = (uint32_t*)src;\
	*p++ = v;\
	*p++ = v;\
	*p++ = v;\
	*p++ = v;\
	src += FDEC_STRIDE;\
	}

static void predict_16x16_dc( uint8_t *src ) //!< 模式2（V和H存在的情况）
{
    uint32_t dc = 0; //!< 32位无符号整型
    int i;

    for( i = 0; i < 16; i++ )
    {
        dc += src[-1 + i * FDEC_STRIDE]; //!< 当前宏块第i行的左邻点像素值 V
        dc += src[i - FDEC_STRIDE]; //!< 当前宏块第1行的第i个上邻点像素值 H
    } //!< V + H 
    dc = (( dc + 16 ) >> 5) * 0x01010101; //!< 将平均值同时赋给4个字节（像素）

    PREDICT_16x16_DC(dc);
}
static void predict_16x16_dc_left( uint8_t *src ) //!< 模式2（只有V存在的情况）
{
    uint32_t dc = 0;
    int i;

    for( i = 0; i < 16; i++ )
    {
        dc += src[-1 + i * FDEC_STRIDE]; //!< 当前宏块第i行的左邻点像素值 V
    }
    dc = (( dc + 8 ) >> 4) * 0x01010101;

    PREDICT_16x16_DC(dc);
}
static void predict_16x16_dc_top( uint8_t *src ) //!< 模式2（只有H存在的情况）
{
    uint32_t dc = 0;
    int i;

    for( i = 0; i < 16; i++ )
    {
        dc += src[i - FDEC_STRIDE]; //!< 当前宏块第1行的第i个上邻点像素值 H
    }
    dc = (( dc + 8 ) >> 4) * 0x01010101;

    PREDICT_16x16_DC(dc);
}
static void predict_16x16_dc_128( uint8_t *src ) //!< 模式2（V和H均不存在的情况）
{
    int i;
    PREDICT_16x16_DC(0x80808080); //!< 0x80 = 1000 0000 = 128
}
static void predict_16x16_h( uint8_t *src ) //!< 模式1 
{
    int i;

    for( i = 0; i < 16; i++ )
    {
        const uint32_t v = 0x01010101 * src[-1]; //!< 复制每一行当前宏块左邻点像素值
        uint32_t *p = (uint32_t*)src; //!< 32位指针使得每个赋值语句可以同时给4个像素点赋值

        *p++ = v;
        *p++ = v;
        *p++ = v;
        *p++ = v;

        src += FDEC_STRIDE; //!< 指针指向下一行

    }
}
static void predict_16x16_v( uint8_t *src ) //!< 模式0
{
    uint32_t v0 = *(uint32_t*)&src[ 0-FDEC_STRIDE]; //!< 0~3列
    uint32_t v1 = *(uint32_t*)&src[ 4-FDEC_STRIDE]; //!< 4~7列
    uint32_t v2 = *(uint32_t*)&src[ 8-FDEC_STRIDE]; //!< 8~11列
    uint32_t v3 = *(uint32_t*)&src[12-FDEC_STRIDE]; //!< 12~15列
    int i;

    for( i = 0; i < 16; i++ )
    {
        uint32_t *p = (uint32_t*)src; //!< 每次给一行的像素赋值
        *p++ = v0;
        *p++ = v1;
        *p++ = v2;
        *p++ = v3;
        src += FDEC_STRIDE; //!< 指针指向下一行
    }
}
static void predict_16x16_p( uint8_t *src ) //!< 模式3
{
    int x, y, i;
    int a, b, c;
    int H = 0;
    int V = 0;
    int i00;

    /* calculate H and V */
    for( i = 0; i <= 7; i++ )
    {
        H += ( i + 1 ) * ( src[ 8 + i - FDEC_STRIDE ] - src[6 -i -FDEC_STRIDE] );
        V += ( i + 1 ) * ( src[-1 + (8+i)*FDEC_STRIDE] - src[-1 + (6-i)*FDEC_STRIDE] );
    }

    a = 16 * ( src[-1 + 15*FDEC_STRIDE] + src[15 - FDEC_STRIDE] ); //!< V和H的最后一个像素点
    b = ( 5 * H + 32 ) >> 6;
    c = ( 5 * V + 32 ) >> 6;

    i00 = a - b * 7 - c * 7 + 16;

    for( y = 0; y < 16; y++ )
    {
        int pix = i00;
        for( x = 0; x < 16; x++ )
        {
            src[x] = x264_clip_uint8( pix>>5 ); //!< 将结果限制在0~255之间
            pix += b; //!< b * x
        }
        src += FDEC_STRIDE;
        i00 += c; //!< c * y
    }
}