umc_h264_segment_decoder_decode_mb_cabac.cpp

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

/*
//
//              INTEL CORPORATION PROPRIETARY INFORMATION
//  This software is supplied under the terms of a license  agreement or
//  nondisclosure agreement with Intel Corporation and may not be copied
//  or disclosed except in  accordance  with the terms of that agreement.
//        Copyright (c) 2003-2007 Intel Corporation. All Rights Reserved.
//
//
*/
#include "umc_defs.h"
#if defined (UMC_ENABLE_H264_VIDEO_DECODER)

#include "umc_h264_segment_decoder.h"
#include "umc_h264_dec.h"
#include "umc_h264_bitstream_templates.h"
#include "umc_h264_bitstream_inlines.h"
#include "umc_h264_dec_internal_cabac.h"
#include "vm_debug.h"

namespace UMC
{

const
Ipp8u pCodFBD[5][4] =
{
//fwd
{CodInBS, CodNone, CodInBS, CodNone},
//bwd
{CodNone, CodInBS, CodNone, CodInBS},
//nothing
{CodNone, CodInBS, CodNone, CodInBS},
//nothing
{CodNone, CodInBS, CodNone, CodInBS},
//both
{CodInBS, CodInBS, CodInBS, CodInBS},
};

const
Ipp8u pCodTemplate[16] =
{
    CodNone, CodLeft, CodLeft, CodLeft,    CodAbov, CodLeft, CodLeft, CodLeft,
    CodAbov, CodLeft, CodLeft, CodLeft,    CodAbov, CodLeft, CodLeft, CodLeft
};

const
Ipp32u sb_x[4][16] =
{
    {
        0, 1, 0, 1,
        0, 1, 0, 1,
        0, 1, 0, 1,
        0, 1, 0, 1,
    },
    {
        0, 1, 0, 1,
        0, 1, 0, 1,
        0, 1, 0, 1,
        0, 1, 0, 1,
    },
    {
        0, 1, 0, 1,
        0, 1, 0, 1,
        0, 1, 0, 1,
        0, 1, 0, 1,
    },
    {
        0, 1, 0, 1,
        2, 3, 2, 3,
        0, 1, 0, 1,
        2, 3, 2, 3
    }
};

const
Ipp32u sb_y[4][16] =
{
    {
        0, 0, 1, 1,
        0, 0, 1, 1,
        0, 0, 1, 1,
        0, 0, 1, 1,
    },
    {
        0, 0, 1, 1,
        0, 0, 1, 1,
        0, 0, 1, 1,
        0, 0, 1, 1,
    },
    {
        0, 0, 1, 1,
        2, 2, 3, 3,
        0, 0, 1, 1,
        2, 2, 3, 3
    },
    {
        0, 0, 1, 1,
        0, 0, 1, 1,
        2, 2, 3, 3,
        2, 2, 3, 3
    }
};

const
Ipp32s sign_mask[2] =
{
    0, -1
};

// ---------------------------------------------------------------------------
//  H264SegmentDecoder::GetRefIdx4x4_CABAC()
//    get ref_idx and update info for all 4x4 blocks
// ---------------------------------------------------------------------------

void H264SegmentDecoder::GetRefIdx4x4_CABAC(const Ipp32u nActive,
                                              const Ipp8u* pBlkIdx,
                                              const Ipp8u* pCodRIx,
                                              Ipp32u ListNum)
{
    Ipp32u i, j, k;

    Ipp8s *pRIx = m_cur_mb.RefIdxs[ListNum]->RefIdxs;

    if (nActive > 1)
    {
        for (i = 0; i < 16; i ++)
        {
            j = pBlkIdx[i];
            k = (j >> 2) * 4+ (j & 3);

            switch (pCodRIx[j])
            {
            case CodNone:
                pRIx[k] = -1;
                break;

            case CodInBS:
                Ipp32s refIdx;
                refIdx = (Ipp32s) GetSE_RefIdx_CABAC(ListNum,k);
                if (refIdx >= (Ipp8s) nActive || refIdx < 0)
                {
                    throw h264_exception(UMC_ERR_INVALID_STREAM);
                }
                pRIx[k] = (Ipp8s) refIdx;
                break;

            case CodLeft:
                pRIx[k] = pRIx[k - 1];
                break;

            case CodAbov:
                pRIx[k] = pRIx[k - 4];
                break;

            case CodSkip:
                break;
            }
        }    // for i
    }
    else
    {
        for (i = 0; i < 16; i ++)
        {
            j = pBlkIdx[i];
            k = (j >> 2) * 4+ (j & 3);

            switch (pCodRIx[j])
            {
            case CodNone:
                pRIx[k] = -1;
                break;

            case CodInBS:
                pRIx[k] = 0;
                break;

            case CodLeft:
                pRIx[k] = pRIx[k - 1];
                break;

            case CodAbov:
                pRIx[k] = pRIx[k - 4];
                break;

            case CodSkip:
                break;
            }
        }    // for i
    }
} // void H264SegmentDecoder::GetRefIdx4x4_CABAC(const Ipp32u nActive,


// ---------------------------------------------------------------------------
//  H264SegmentDecoder::GetRefIdx4x4_CABAC()
//    get ref_idx and update info for all 4x4 blocks
// ---------------------------------------------------------------------------

void H264SegmentDecoder::GetRefIdx4x4_CABAC(const Ipp32u nActive,
                                              const Ipp8u pCodRIx,
                                              Ipp32u ListNum)
{
    Ipp32u k;

    Ipp8s *pRIx = m_cur_mb.RefIdxs[ListNum]->RefIdxs;

#ifdef __ICL
    __assume_aligned(pRIx, 16);
#endif
    if(pCodRIx == CodNone)
    {
        for (k = 0; k < 16; k ++)
            pRIx[k] = -1;
    }
    else if (nActive > 1)
    {
        Ipp32s refIdx;
        refIdx = (Ipp32s) GetSE_RefIdx_CABAC(ListNum,0);
        if (refIdx >= (Ipp8s) nActive || refIdx < 0)
        {
            throw h264_exception(UMC_ERR_INVALID_STREAM);
        }
        memset(pRIx, refIdx, 16);
    }
    else
    {
        memset(pRIx, 0, 16);
    }

} // void H264SegmentDecoder::GetRefIdx4x4_CABAC(const Ipp32u nActive,

void H264SegmentDecoder::GetRefIdx4x4_16x8_CABAC(const Ipp32u nActive,
                                                   const Ipp8u* pCodRIx,
                                                   Ipp32u ListNum)
{
    Ipp8s *pRIx = m_cur_mb.RefIdxs[ListNum]->RefIdxs;

#ifdef __ICL
    __assume_aligned(pRIx, 8);
#endif
    if(pCodRIx[0] == CodNone)
    {
        memset(pRIx, -1, 8);
    }
    else if (nActive > 1)
    {
        Ipp32s refIdx;
        refIdx = (Ipp32s) GetSE_RefIdx_CABAC(ListNum,0);
        if (refIdx >= (Ipp8s) nActive || refIdx < 0)
        {
            throw h264_exception(UMC_ERR_INVALID_STREAM);
        }
        memset(pRIx, refIdx, 8);
   }
    else
    {
        memset(pRIx, 0, 8);
    }

    if(pCodRIx[8] == CodNone)
    {
        memset(&pRIx[8], -1, 8);
    }
    else if (nActive > 1)
    {
        Ipp32s refIdx;
        refIdx = (Ipp32s) GetSE_RefIdx_CABAC(ListNum,8);
        if (refIdx >= (Ipp8s) nActive || refIdx < 0)
        {
            throw h264_exception(UMC_ERR_INVALID_STREAM);
        }
        memset(&pRIx[8], refIdx, 8);
   }
    else
    {
        memset(&pRIx[8], 0, 8);
    }
} // void H264SegmentDecoder::GetRefIdx4x4_CABAC(const Ipp32u nActive,

void H264SegmentDecoder::GetRefIdx4x4_8x16_CABAC(const Ipp32u nActive,
                                                   const Ipp8u* pCodRIx,
                                                   Ipp32u ListNum)
{
    Ipp8s *pRIx = m_cur_mb.RefIdxs[ListNum]->RefIdxs;

#ifdef __ICL
    __assume_aligned(pRIx, 16);
#endif
    if(pCodRIx[0] == CodNone)
    {
        pRIx[0] = pRIx[1] = -1;
    }
    else if (nActive > 1)
    {
        Ipp32s refIdx;
        refIdx = (Ipp32s) GetSE_RefIdx_CABAC(ListNum,0);
        if (refIdx >= (Ipp8s) nActive || refIdx < 0)
        {
            throw h264_exception(UMC_ERR_INVALID_STREAM);
        }
        pRIx[0] = pRIx[1] = (Ipp8s) refIdx;
   }
    else
    {
        pRIx[0] = pRIx[1] = 0;
    }

    if(pCodRIx[2] == CodNone)
    {
        pRIx[2] = pRIx[3] = -1;
    }
    else if (nActive > 1)
    {
        Ipp32s refIdx;
        refIdx = (Ipp32s) GetSE_RefIdx_CABAC(ListNum,2);
        if (refIdx >= (Ipp8s) nActive || refIdx < 0)
        {
            throw h264_exception(UMC_ERR_INVALID_STREAM);
        }
        pRIx[2] = pRIx[3] = (Ipp8s) refIdx;
   }
    else
    {
        pRIx[2] = pRIx[3] = 0;
    }
#ifdef __ICL
    memcpy(&pRIx[4], &pRIx[0], 4);
    memcpy(&pRIx[8], &pRIx[0], 4);
    memcpy(&pRIx[12],&pRIx[0], 4);
#else
    *(Ipp32s*)&pRIx[4] = *(Ipp32s*)&pRIx[0];
    *(Ipp32s*)&pRIx[8] = *(Ipp32s*)&pRIx[0];