x264帧内预测

理论

    
1、宏块大小是 16x16,每个宏块包含一个 16x16 大小的亮度块和两个 8x8 的色度块
2、亮度分量
    对于亮度分量而言,帧内预测只针对 16x16 的块或者 4x4 的小块,换句话说,对于亮度分量而言,进行帧内预测的时候,它只能被划分为 16x16(即不进行划分)的块,或者 4x4 的小块。
    2.1、16x16 亮度块
        有4种帧内预测模式:DC、H(水平模式)、V(垂直模式)、plane(平面模式)。对于的序号分别是:0、1、2、3.
    2.2、4x4 亮度块
        有 9 种帧内预测模式:模式 0(垂直),模式 1(水平),模式 2(DC),模式3(45°),模式 4(135°),模式 5(116.6°),模式 6(153.4°),模式 7(63.4°),模式 8(26.6°)
    2.3、额外补充
        按照理论上,亮度分量只支持 16x16 和 4x4 的块,但是后来增加了 8x8 的DCT,它要求提供 8x8 的帧内预测,因此,x264 提供了 8x8 块的帧内预测。它的模式和 4x4 小块的模式是一样的。
3、色度分量对于色度分量,帧内预测只支持 8x8 的色度分量,也就是说宏块对应的色度分量不用划分,直接进行预测。它使用的预测方式和 16x16 的亮度块一样。
4、处理过程
    先计算宏块下每个 4x4 小块的最优模式,把所有 4x4 小块的最优代价相加(假设为 sum),然后计算 16x16 的块的最优模式,与 sum 进行比较,决定使用哪一个作为最优模式。

代码

1、入口函数 x264_mb_analyse_intra
2、处理步骤
    2.1、进行 16x16 亮度块的帧内预测
        （1）调用函数 predict_16x16_mode_available,选出 16x16 亮度块可用的帧内模式(要根据邻居块是否存在来判别哪些模式可用)
        （2） 遍 历 所 有 可 用 的 16x16 亮 度 块 的 模 式 , 调 用 函 数 指 针predict_16x16[...]进行预测,然后计算 sad,最后选出 16x16 块的最优模式
    2.2、进行 8x8 色度块的帧内预测
        （1） 如 果 使 用 了 rdo 模 式 ( 可 以 由 用 户 设 置 ), 那 么 调 用x264_mb_analyse_intra_chroma 函数,进行下面处理：调用 predict_8x8chroma_mode_available 函数,选取 8x8 色度块可用的帧内预测模式2)遍历所有的 8x8 色度块的预测模式,进行做鱼操作,计算 sad,选出最优的模式
        （2）如果没有使用 rdo 模式,那么计算一些额外的 sad(相当于是 8x8色度块的 sad),它们的模式应该和对应的 16x16 亮度块的模式一样,不用另外计算。
    2.3、进行 4x4 亮度块的帧内预测,遍历宏块下所有的 4x4 小块,对于每一个小块,进行下面操作
        （1）调用 x264_mb_predict_intra4x4_mode 函数,得到一个从邻居块预测来的模式 pred_mode,用于后面 sad 的计算。
        （2）调用 predict_4x4_mode_available 函数,选取可用的 4x4 亮度块的预测模式。
        （3）遍历所有可用的预测模式,进行预测操作,选取最优的模式
        （4）对于最优的模式,调用 x264_mb_encode_i4x4,计算比特率
        （5）把所有的 4x4 小块最优模式的代价相加,就得到了宏块下 4x4 划分的最优模式的代价
    2.4、如果有必要(使用 8x8 的 DCT 时),那么进行 8x8 亮度块的帧内预测
        （1）宏块由 4 个 8x8 块构成,因此要依次处理这 4 个块。
        （2）对于每一个 8x8 可用的模式(由于 8x8 亮度预测模式和 4x4 的一样,因此实际调用 predict_4x4_mode_available 函数来得到可用的预测模式),遍历这些可用模式,进行 8x8 的预测操作,选出最优的模式,然后调用x264_mb_encode_i8x8 计算该最优模式的比特率。
        （3）累加宏块下 8x8 小块的最优代价,即为 8x8 帧内预测模式的最优代价
3、具体代码实现,抽取了几个典型的函数作为例子:

/* 帧内预测主函数 */
static void x264_mb_analyse_intra( x264_t *h, x264_mb_analysis_t *a, int i_cost_inter )
{
    const unsigned int flags = h->sh.i_type == SLICE_TYPE_I ? h->param.analyse.intra :
                                                              h->param.analyse.inter;
    const int i_stride = h->mb.pic.i_stride[0];
    uint8_t *p_src = h->mb.pic.p_fenc[0];
    uint8_t *p_dst = h->mb.pic.p_fdec[0];
    int
            f8_satd_rd_ratio = 0;
    int i, idx;
    int i_max;
    int predict_mode[9];
    const int i_satd_thresh = a->i_best_satd * 5/4 + a->i_lambda * 10;
    /*---------------- Try all mode and calculate their score ---------------*/
    /* 16x16 prediction selection */
    /* 16x16亮度 预测 */
    predict_16x16_mode_available( h->mb.i_neighbour, predict_mode, &i_max );
    for( i = 0; i < i_max; i++ )
    {
        int i_sad;
        int i_mode;
        i_mode = predict_mode[i];
        h->predict_16x16[i_mode]( p_dst, i_stride );
        i_sad = h->pixf.mbcmp[PIXEL_16x16]( p_dst, i_stride, p_src, i_stride ) +
                a->i_lambda * bs_size_ue( x264_mb_pred_mode16x16_fix[i_mode] );
        if( a->i_sad_i16x16 > i_sad )
        {
            a->i_predict16x16 = i_mode;
            a->i_sad_i16x16
        }
    }
    = i_sad;/* 8x8色度预测 */
    if( a->b_mbrd )
    {
        f8_satd_rd_ratio = ((unsigned)i_cost_inter << 8) / a->i_best_satd + 1;
        x264_mb_analyse_intra_chroma( h, a );
        if( h->mb.b_chroma_me )
            a->i_sad_i16x16 += a->i_sad_i8x8chroma;
        if( a->i_sad_i16x16 < i_satd_thresh )
        {
            h->mb.i_type = I_16x16;
            h->mb.i_intra16x16_pred_mode = a->i_predict16x16;
            a->i_sad_i16x16 = x264_rd_cost_mb( h, a->i_lambda2 );
        }
        else
            a->i_sad_i16x16 = a->i_sad_i16x16 * f8_satd_rd_ratio >> 8;
    }
    else
    {
        if( h->sh.i_type == SLICE_TYPE_B )
            /* cavlc mb type prefix */
            a->i_sad_i16x16 += a->i_lambda * i_mb_b_cost_table[I_16x16];
        if( a->b_fast_intra && a->i_sad_i16x16 > 2*i_cost_inter )
            return;
    }
    /* 4x4 prediction selection */
    /* 4x4亮度预测 */
    if( flags & X264_ANALYSE_I4x4 )
    {
        a->i_sad_i4x4 = 0;
        for( idx = 0; idx < 16; idx++ )
        {
            uint8_t *p_src_by;
            uint8_t *p_dst_by;
            int
                    i_best;
            int x, y;
            int i_pred_mode;
            i_pred_mode= x264_mb_predict_intra4x4_mode( h, idx );
            x = block_idx_x[idx];
            y = block_idx_y[idx];
            p_src_by = p_src + 4 * x + 4 * y * i_stride;
            p_dst_by = p_dst + 4 * x + 4 * y * i_stride;i_best = COST_MAX;
            predict_4x4_mode_available( h->mb.i_neighbour4[idx], predict_mode,
                                        &i_max );
            for( i = 0; i < i_max; i++ )
            {
                int i_sad;
                int i_mode;
                i_mode = predict_mode[i];
                h->predict_4x4[i_mode]( p_dst_by, i_stride );
                i_sad = h->pixf.mbcmp[PIXEL_4x4]( p_dst_by, i_stride,
                        p_src_by, i_stride )
                        + a->i_lambda * (i_pred_mode ==
                                         x264_mb_pred_mode4x4_fix(i_mode) ? 1 : 4);
                if( i_best > i_sad )
                {
                    a->i_predict4x4[x][y] = i_mode;
                    i_best = i_sad;
                }
            }
            a->i_sad_i4x4 += i_best;
            /* we need to encode this block now (for next ones) */
            h->predict_4x4[a->i_predict4x4[x][y]]( p_dst_by, i_stride );
            /* 计算该最优模式下的比特率 */
            x264_mb_encode_i4x4( h, idx, a->i_qp );
            h->mb.cache.intra4x4_pred_mode[x264_scan8[idx]] = a->i_predict4x4[x][y];
        }
        a->i_sad_i4x4 += a->i_lambda * 24;
        /* from JVT (SATD0) */
        if( a->b_mbrd )
        {
            if( h->mb.b_chroma_me )
                a->i_sad_i4x4 += a->i_sad_i8x8chroma;
            if( a->i_sad_i4x4 < i_satd_thresh )
            {
                h->mb.i_type = I_4x4;
                a->i_sad_i4x4 = x264_rd_cost_mb( h, a->i_lambda2 );
            }
            elsea->i_sad_i4x4 = a->i_sad_i4x4 * f8_satd_rd_ratio >> 8;
        }
        else
        {
            if( h->sh.i_type == SLICE_TYPE_B )
                a->i_sad_i4x4 += a->i_lambda * i_mb_b_cost_table[I_4x4];
        }
    }
    /* 8x8 prediction selection */
    /* 如果有必要,那么进行8x8的亮度预测 */
    if( flags & X264_ANALYSE_I8x8 )
    {
        a->i_sad_i8x8 = 0;
        for( idx = 0; idx < 4; idx++ )
        {
            uint8_t *p_src_by;
            uint8_t *p_dst_by;
            int
                    i_best;
            int x, y;
            int i_pred_mode;
            i_pred_mode= x264_mb_predict_intra4x4_mode( h, 4*idx );
            x = idx&1;
            y = idx>>1;
            p_src_by = p_src + 8 * x + 8 * y * i_stride;
            p_dst_by = p_dst + 8 * x + 8 * y * i_stride;
            i_best = COST_MAX;
            predict_4x4_mode_available( h->mb.i_neighbour8[idx], predict_mode,
                                        &i_max );
            for( i = 0; i < i_max; i++ )
            {
                int i_sad;
                int i_mode;
                i_mode = predict_mode[i];
                h->predict_8x8[i_mode]( p_dst_by, i_stride, h->mb.i_neighbour );
                /* could use sa8d, but it doesn't seem worth the speed cost (without
mmx at least) */
                i_sad = h->pixf.mbcmp[PIXEL_8x8]( p_dst_by, i_stride,
                        p_src_by, i_stride )+ a->i_lambda * (i_pred_mode ==
                                                             x264_mb_pred_mode4x4_fix(i_mode) ? 1 : 4);
                if( i_best > i_sad )
                {
                    a->i_predict8x8[x][y] = i_mode;
                    i_best = i_sad;
                }
            }
            a->i_sad_i8x8 += i_best;
            /* we need to encode this block now (for next ones) */
            h->predict_8x8[a->i_predict8x8[x][y]]( p_dst_by, i_stride,
                                                   h->mb.i_neighbour );
            x264_mb_encode_i8x8( h, idx, a->i_qp );
            x264_macroblock_cache_intra8x8_pred( h, 2*x, 2*y, a->i_predict8x8[x][y] );
        }
        if( a->b_mbrd )
        {
            if( h->mb.b_chroma_me )
                a->i_sad_i8x8 += a->i_sad_i8x8chroma;
            if( a->i_sad_i8x8 < i_satd_thresh )
            {
                h->mb.i_type = I_8x8;
                a->i_sad_i8x8 = x264_rd_cost_mb( h, a->i_lambda2 );
            }
            else
                a->i_sad_i8x8 = a->i_sad_i8x8 * f8_satd_rd_ratio >> 8;
        }
        else
        {
            // FIXME some bias like in i4x4?
            if( h->sh.i_type == SLICE_TYPE_B )
                a->i_sad_i8x8 += a->i_lambda * i_mb_b_cost_table[I_8x8];
        }
    }
}
/* 选取 16x16 亮度块,可用的帧内预测模式 */
static void predict_16x16_mode_available( unsigned int i_neighbour, int *mode, int
                                          *pi_count ){
    if( i_neighbour & MB_TOPLEFT )
    {
        /* top and left avaible */
        *mode++ = I_PRED_16x16_V;
        *mode++ = I_PRED_16x16_H;
        *mode++ = I_PRED_16x16_DC;
        *mode++ = I_PRED_16x16_P;
        *pi_count = 4;
    }
    else if( i_neighbour & MB_LEFT )
    {
        /* left available*/
        *mode++ = I_PRED_16x16_DC_LEFT;
        *mode++ = I_PRED_16x16_H;
        *pi_count = 2;
    }
    else if( i_neighbour & MB_TOP )
    {
        /* top available*/
        *mode++ = I_PRED_16x16_DC_TOP;
        *mode++ = I_PRED_16x16_V;
        *pi_count = 2;
    }
    else
    {
        /* none avaible */
        *mode = I_PRED_16x16_DC_128;
        *pi_count = 1;
    }
}
/* 从附近块中预测出一个模式 pred_mode */
int x264_mb_predict_intra4x4_mode( x264_t *h, int idx )
{
    const int ma = h->mb.cache.intra4x4_pred_mode[x264_scan8[idx] - 1];
    const int mb = h->mb.cache.intra4x4_pred_mode[x264_scan8[idx] - 8];
    const int m = X264_MIN( x264_mb_pred_mode4x4_fix(ma),
                            x264_mb_pred_mode4x4_fix(mb) );
    if( m < 0 )
        return I_PRED_4x4_DC;
    return m;}
/* 4x4(8x8)亮度块,可用的预测模式 */
static void predict_4x4_mode_available( unsigned int i_neighbour,
                                        int *mode, int *pi_count )
{
    /* FIXME even when b_tr == 0 there is some case where missing pixels
* are emulated and thus more mode are available TODO
* analysis and encode should be fixed too */
    int b_l = i_neighbour & MB_LEFT;
    int b_t = i_neighbour & MB_TOP;
    int b_tr = i_neighbour & MB_TOPRIGHT;
    if( b_l && b_t )
    {
        *mode++ = I_PRED_4x4_DC;
        *mode++ = I_PRED_4x4_H;
        *mode++ = I_PRED_4x4_V;
        *mode++ = I_PRED_4x4_DDR;
        *mode++ = I_PRED_4x4_VR;
        *mode++ = I_PRED_4x4_HD;
        *mode++ = I_PRED_4x4_HU;
        *pi_count = 7;
    }
    else if( b_l )
    {
        *mode++ = I_PRED_4x4_DC_LEFT;
        *mode++ = I_PRED_4x4_H;
        *mode++ = I_PRED_4x4_HU;
        *pi_count = 3;
    }
    else if( b_t )
    {
        *mode++ = I_PRED_4x4_DC_TOP;
        *mode++ = I_PRED_4x4_V;
        *pi_count = 2;
    }
    else
    {
        *mode++ = I_PRED_4x4_DC_128;
        *pi_count = 1;
    }
    if( b_t && b_tr ){
        *mode++ = I_PRED_4x4_DDL;
        *mode++ = I_PRED_4x4_VL;
        (*pi_count) += 2;
    }
}
/* 编码/计算某个模式的比特率(为了选取最优模式) */
void x264_mb_encode_i4x4( x264_t *h, int idx, int i_qscale )
{
    const int i_stride = h->mb.pic.i_stride[0];
    const int i_offset = 4 * block_idx_x[idx] + 4 * block_idx_y[idx] * i_stride;
    uint8_t *p_src = &h->mb.pic.p_fenc[0][i_offset];
    uint8_t *p_dst = &h->mb.pic.p_fdec[0][i_offset];
    int16_t dct4x4[4][4];
    if( h->mb.b_lossless )
    {
        sub_zigzag_4x4full( h->dct.block[idx].luma4x4, p_src, p_dst, i_stride );
        return;
    }
    h->dctf.sub4x4_dct( dct4x4, p_src, i_stride, p_dst, i_stride );
    quant_4x4( dct4x4, h->quant4_mf[CQM_4IY], i_qscale, 1 );
    scan_zigzag_4x4full( h->dct.block[idx].luma4x4, dct4x4 );
    x264_mb_dequant_4x4( dct4x4, h->dequant4_mf[CQM_4IY], i_qscale );
    /* output samples to fdec */
    h->dctf.add4x4_idct( p_dst, i_stride, dct4x4 );
}
/* 16x16 亮度块水平预测 */
static void predict_16x16_h( uint8_t *src, int i_stride )
{
    int i,j;
    for( i = 0; i < 16; i++ )
    {
        uint8_t v;
        v = src[-1];
        for( j = 0; j < 16; j++ )
        {src[j] = v;
        }
        src += i_stride;
    }
}