umc_h264_pack.cpp

这是在PCA下的基于IPP库示例代码例子,在网上下了IPP的库之后,设置相关参数就可以编译该代码.

        if(!IS_Left_Available(uMB))
        {
            Left_Block_Availability[0] = 0;
            Left_Block_Availability[1] = 0;
        }
        Multiply_DMV(&m_pCurrentFrame->pDMVL0[m_pCurrentFrame->pMBOffsets[uMB].uFirstBlockIndex+m_pCurrentFrame->block_positions[0]],0,2,1,0,4,1,mvd[0]);
        Multiply_DMV(&m_pCurrentFrame->pDMVL1[m_pCurrentFrame->pMBOffsets[uMB].uFirstBlockIndex+m_pCurrentFrame->block_positions[0]],0,2,1,0,4,1,mvd[1]);
        Multiply_DMV(&m_pCurrentFrame->pDMVL1[m_pCurrentFrame->pMBOffsets[uMB].uFirstBlockIndex+m_pCurrentFrame->block_positions[2]],0,2,1,0,4,1,mvd[2]);
        break;

    case MBTYPE_BWD_BIDIR_8x16:
        ref0_vectors = 1;
        num_vectors = 3;
        num_ref_idx_l0 = 1;
        num_ref_idx_l1 = 2;

        block_index[0]=m_pCurrentFrame->block_positions[2];
        block_index[1]=m_pCurrentFrame->block_positions[0];
        block_index[2]=m_pCurrentFrame->block_positions[2];
        ref_idx_l0[0] = pRefIdxL0[block_index[0]];
        ref_idx_l1[0] = pRefIdxL1[block_index[1]];
        ref_idx_l1[1] = pRefIdxL1[block_index[2]];

        Calc_One_MV_Predictor(uMB, 0, 1, 2, 4, mv+1, mvd+1, &ref_idx_l1_ctxIdxInc[0]);
        Calc_One_MV_Predictor(uMB, 2, 0, 2, 4, mv, mvd, &ref_idx_l0_ctxIdxInc[0]);
        Calc_One_MV_Predictor(uMB, 2, 1, 2, 4, mv+2, mvd+2, &ref_idx_l1_ctxIdxInc[1]);
        if(!IS_Top_Available(uMB))
        {
            Top_Block_Availability[0] = 0;
            Top_Block_Availability[1] = 0;
            Top_Block_Availability[2] = 0;
        }
        if(!IS_Left_Available(uMB))
        {
            Left_Block_Availability[1] = 0;
        }
        Multiply_DMV(&m_pCurrentFrame->pDMVL0[m_pCurrentFrame->pMBOffsets[uMB].uFirstBlockIndex+m_pCurrentFrame->block_positions[2]],0,2,1,0,4,1,mvd[0]);
        Multiply_DMV(&m_pCurrentFrame->pDMVL1[m_pCurrentFrame->pMBOffsets[uMB].uFirstBlockIndex+m_pCurrentFrame->block_positions[0]],0,2,1,0,4,1,mvd[1]);
        Multiply_DMV(&m_pCurrentFrame->pDMVL1[m_pCurrentFrame->pMBOffsets[uMB].uFirstBlockIndex+m_pCurrentFrame->block_positions[2]],0,2,1,0,4,1,mvd[2]);
        break;

    case MBTYPE_BIDIR_BIDIR_8x16:
        ref0_vectors = 2;
        num_vectors = 4;
        num_ref_idx_l0 = 2;
        num_ref_idx_l1 = 2;

        block_index[0]=m_pCurrentFrame->block_positions[0];
        block_index[1]=m_pCurrentFrame->block_positions[2];
        block_index[2]=m_pCurrentFrame->block_positions[0];
        block_index[3]=m_pCurrentFrame->block_positions[2];
        ref_idx_l0[0] = pRefIdxL0[block_index[0]];
        ref_idx_l0[1] = pRefIdxL0[block_index[1]];
        ref_idx_l1[0] = pRefIdxL1[block_index[2]];
        ref_idx_l1[1] = pRefIdxL1[block_index[3]];

        Calc_One_MV_Predictor(uMB, 0, 0, 2, 4, mv, mvd, &ref_idx_l0_ctxIdxInc[0]);
        Calc_One_MV_Predictor(uMB, 0, 1, 2, 4, mv+2, mvd+2, &ref_idx_l1_ctxIdxInc[0]);
        Calc_One_MV_Predictor(uMB, 2, 0, 2, 4, mv+1, mvd+1, &ref_idx_l0_ctxIdxInc[1]);
        Calc_One_MV_Predictor(uMB, 2, 1, 2, 4, mv+3, mvd+3, &ref_idx_l1_ctxIdxInc[1]);
        if(!IS_Top_Available(uMB))
        {
            Top_Block_Availability[0] = 0;
            Top_Block_Availability[1] = 0;
            Top_Block_Availability[2] = 0;
            Top_Block_Availability[3] = 0;
        }
        if(!IS_Left_Available(uMB))
        {
            Left_Block_Availability[0] = 0;
            Left_Block_Availability[2] = 0;
        }
        Multiply_DMV(&m_pCurrentFrame->pDMVL0[m_pCurrentFrame->pMBOffsets[uMB].uFirstBlockIndex+m_pCurrentFrame->block_positions[0]],0,2,1,0,4,1,mvd[0]);
        Multiply_DMV(&m_pCurrentFrame->pDMVL0[m_pCurrentFrame->pMBOffsets[uMB].uFirstBlockIndex+m_pCurrentFrame->block_positions[2]],0,2,1,0,4,1,mvd[1]);
        Multiply_DMV(&m_pCurrentFrame->pDMVL1[m_pCurrentFrame->pMBOffsets[uMB].uFirstBlockIndex+m_pCurrentFrame->block_positions[0]],0,2,1,0,4,1,mvd[2]);
        Multiply_DMV(&m_pCurrentFrame->pDMVL1[m_pCurrentFrame->pMBOffsets[uMB].uFirstBlockIndex+m_pCurrentFrame->block_positions[2]],0,2,1,0,4,1,mvd[3]);
        break;

    case MBTYPE_INTER_8x8:
    case MBTYPE_INTER_8x8_REF0:
        num_vectors = 0;    // Initialize this counter

        for (uBlock =0; uBlock < 4; uBlock++)
        {
            switch (m_pCurrentFrame->pMBData[uMB].SBType[uBlock])
            {
                case SBTYPE_8x8:
                    Calc_One_MV_Predictor(uMB, blockpos[uBlock], 0, 2, 2, mv+num_vectors, mvd+num_vectors, &ref_idx_l0_ctxIdxInc[num_ref_idx_l0]);
                    block_index[num_vectors] = m_pCurrentFrame->block_positions[blockpos[uBlock]];
                    ref_idx_l0[num_ref_idx_l0++] = pRefIdxL0[block_index[num_vectors]];
                    Multiply_DMV(&m_pCurrentFrame->pDMVL0[m_pCurrentFrame->pMBOffsets[uMB].uFirstBlockIndex+m_pCurrentFrame->block_positions[blockpos[uBlock]]],0,2,1,0,2,1,mvd[num_vectors]);

                    switch(uBlock)
                    {
                    case 0:
                        if(!IS_Top_Available(uMB))
                        {
                            Top_Block_Availability[num_vectors] = 0;
                        }
                        if(!IS_Left_Available(uMB))
                        {
                            Left_Block_Availability[num_vectors] = 0;
                        }
                        break;
                    case 1:
                        if(!IS_Top_Available(uMB))
                        {
                            Top_Block_Availability[num_vectors] = 0;
                        }
                        break;
                    case 2:
                        if(!IS_Left_Available(uMB))
                        {
                            Left_Block_Availability[num_vectors] = 0;
                        }
                        break;
                    default:
                        break;
                    }
                    num_vectors++;
                    break;

                case SBTYPE_8x4:
                    Calc_One_MV_Predictor(uMB, blockpos[uBlock], 0, 2, 1, mv+num_vectors, mvd+num_vectors, &ref_idx_l0_ctxIdxInc[num_ref_idx_l0]);
                    Calc_One_MV_Predictor(uMB, blockpos[uBlock]+4, 0, 2, 1, mv+num_vectors+1, mvd+num_vectors+1, &ref_idx_l0_ctxIdxInc[num_ref_idx_l0+1]); // the second ctxIdxInc value won't be used
                    block_index[num_vectors]=m_pCurrentFrame->block_positions[blockpos[uBlock]];
                    block_index[num_vectors+1]=m_pCurrentFrame->block_positions[blockpos[uBlock]+4];
                    ref_idx_l0[num_ref_idx_l0++] = pRefIdxL0[block_index[num_vectors]];

                    Multiply_DMV(&m_pCurrentFrame->pDMVL0[m_pCurrentFrame->pMBOffsets[uMB].uFirstBlockIndex+m_pCurrentFrame->block_positions[blockpos[uBlock]]],0,2,1,0,1,1,mvd[num_vectors]);
                    Multiply_DMV(&m_pCurrentFrame->pDMVL0[m_pCurrentFrame->pMBOffsets[uMB].uFirstBlockIndex+m_pCurrentFrame->block_positions[blockpos[uBlock]+4]],0,2,1,0,1,1,mvd[num_vectors+1]);
                    switch(uBlock )
                    {
                    case 0:
                        if(!IS_Top_Available(uMB))
                        {
                            Top_Block_Availability[num_vectors] = 0;
                        }
                        if(!IS_Left_Available(uMB))
                        {
                            Left_Block_Availability[num_vectors] = 0;
                            Left_Block_Availability[num_vectors+1] = 0;
                        }
                        break;
                    case 1:
                        if(!IS_Top_Available(uMB))
                        {
                            Top_Block_Availability[num_vectors] = 0;
                        }
                        break;
                    case 2:
                        if(!IS_Left_Available(uMB))
                        {
                            Left_Block_Availability[num_vectors] = 0;
                            Left_Block_Availability[num_vectors+1] = 0;
                        }
                        break;
                    default:
                        break;
                    }
                    num_vectors += 2;
                    break;

                case SBTYPE_4x8:
                    Calc_One_MV_Predictor(uMB, blockpos[uBlock], 0, 1, 2, mv+num_vectors, mvd+num_vectors, &ref_idx_l0_ctxIdxInc[num_ref_idx_l0]);
                    Calc_One_MV_Predictor(uMB, blockpos[uBlock]+1, 0, 1, 2, mv+num_vectors+1, mvd+num_vectors+1, &ref_idx_l0_ctxIdxInc[num_ref_idx_l0 + 1]); // the second ctxIdxInc won't be used.
                    block_index[num_vectors]=m_pCurrentFrame->block_positions[blockpos[uBlock]];
                    block_index[num_vectors+1]=m_pCurrentFrame->block_positions[blockpos[uBlock]+1];
                    ref_idx_l0[num_ref_idx_l0++] = pRefIdxL0[block_index[num_vectors]];

                    Multiply_DMV(&m_pCurrentFrame->pDMVL0[m_pCurrentFrame->pMBOffsets[uMB].uFirstBlockIndex+m_pCurrentFrame->block_positions[blockpos[uBlock]]],0,1,1,0,2,1,mvd[num_vectors]);
                    Multiply_DMV(&m_pCurrentFrame->pDMVL0[m_pCurrentFrame->pMBOffsets[uMB].uFirstBlockIndex+m_pCurrentFrame->block_positions[blockpos[uBlock]+1]],0,1,1,0,2,1,mvd[num_vectors+1]);
                    switch(uBlock )
                    {
                    case 0:
                        if(!IS_Top_Available(uMB))
                        {
                            Top_Block_Availability[num_vectors] = 0;
                            Top_Block_Availability[num_vectors+1] = 0;
                        }
                        if(!IS_Left_Available(uMB))
                        {
                            Left_Block_Availability[num_vectors] = 0;
                        }
                        break;
                    case 1:
                        if(!IS_Top_Available(uMB))
                        {
                            Top_Block_Availability[num_vectors] = 0;
                            Top_Block_Availability[num_vectors+1] = 0;
                        }
                        break;
                    case 2:
                        if(!IS_Left_Available(uMB))
                        {
                            Left_Block_Availability[num_vectors] = 0;
                        }
                        break;
                    default:
                        break;
                    }
                    num_vectors += 2;
                    break;

                case SBTYPE_4x4:
                    Calc_One_MV_Predictor(uMB, blockpos[uBlock], 0, 1, 1, mv+num_vectors, mvd+num_vectors, &ref_idx_l0_ctxIdxInc[num_ref_idx_l0]);
                    Calc_One_MV_Predictor(uMB, blockpos[uBlock]+1, 0, 1, 1, mv+num_vectors+1, mvd+num_vectors+1, &ref_idx_l0_ctxIdxInc[num_ref_idx_l0+1]); // ctxIdxInc won't be used.
                    Calc_One_MV_Predictor(uMB, blockpos[uBlock]+4, 0, 1, 1, mv+num_vectors+2, mvd+num_vectors+2, &ref_idx_l0_ctxIdxInc[num_ref_idx_l0+1]); // ctxIdxInc won't be used.
                    Calc_One_MV_Predictor(uMB, blockpos[uBlock]+5, 0, 1, 1, mv+num_vectors+3, mvd+num_vectors+3, &ref_idx_l0_ctxIdxInc[num_ref_idx_l0+1]); // ctxIdxInc won't be used.
                    //DMV needn't to be multiplied
                    block_index[num_vectors]=m_pCurrentFrame->block_positions[blockpos[uBlock]];
                    block_index[num_vectors+1]=m_pCurrentFrame->block_positions[blockpos[uBlock]+1];
                    block_index[num_vectors+2]=m_pCurrentFrame->block_positions[blockpos[uBlock]+4];
                    block_index[num_vectors+3]=m_pCurrentFrame->block_positions[blockpos[uBlock]+5];
                    ref_idx_l0[num_ref_idx_l0++] = pRefIdxL0[block_index[num_vectors]];
                    switch(uBlock )
                    {
                    case 0:
                        if(!IS_Top_Available(uMB))
                        {
                            Top_Block_Availability[num_vectors] = 0;
                            Top_Block_Availability[num_vectors+1] = 0;
                        }
                        if(!IS_Left_Available(uMB))
                        {
                            Left_Block_Availability[num_vectors] = 0;
                            Left_Block_Availability[num_vectors+2] = 0;
                        }
                        break;
                    case 1:
                        if(!IS_Top_Available(uMB))
                        {
                            Top_Block_Availability[num_vectors] = 0;
                            Top_Block_Availability[num_vectors+1] = 0;
                        }
                        break;
                    case 2:
                        if(!IS_Left_Available(uMB))
                        {
                            Left_Block_Availability[num_vectors] = 0;
                            Left_Block_Availability[num_vectors+2] = 0;
                        }
                        break;
                    default:
                        break;
                    }
                    num_vectors += 4;
                    break;

                default:
                    break;
            }
        }

        ref0_vectors = num_vectors;
        num_ref_idx_l0 = (uMBType == MBTYPE_INTER_8x8)? num_ref_idx_l0 : 0;
        break;

    case MBTYPE_DIRECT:
        ref0_vectors = 0;
        num_vectors = 0;
        num_ref_idx_l0 = 0;
        num_ref_idx_l1 = 0;
        break;

    case MBTYPE_BIDIR:
        ref0_vectors = 1;
        num_vectors = 2;
        num_ref_idx_l0 = 1;
        num_ref_idx_l1 = 1;

        block_index[0]=m_pCurrentFrame->block_positions[blockpos[0]];
        block_index[1]=m_pCurrentFrame->block_positions[blockpos[0]];
        ref_idx_l0[0] = pRefIdxL0[block_index[0]];
        ref_idx_l1[0] = pRefIdxL1[block_index[1]];

        Calc_One_MV_Predictor(uMB, 0, 0, 4, 4, mv, mvd, &ref_idx_l0_ctxIdxInc[0]);
        Calc_One_MV_Predictor(uMB, 0, 1, 4, 4, mv+1, mvd+1, &ref_idx_l1_ctxIdxInc[0]);
        Multiply_DMV(&m_pCurrentFrame->pDMVL0[m_pCurrentFrame->pMBOffsets[uMB].uFirstBlockIndex+m_pCurrentFrame->block_positions[blockpos[0]]],0,4,1,0,4,1,mvd[0]);
        Multiply_DMV(&m_pCurrentFrame->pDMVL1[m_pCurrentFrame->pMBOffsets[uMB].uFirstBlockIndex+m_pCurrentFrame->block_positions[blockpos[0]]],0,4,1,0,4,1,mvd[1]);
        if(!IS_Top_Available(uMB))
        {
            Top_Block_Availability[0] = 0;
            Top_Block_Availability[1] = 0;
        }

        if(!IS_Left_Available(uMB))
        {
            Left_Block_Availability[0] = 0;
            Left_Block_Availability[1] = 0;
        }
        break;

    case MBTYPE_B_8x8:
        num_vectors = 0;    // Initialize this counter

        // Forward Vectors first
        for (uBlock = 0; uBlock < 4; uBlock++)
        {
            switch (m_pCurrentFrame->pMBData[uMB].SBType[uBlock])
            {
                case SBTYPE_DIRECT:
                    Calc_One_MV_Predictor(uMB, blockpos[uBlock], 0, 2, 2, mv+num_vectors, mvd+num_vectors, &ref_idx_l0_ctxIdxInc[num_ref_idx_l0]);
                    block_index[num_vectors]=m_pCurrentFrame->block_positions[blockpos[uBlock]];
                    //ref_idx_l0[num_ref_idx_l0++] = pRefIdxL0[block_index[num_vectors]];
                    break;
                case SBTYPE_FORWARD_8x8:
                case SBTYPE_BIDIR_8x8:
                    Calc_One_MV_Predictor(uMB, blockpos[uBlock], 0, 2, 2, mv+num_vectors, mvd+num_vectors, &ref_idx_l0_ctxIdxInc[num_ref_idx_l0]);
                    block_index[num_vectors]=m_pCurrentFrame->block_positions[blockpos[uBlock]];
                    ref_idx_l0[num_ref_idx_l0++] = pRefIdxL0[block_index[num_vectors]];
                    Multiply_DMV(&m_pCurrentFrame->pDMVL0[m_pCurrentFrame->pMBOffsets[uMB].uFirstBlockIndex+m_pCurrentFrame->block_positions[blockpos[uBlock]]],0,2,1,0,2,1,mvd[num_vectors]);