umc_h264_segment_decoder_mt.cpp

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

    }

    if(pCodMVd[8] == CodNone)
    {
        memset(&pMVd[8],0,8*sizeof(H264DecoderMotionVector));
    }
    else
    {
        mvd = GetSE_MVD_CABAC(ListNum, 8);

        for (k = 8; k < 16; k ++)
        {
            pMVd[k].mvx = mvd.mvx;
            pMVd[k].mvy = mvd.mvy;

        } // for k
    }
} // void H264SegmentDecoderMultiThreaded::GetMVD4x4_16x8_CABAC(const Ipp8u *pCodMVd,

void H264SegmentDecoderMultiThreaded::ReconstructMotionVectors16x8(const Ipp8u *pCodMVd,
                                                                     Ipp32u ListNum)
{
    Ipp32u k;

    H264DecoderMotionVector *pMV = m_cur_mb.MVs[ListNum]->MotionVectors;
    H264DecoderMotionVector *pMVd = m_cur_mb.MVs[ListNum + 2]->MotionVectors;
    Ipp8s *pRIx = m_cur_mb.RefIdxs[ListNum]->RefIdxs;

    H264DecoderMotionVector mv;
    H264DecoderMotionVector mvd;
    Ipp32s mvpx, mvpy;
#ifdef __ICL
    __assume_aligned(pMV, 16);
    __assume_aligned(pMVd, 16);
#endif
    if(pCodMVd[0] == CodNone)
    {
        memset(&pMV[0],0,8*sizeof(H264DecoderMotionVector));
    }
    else
    {
        ComputeMotionVectorPredictors( (Ipp8u) ListNum,
                                        pRIx[0],
                                        0, &mvpx, &mvpy);

        mvd = pMVd[0];
        mv.mvx  = (Ipp16s) (mvpx + (Ipp32s) mvd.mvx);
        mv.mvy  = (Ipp16s) (mvpy + (Ipp32s) mvd.mvy);

        if (mv.mvy > m_MVDistortion[ListNum])
            m_MVDistortion[ListNum] = mv.mvy;

        for (k = 0; k < 8; k ++)
        {
            pMV[k].mvx  = mv.mvx;
            pMV[k].mvy  = mv.mvy;

        } // for k
    }

    if(pCodMVd[8] == CodNone)
    {
        memset(&pMV[8],0,8*sizeof(H264DecoderMotionVector));
    }
    else
    {
        ComputeMotionVectorPredictors( (Ipp8u) ListNum,
                                        pRIx[8],
                                        1, &mvpx, &mvpy);

        mvd = pMVd[8];
        mv.mvx  = (Ipp16s) (mvpx + (Ipp32s) mvd.mvx);
        mv.mvy  = (Ipp16s) (mvpy + (Ipp32s) mvd.mvy);

        if (mv.mvy > m_MVDistortion[ListNum])
            m_MVDistortion[ListNum] = mv.mvy;

        for (k = 8; k < 16; k ++)
        {
            pMV[k].mvx  = mv.mvx;
            pMV[k].mvy  = mv.mvy;

        } // for k
    }

} // void H264SegmentDecoderMultiThreaded::ReconstructMVs16x8(const Ipp8u *pCodMVd,

void H264SegmentDecoderMultiThreaded::GetMVD4x4_8x16_CABAC(const Ipp8u *pCodMVd,
                                                             Ipp32u ListNum)
{
    Ipp32u k;

    H264DecoderMotionVector *pMVd = m_cur_mb.MVs[ListNum + 2]->MotionVectors;

    H264DecoderMotionVector mvd;
#ifdef __ICL
    __assume_aligned(pMVd, 16);
#endif
    if(pCodMVd[0] == CodNone)
    {
        pMVd[0].mvx = pMVd[0].mvy = 0;
        pMVd[1].mvx = pMVd[1].mvy = 0;
    }
    else
    {
        mvd = GetSE_MVD_CABAC(ListNum, 0);

        for (k = 0; k < 2; k ++)
        {
            pMVd[k].mvx = mvd.mvx;
            pMVd[k].mvy = mvd.mvy;

        } // for k
    }

    if(pCodMVd[2] == CodNone)
    {
        pMVd[2].mvx = pMVd[2].mvy = 0;
        pMVd[3].mvx = pMVd[3].mvy = 0;
    }
    else
    {
        mvd = GetSE_MVD_CABAC(ListNum, 2);

        for (k = 2; k < 4; k ++)
        {
            pMVd[k].mvx = mvd.mvx;
            pMVd[k].mvy = mvd.mvy;

        } // for k
    }
    memcpy(&pMVd[4], &pMVd[0], 4*sizeof(H264DecoderMotionVector));
    memcpy(&pMVd[8], &pMVd[0], 4*sizeof(H264DecoderMotionVector));
    memcpy(&pMVd[12], &pMVd[0], 4*sizeof(H264DecoderMotionVector));

} // void H264SegmentDecoderMultiThreaded::GetMVD4x4_8x16_CABAC(const Ipp8u *pCodMVd,

void H264SegmentDecoderMultiThreaded::ReconstructMotionVectors8x16(const Ipp8u *pCodMVd,
                                                                     Ipp32u ListNum)
{
    Ipp32u k;

    H264DecoderMotionVector *pMV = m_cur_mb.MVs[ListNum]->MotionVectors;
    H264DecoderMotionVector *pMVd = m_cur_mb.MVs[ListNum + 2]->MotionVectors;
    Ipp8s *pRIx = m_cur_mb.RefIdxs[ListNum]->RefIdxs;

    H264DecoderMotionVector mv;
    H264DecoderMotionVector mvd;
    Ipp32s mvpx, mvpy;
#ifdef __ICL
    __assume_aligned(pMV, 16);
    __assume_aligned(pMVd, 16);
#endif
    if(pCodMVd[0] == CodNone)
    {
        pMV[0].mvx = pMV[0].mvy = 0;
        pMV[1].mvx = pMV[1].mvy = 0;
    }
    else
    {
        ComputeMotionVectorPredictors( (Ipp8u) ListNum,
                                        pRIx[0],
                                        0, &mvpx, &mvpy);

        mvd = pMVd[0];
        mv.mvx  = (Ipp16s) (mvpx + (Ipp32s) mvd.mvx);
        mv.mvy  = (Ipp16s) (mvpy + (Ipp32s) mvd.mvy);

        if (mv.mvy > m_MVDistortion[ListNum])
            m_MVDistortion[ListNum] = mv.mvy;

        for (k = 0; k < 2; k ++)
        {
            pMV[k].mvx  = mv.mvx;
            pMV[k].mvy  = mv.mvy;

        } // for k
    }

    if(pCodMVd[2] == CodNone)
    {
        pMV[2].mvx = pMV[2].mvy = 0;
        pMV[3].mvx = pMV[3].mvy = 0;
    }
    else
    {
        ComputeMotionVectorPredictors( (Ipp8u) ListNum,
                                        pRIx[2],
                                        1, &mvpx, &mvpy);

        mvd = pMVd[2];
        mv.mvx  = (Ipp16s) (mvpx + (Ipp32s) mvd.mvx);
        mv.mvy  = (Ipp16s) (mvpy + (Ipp32s) mvd.mvy);

        if (mv.mvy > m_MVDistortion[ListNum])
            m_MVDistortion[ListNum] = mv.mvy;

        for (k = 2; k < 4; k ++)
        {
            pMV[k].mvx  = mv.mvx;
            pMV[k].mvy  = mv.mvy;

        } // for k
    }
    memcpy(&pMV[4], &pMV[0], 4*sizeof(H264DecoderMotionVector));
    memcpy(&pMV[8], &pMV[0], 4*sizeof(H264DecoderMotionVector));
    memcpy(&pMV[12], &pMV[0], 4*sizeof(H264DecoderMotionVector));

} // void Status H264SegmentDecoderMultiThreaded::ReconstructMotionVectors8x16(const Ipp8u* pCodMVd,

bool H264SegmentDecoderMultiThreaded::DecodeSkipMotionVectors(void)
{
    Ipp8s *RefIndex = m_cur_mb.RefIdxs[0]->RefIdxs;

    memset(RefIndex, 0, sizeof(H264DecoderMacroblockRefIdxs));

    return true;

} // bool H264SegmentDecoderMultiThreaded::DecodeSkipMotionVectors(void)

void H264SegmentDecoderMultiThreaded::ReconstructSkipMotionVectors(void)
{
    // check "zero motion vectors" condition
    H264DecoderBlockLocation mbAddrA, mbAddrB;

    // select neighbours
    mbAddrA = m_cur_mb.CurrentBlockNeighbours.mbs_left[0];
    mbAddrB = m_cur_mb.CurrentBlockNeighbours.mb_above;

    if ((0 <= mbAddrA.mb_num) &&
        (0 <= mbAddrB.mb_num))
    {
        H264DecoderMotionVector mvA, mvB;
        Ipp32s refIdxA, refIdxB;

        // select motion vectors & reference indexes
        mvA = m_gmbinfo->MV[0][mbAddrA.mb_num].MotionVectors[mbAddrA.block_num];
        mvB = m_gmbinfo->MV[0][mbAddrB.mb_num].MotionVectors[mbAddrB.block_num];
        refIdxA = m_gmbinfo->RefIdxs[0][mbAddrA.mb_num].RefIdxs[mbAddrA.block_num];
        refIdxB = m_gmbinfo->RefIdxs[0][mbAddrB.mb_num].RefIdxs[mbAddrB.block_num];

        // adjust vectors & reference in the MBAFF case
        if (m_pSliceHeader->MbaffFrameFlag)
        {
            Ipp32s iCurStruct = pGetMBFieldDecodingFlag(m_cur_mb.GlobalMacroblockInfo);
            Ipp32s iNeighbourStruct;

            iNeighbourStruct = GetMBFieldDecodingFlag(m_gmbinfo->mbs[mbAddrA.mb_num]);
            mvA.mvy <<= iNeighbourStruct;
            refIdxA <<= (1 - iNeighbourStruct);

            iNeighbourStruct = GetMBFieldDecodingFlag(m_gmbinfo->mbs[mbAddrB.mb_num]);
            mvB.mvy <<= iNeighbourStruct;
            refIdxB <<= (1 - iNeighbourStruct);

            if (iCurStruct)
            {
                mvA.mvy /= 2;
                mvB.mvy /= 2;
            }
            else
            {
                refIdxA >>= 1;
                refIdxB >>= 1;
            }
        }

        // check condition
        if ((mvA.mvx | mvA.mvy | refIdxA) &&
            (mvB.mvx | mvB.mvy | refIdxB))
        {
            H264DecoderMotionVector mvPred;
            H264DecoderBlockLocation mbAddrC;
            Ipp32s i;

            mbAddrC = m_cur_mb.CurrentBlockNeighbours.mb_above_right;
            if (0 == m_pSliceHeader->MbaffFrameFlag)
                ReconstructMVPredictorExternalBlock(0, mbAddrC, &mvPred);
            else
                ReconstructMVPredictorExternalBlockMBAFF(0, mbAddrC, &mvPred);

            if (mvPred.mvy > m_MVDistortion[0])
                m_MVDistortion[0] = mvPred.mvy;

            // fill motion vectors
            for (i = 0; i < 16; i += 1)
                m_cur_mb.MVs[0]->MotionVectors[i] = mvPred;

            return;
        }
    }

    // in oposite case we clean motion vectors
    memset((void *) m_cur_mb.MVs[0], 0, sizeof(H264DecoderMacroblockMVs));
} // void H264SegmentDecoderMultiThreaded::ReconstructSkipMotionVectors(void)

inline
Ipp32s CreateMVFromCode(Ipp32s code)
{
    Ipp32s val, sign;

    val = (code + 1) >> 1;
    sign = (code & 1) - 1;
    val ^= sign;
    val -= sign;

    return val;

} // Ipp32s CreateMVFromCode(Ipp32s code)

#define DecodeMVDelta_CAVLC(list_num, block_num) \
{ \
    H264DecoderMotionVector mvD; \
    mvD.mvx = (Ipp16s) CreateMVFromCode(m_pBitStream->GetVLCElement(false)); \
    mvD.mvy = (Ipp16s) CreateMVFromCode(m_pBitStream->GetVLCElement(false)); \
    m_cur_mb.MVs[list_num + MV_DELTAS_OFFSET]->MotionVectors[block_num] = mvD; \
}

void H264SegmentDecoderMultiThreaded::DecodeMotionVectorsPSlice_CAVLC(void)
{
    if ((m_cur_mb.LocalMacroblockInfo->sbdir[0] > D_DIR_BIDIR)
        && (m_cur_mb.GlobalMacroblockInfo->mbtype - MBTYPE_FORWARD >= 0))
    {
        return;
    }

    Ipp32s mbtype = m_cur_mb.GlobalMacroblockInfo->mbtype;

    switch (mbtype)
    {
    case MBTYPE_FORWARD:
        {
            // decode reference indexes
            {
                Ipp32s num_ref_idx_l0_active = m_pSliceHeader->num_ref_idx_l0_active <<
                                               pGetMBFieldDecodingFlag(m_cur_mb.GlobalMacroblockInfo);
                Ipp32s refIdx = 0;

                if (2 == num_ref_idx_l0_active)

                    refIdx = m_pBitStream->Get1Bit() ^ 1;
                else if (2 < num_ref_idx_l0_active)
                    refIdx = m_pBitStream->GetVLCElement(false);
                memset(m_cur_mb.RefIdxs[0]->RefIdxs, refIdx, sizeof(Ipp8u) * 16);
            }

            // decode motion vector deltas
            DecodeMVDelta_CAVLC(0, 0);
        }
        break;

    case MBTYPE_INTER_16x8:
        {
            // decode reference indexes
            {
                Ipp32s num_ref_idx_l0_active = m_pSliceHeader->num_ref_idx_l0_active <<
                                               pGetMBFieldDecodingFlag(m_cur_mb.GlobalMacroblockInfo);
                Ipp32s refIdx[2] = {0, 0};

                if (2 == num_ref_idx_l0_active)
                {
                    refIdx[0] = m_pBitStream->Get1Bit() ^ 1;
                    refIdx[1] = m_pBitStream->Get1Bit() ^ 1;
                }