umc_h264_dec_slice_decoder_decode_pic.cpp

audio-video-codecs.rar语音编解码器

            pDistScaleFactor = m_DistScaleFactorAFF->values[L1Index][1][1][1];       //complementary field pairs, cf=bottom r1=bottom,r0=bottom
            pDistScaleFactorMV = m_DistScaleFactorMVAFF->values[1][1][1];   //complementary field pairs, cf=bottom r1=bottom,r0=bottom

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

                Ipp32s RefFieldTop = 1;
                picCntRef0 = pRefPicList0[L0Index]->PicOrderCnt(pRefPicList0[L0Index]->GetNumberByParity(1), 1);
                CalculateDSF(L0Index, pDistScaleFactor[L0Index], pDistScaleFactorMV[L0Index]);
            }
        }

        if (!isNeedScale)
        {
            m_DistScaleFactorAFF = 0;
        }
    }
} // void H264Slice::InitDistScaleFactor(Ipp32s NumL0RefActive,

Ipp32s H264Slice::AdjustRefPicListForFields(H264DecoderFrame **pRefPicList,
                                          ReferenceFlags *pFields,
                                          H264RefListInfo &rli)
{
    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_SliceHeader.bottom_field_flag;
    //first scan the list to determine number of shortterm and longterm reference frames
    while ((numSTR < 16) && pRefPicList[numSTR] && pRefPicList[numSTR]->isShortTermRef()) numSTR++;
    while ((numSTR + numLTR < 16) && 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)
        {
            while (num_same_parity < numSTR)
            {
                Ipp32s ref_field = pRefPicList[num_same_parity]->GetNumberByParity(current_parity);
                if (pRefPicList[num_same_parity]->isShortTermRef(ref_field))
                    break;

                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)
        {
            while (num_opposite_parity < numSTR)
            {
                Ipp32s ref_field = pRefPicList[num_opposite_parity]->GetNumberByParity(!current_parity);
                if (pRefPicList[num_opposite_parity]->isShortTermRef(ref_field))
                    break;
                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++;
            }
        }
    }

    rli.m_iNumShortEntriesInList = (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)
        {
            while (num_same_parity < numLTR)
            {
                Ipp32s ref_field = pRefPicList[num_same_parity+numSTR]->GetNumberByParity(current_parity);
                if (pRefPicList[num_same_parity+numSTR]->isLongTermRef(ref_field))
                    break;
                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)
        {
            while (num_opposite_parity < numLTR)
            {
                Ipp32s ref_field = pRefPicList[num_opposite_parity+numSTR]->GetNumberByParity(!current_parity);

                if (pRefPicList[num_opposite_parity+numSTR]->isLongTermRef(ref_field))
                    break;
                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++;
            }
        }
    }

    rli.m_iNumLongEntriesInList = (Ipp8u) (i - rli.m_iNumShortEntriesInList);
    j = 0;
    while(j < i)//copy data back to list
    {
        pRefPicList[j] = TempList[j];
        pFields[j].field = TempFields[j];
        pFields[j].isShortReference = pRefPicList[j]->isShortTermRef(pRefPicList[j]->GetNumberByParity(TempFields[j])) ? 1 : 0;
        j++;
    }

    while(j < MAX_NUM_REF_FRAMES)//fill remaining entries
    {
        pRefPicList[j] = NULL;
        pFields[j].field = 0;
        pFields[j].isShortReference = 0;
        j++;
    }

    return i;
} // Ipp32s H264Slice::AdjustRefPicListForFields(H264DecoderFrame **pRefPicList, Ipp8s *pFields)

void H264Slice::ReOrderRefPicList(bool bIsFieldSlice,
                                  H264DecoderFrame **pRefPicList,
                                  ReferenceFlags *pFields,
                                  RefPicListReorderInfo *pReorderInfo,
                                  Ipp32s MaxPicNum,
                                  Ipp32s NumRefActive,
                                  H264DBPList *pDecoderFrameList)
{
    Ipp32u i;
    Ipp32s picNumNoWrap;
    Ipp32s picNum;
    Ipp32s picNumPred;
    Ipp32s picNumCurr;

    // 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;

                H264DecoderFrame* pFrame = pDecoderFrameList->findShortTermPic(picNum, 0);

                for (Ipp32u k = NumRefActive; k > i; k--)
                {
                    pRefPicList[k] = pRefPicList[k - 1];
                    pFields[k] = pFields[k - 1];
                }

                // Place picture with picNum on list, shifting pictures
                // down by one while removing any duplication of picture with picNum.
                pRefPicList[i] = pFrame;
                pFields[i].field = 0;
                pFields[i].isShortReference = 1;
                Ipp32s refIdxLX = i + 1;

                for(Ipp32s kk = i + 1; kk <= NumRefActive; kk++)
                {
                    if (pRefPicList[kk])
                    {
                        if (!(pRefPicList[kk]->isShortTermRef(pRefPicList[kk]->GetNumberByParity(pFields[kk].field)) &&
                            pRefPicList[kk]->PicNum(pRefPicList[kk]->GetNumberByParity(pFields[kk].field), 1) == picNum))
                        {
                            pRefPicList[refIdxLX] = pRefPicList[kk];
                            pFields[refIdxLX] = pFields[kk];
                            refIdxLX++;
                        }
                    }
                }
            }    // short-term reorder
            else
            {
                // long term reorder
                picNum = pReorderInfo->reorder_value[i];

                H264DecoderFrame* pFrame = pDecoderFrameList->findLongTermPic(picNum, 0);

                for (Ipp32u k = NumRefActive; k > i; k--)
                {
                    pRefPicList[k] = pRefPicList[k - 1];
                    pFields[k] = pFields[k - 1];
                }

                // Place picture with picNum on list, shifting pictures
                // down by one while removing any duplication of picture with picNum.
                pRefPicList[i] = pFrame;
                pFields[i].field = 0;
                pFields[i].isShortReference = 0;
                Ipp32s refIdxLX = i + 1;

                for(Ipp32s kk = i + 1; kk <= NumRefActive; kk++)
                {
                    if (pRefPicList[kk])
                    {
                        if (!(pRefPicList[kk]->isLongTermRef(pRefPicList[kk]->GetNumberByParity(pFields[kk].field)) &&
                            pRefPicList[kk]->LongTermPicNum(pRefPicList[kk]->GetNumberByParity(pFields[kk].field), 1) == picNum))
                        {
                            pRefPicList[refIdxLX] = pRefPicList[kk];
                            pFields[refIdxLX] = pFields[kk];
                            refIdxLX++;
                        }
                    }
                }
            }    // long term reorder
        }    // for i
    }
    else
    {
        picNumCurr = m_pCurrentFrame->PicNum(m_pCurrentFrame->GetNumberByParity(m_SliceHeader.bottom_field_flag));
        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;

                Ipp32s frameField;
                H264DecoderFrame* pFrame = pDecoderFrameList->findShortTermPic(picNum, &frameField);

                for (Ipp32u k = NumRefActive; k > i; k--)
                {
                    pRefPicList[k] = pRefPicList[k - 1];
                    pFields[k] = pFields[k - 1];
                }

                // Place picture with picNum on list, shifting pictures
                // down by one while removing any duplication of picture with picNum.
                pRefPicList[i] = pFrame;
                pFields[i].field = pFrame ? pFrame->m_bottom_field_flag[frameField] : 0;
                pFields[i].isShortReference = 1;
                Ipp32s refIdxLX = i + 1;

                for(Ipp32s kk = i + 1; kk <= NumRefActive; kk++)
                {
                    if (pRefPicList[kk])
                    {
                        if (!(pRefPicList[kk]->isShortTermRef(pRefPicList[kk]->GetNumberByParity(pFields[kk].field)) &&
                            pRefPicList[kk]->PicNum(pRefPicList[kk]->GetNumberByParity(pFields[kk].field), 1) == picNum))
                        {
                            pRefPicList[refIdxLX] = pRefPicList[kk];
                            pFields[refIdxLX] = pFields[kk];
                            refIdxLX++;
                        }
                    }
                }
            }    // short term reorder
            else
            {
                // long term reorder
                picNum = pReorderInfo->reorder_value[i];

                Ipp32s frameField;
                H264DecoderFrame* pFrame = pDecoderFrameList->findLongTermPic(picNum, &frameField);

                for (Ipp32u k = NumRefActive; k > i; k--)
                {
                    pRefPicList[k] = pRefPicList[k - 1];
                    pFields[k] = pFields[k - 1];
                }

                // Place picture with picNum on list, shifting pictures
                // down by one while removing any duplication of picture with picNum.
                pRefPicList[i] = pFrame;
                pFields[i].field = pFrame ? pFrame->m_bottom_field_flag[frameField] : 0;
                pFields[i].isShortReference = 0;
                Ipp32s refIdxLX = i + 1;

                for(Ipp32s kk = i + 1; kk <= NumRefActive; kk++)
                {
                    if (pRefPicList[kk])
                    {
                        if (!(pRefPicList[kk]->isLongTermRef(pRefPicList[kk]->GetNumberByParity(pFields[kk].field)) &&
                            pRefPicList[kk]->LongTermPicNum(pRefPicList[kk]->GetNumberByParity(pFields[kk].field), 1) == picNum))
                        {
                            pRefPicList[refIdxLX] = pRefPicList[kk];
                            pFields[refIdxLX] = pFields[kk];
                            refIdxLX++;
                        }
                    }
                }
            }    // long term reorder
        }    // for i
    }
} // void H264Slice::ReOrderRefPicList(bool bIsFieldSlice,

} // namespace UMC
#endif // UMC_ENABLE_H264_VIDEO_DECODER