umc_h264_dec_decode_pic.cpp

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

        for (L0Index=0; L0Index<NumL0RefActive; L0Index++)
        {
            VM_ASSERT(pRefPicList0[L0Index]);

            picCntRef0 = pRefPicList0[L0Index]->PicOrderCnt(0,1);
            CalculateDSF(L0Index);
        }

        pDistScaleFactor = m_CurSliceInfo.DistScaleFactorAFF[1][0][1];        //complementary field pairs, cf=bottom r1=top,r0=bottom
        pDistScaleFactorMV = m_CurSliceInfo.DistScaleFactorMVAFF[1][0][1];  //complementary field pairs, cf=bottom r1=top,r0=bottom

        picCntCur = m_pCurrentFrame->PicOrderCnt(1,1);
        picCntRef1 = pRefPicList1[0]->PicOrderCnt(0,1);

        for (L0Index=0; L0Index<NumL0RefActive; L0Index++)
        {
            VM_ASSERT(pRefPicList0[L0Index]);

            picCntRef0 = pRefPicList0[L0Index]->PicOrderCnt(1,1);
            CalculateDSF(L0Index);
        }
        pDistScaleFactor = m_CurSliceInfo.DistScaleFactorAFF[1][1][0];        //complementary field pairs, cf=bottom r1=bottom,r0=top
        pDistScaleFactorMV = m_CurSliceInfo.DistScaleFactorMVAFF[1][1][0];  //complementary field pairs, cf=bottom r1=bottom,r0=top

        picCntCur = m_pCurrentFrame->PicOrderCnt(1,1);
        picCntRef1 = pRefPicList1[0]->PicOrderCnt(1,1);

        for (L0Index=0; L0Index<NumL0RefActive; L0Index++)
        {
            VM_ASSERT(pRefPicList0[L0Index]);

            picCntRef0 = pRefPicList0[L0Index]->PicOrderCnt(0,1);
            CalculateDSF(L0Index);
        }
        pDistScaleFactor = m_CurSliceInfo.DistScaleFactorAFF[1][1][1];        //complementary field pairs, cf=bottom r1=bottom,r0=bottom
        pDistScaleFactorMV = m_CurSliceInfo.DistScaleFactorMVAFF[1][1][1];  //complementary field pairs, cf=bottom r1=bottom,r0=bottom

        picCntCur = m_pCurrentFrame->PicOrderCnt(1,1);
        picCntRef1 = pRefPicList1[0]->PicOrderCnt(1,1);

        for (L0Index=0; L0Index<NumL0RefActive; L0Index++)
        {
            VM_ASSERT(pRefPicList0[L0Index]);

            picCntRef0 = pRefPicList0[L0Index]->PicOrderCnt(1,1);
            CalculateDSF(L0Index);
        }
    }

}    // InitDistScaleFactor

void H264VideoDecoder::AdjustRefPicListForFields(
    H264DecoderFrame **pRefPicList,Ipp8s *pFields)
{
    H264DecoderFrame *TempList[MAX_NUM_REF_FRAMES+1];
    Ipp8u TempFields[MAX_NUM_REF_FRAMES+1];
    //walk through list and set correct indices
    Ipp32s i=0,j=0,numSTR=0,numLTR=0;
    Ipp32s num_same_parity=0,num_opposite_parity=0;
    Ipp8s current_parity = m_pCurrentFrame->m_bottom_field_flag[m_field_index];
    //first scan the list to determine number of shortterm and longterm reference frames
    while (pRefPicList[numSTR] && pRefPicList[numSTR]->isShortTermRef()) numSTR++;
    while (pRefPicList[numSTR+numLTR] && pRefPicList[numSTR+numLTR]->isLongTermRef()) numLTR++;
    while(num_same_parity<numSTR ||  num_opposite_parity<numSTR)
    {
        //try to fill shorttermref fields with the same parity first
        if (num_same_parity<numSTR)
        {
            Ipp8u ref_field = pRefPicList[num_same_parity]->GetNumberByParity(current_parity);

            while (num_same_parity<numSTR && !pRefPicList[num_same_parity]->isShortTermRef(ref_field))
                num_same_parity++;
            if (num_same_parity<numSTR)
            {
                TempList[i] = pRefPicList[num_same_parity];
                TempFields[i] = current_parity;
                i++;
                num_same_parity++;
            }
        }
        //now process opposite parity
        if (num_opposite_parity<numSTR)
        {
            Ipp8u ref_field = pRefPicList[num_opposite_parity]->GetNumberByParity(!current_parity);

            while (num_opposite_parity<numSTR && !pRefPicList[num_opposite_parity]->isShortTermRef(ref_field))
                num_opposite_parity++;
            if (num_opposite_parity<numSTR) //selected field is reference
            {
                TempList[i] = pRefPicList[num_opposite_parity];
                TempFields[i] = !current_parity;
                i++;
                num_opposite_parity++;
            }
        }
    }
    m_NumShortEntriesInList = (Ipp8u) i;
    num_same_parity=num_opposite_parity=0;
    //now processing LongTermRef
    while(num_same_parity<numLTR ||  num_opposite_parity<numLTR)
    {
        //try to fill longtermref fields with the same parity first
        if (num_same_parity<numLTR)
        {
            Ipp8u ref_field = pRefPicList[num_same_parity+numSTR]->GetNumberByParity(current_parity);

            while (num_same_parity<numLTR && !pRefPicList[num_same_parity+numSTR]->isLongTermRef(ref_field))
                num_same_parity++;
            if (num_same_parity<numLTR)
            {
                TempList[i] = pRefPicList[num_same_parity+numSTR];
                TempFields[i] = current_parity;
                i++;
                num_same_parity++;
            }
        }
        //now process opposite parity
        if (num_opposite_parity<numLTR)
        {
            Ipp8u ref_field = pRefPicList[num_opposite_parity+numSTR]->GetNumberByParity(!current_parity);

            while (num_opposite_parity<numLTR && !pRefPicList[num_opposite_parity+numSTR]->isLongTermRef(ref_field))
                num_opposite_parity++;
            if (num_opposite_parity<numLTR) //selected field is reference
            {
                TempList[i] = pRefPicList[num_opposite_parity+numSTR];
                TempFields[i] = !current_parity;
                i++;
                num_opposite_parity++;
            }
        }
    }
    m_NumLongEntriesInList = (Ipp8u) (i - m_NumShortEntriesInList);
    j=0;
    while(j<i)//copy data back to list
    {
        pRefPicList[j]=TempList[j];
        pFields[j] = TempFields[j];

        j++;
    }
    while(j<MAX_NUM_REF_FRAMES)//fill remaining entries
    {
        pRefPicList[j]=NULL;
        pFields[j] = -1;
        j++;
    }
    return;
}
//////////////////////////////////////////////////////////////////////////////
// ReOrderRefPicList
//  Use reordering info from the slice header to reorder (update) L0 or L1
//  reference picture list.
//////////////////////////////////////////////////////////////////////////////
void H264VideoDecoder::ReOrderRefPicList(
    bool bIsFieldSlice,
    H264DecoderFrame **pRefPicList,
    Ipp8s         *pFields,
    RefPicListReorderInfo *pReorderInfo,
    Ipp32s MaxPicNum,
    Ipp32s NumRefActive
)
{
    Ipp32u i;
    Ipp32s j;
    Ipp32s PicNumNoWrap;
    Ipp32s PicNum;
    Ipp32s PicNumPred;
    Ipp32s PicNumCurr;
    H264DecoderFrame *tempFrame[2];
    Ipp8s tempFields[2];
    Ipp32u NumDuplicates;

    // Reference: Reordering process for reference picture lists, 8.2.4.3
    if (!bIsFieldSlice)
    {
        PicNumCurr = m_pCurrentFrame->PicNum(0,3);
        PicNumPred = PicNumCurr;

        for (i=0; i<pReorderInfo->num_entries; i++)
        {
            if (pReorderInfo->reordering_of_pic_nums_idc[i] < 2)
            {
                // short term reorder
                if (pReorderInfo->reordering_of_pic_nums_idc[i] == 0)
                {
                    PicNumNoWrap = PicNumPred - pReorderInfo->reorder_value[i];
                    if (PicNumNoWrap < 0)
                        PicNumNoWrap += MaxPicNum;
                }
                else
                {
                    PicNumNoWrap = PicNumPred + pReorderInfo->reorder_value[i];
                    if (PicNumNoWrap >= MaxPicNum)
                        PicNumNoWrap -= MaxPicNum;
                }
                PicNumPred = PicNumNoWrap;

                PicNum = PicNumNoWrap;
                if (PicNum > PicNumCurr)
                    PicNum -= MaxPicNum;

                // Find the PicNum frame.
                for (j=0; pRefPicList[j] !=NULL; j++)
                    if (pRefPicList[j] != NULL &&
                        pRefPicList[j]->isShortTermRef() &&
                        pRefPicList[j]->PicNum(0,3) == PicNum)
                        break;

                // error if not found, should not happen
                VM_ASSERT(pRefPicList[j]);

                // Place picture with PicNum on list, shifting pictures
                // down by one while removing any duplication of picture with PicNum.
                tempFrame[0] = pRefPicList[j];    // PicNum frame just found
                NumDuplicates = 0;
                for (j=i; j<NumRefActive || pRefPicList[j] !=NULL; j++)
                {
                    if (NumDuplicates == 0)
                    {
                        // shifting pictures down
                        tempFrame[1] = pRefPicList[j];
                        pRefPicList[j] = tempFrame[0];
                        tempFrame[0] = tempFrame[1];
                    }
                    else if (NumDuplicates == 1)
                    {
                        // one duplicate of PicNum made room for new entry, just
                        // look for more duplicates to eliminate
                        tempFrame[0] = pRefPicList[j];
                    }
                    else
                    {
                        // >1 duplicate found, shifting pictures up
                        pRefPicList[j - NumDuplicates + 1] = tempFrame[0];
                        tempFrame[0] = pRefPicList[j];
                    }
                    if (tempFrame[0] == NULL)
                        break;        // end of valid reference frames
                    if (tempFrame[0]->isShortTermRef() &&
                        tempFrame[0]->PicNum(0,3) == PicNum)
                        NumDuplicates++;
                }
            }    // short term reorder
            else
            {
                // long term reorder
                PicNum = pReorderInfo->reorder_value[i];

                // Find the PicNum frame.
                for (j=0; pRefPicList[j] !=NULL; j++)
                    if (pRefPicList[j] != NULL &&
                        pRefPicList[j]->isLongTermRef() &&
                        pRefPicList[j]->LongTermPicNum(0,3) == PicNum)
                        break;

                // error if not found, should not happen
                VM_ASSERT(pRefPicList[j]);

                // Place picture with PicNum on list, shifting pictures
                // down by one while removing any duplication of picture with PicNum.
                tempFrame[0] = pRefPicList[j];    // PicNum frame just found
                NumDuplicates = 0;
                for (j=i; j<NumRefActive || pRefPicList[j] !=NULL; j++)
                {
                    if (NumDuplicates == 0)
                    {
                        // shifting pictures down
                        tempFrame[1] = pRefPicList[j];
                        pRefPicList[j] = tempFrame[0];
                        tempFrame[0] = tempFrame[1];
                    }
                    else if (NumDuplicates == 1)
                    {
                        // one duplicate of PicNum made room for new entry, just
                        // look for more duplicates to eliminate
                        tempFrame[0] = pRefPicList[j];
                    }
                    else
                    {
                        // >1 duplicate found, shifting pictures up
                        pRefPicList[j - NumDuplicates + 1] = tempFrame[0];
                        tempFrame[0] = pRefPicList[j];
                    }
                    if (tempFrame[0] == NULL)
                        break;        // end of valid reference frames
                    if (tempFrame[0]->isLongTermRef() &&
                        tempFrame[0]->LongTermPicNum(0,3) == PicNum)
                        NumDuplicates++;
                }
            }    // long term reorder
        }    // for i
    }
    else
    {
        //NumRefActive<<=1;
        PicNumCurr = m_pCurrentFrame->PicNum(m_field_index);
        PicNumPred = PicNumCurr;

        for (i=0; i<pReorderInfo->num_entries; i++)
        {
            if (pReorderInfo->reordering_of_pic_nums_idc[i] < 2)
            {
                // short term reorder
                if (pReorderInfo->reordering_of_pic_nums_idc[i] == 0)
                {
                    PicNumNoWrap = PicNumPred - pReorderInfo->reorder_value[i];
                    if (PicNumNoWrap < 0)
                        PicNumNoWrap += MaxPicNum;
                }
                else
                {
                    PicNumNoWrap = PicNumPred + pReorderInfo->reorder_value[i];
                    if (PicNumNoWrap >= MaxPicNum)
                        PicNumNoWrap -= MaxPicNum;
                }
                PicNumPred = PicNumNoWrap;

                PicNum = PicNumNoWrap;
                if (PicNum > PicNumCurr)
                    PicNum -= MaxPicNum;

                // Find the PicNum frame.
                for (j=0; pRefPicList[j] !=NULL; j++)
                    if (pRefPicList[j] != NULL &&
                        pRefPicList[j]->isShortTermRef(pRefPicList[j]->GetNumberByParity(pFields[j])) &&
                        pRefPicList[j]->PicNum(pRefPicList[j]->GetNumberByParity(pFields[j]),1) == PicNum)
                        break;

                // error if not found, should not happen
                VM_ASSERT(pRefPicList[j]);

                // Place picture with PicNum on list, shifting pictures
                // down by one while removing any duplication of picture with PicNum.
                tempFrame[0] = pRefPicList[j];    // PicNum frame just found
                tempFields[0] = pFields[j];

                NumDuplicates = 0;
                for (j=i; j<NumRefActive || pRefPicList[j] !=NULL; j++)
                {
                    if (NumDuplicates == 0)
                    {
                        // shifting pictures down
                        tempFrame[1] = pRefPicList[j];
                        pRefPicList[j] = tempFrame[0];
                        tempFrame[0] = tempFrame[1];

                        tempFields[1] = pFields[j];
                        pFields[j] = tempFields[0];
                        tempFields[0] = tempFields[1];
                    }
                    else if (NumDuplicates == 1)
                    {
                        // one duplicate of PicNum made room for new entry, just
                        // look for more duplicates to eliminate
                        tempFrame[0] = pRefPicList[j];
                        t