umc_vc1_dec_seq.h

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) 2004-2007 Intel Corporation. All Rights Reserved.
//
//
//          VC-1 (VC1) decoder, Coded block pattern tables
//
*/

#include "umc_defs.h"

#if defined (UMC_ENABLE_VC1_VIDEO_DECODER)

#ifndef __UMC_VC1_DEC_SEQ_H__
#define __UMC_VC1_DEC_SEQ_H__

#include "umc_vc1_common_defs.h"
#include "umc_vc1_dec_task.h"

//#ifdef DXVA_SIM
//#include "vc1_dxva2_struct.h"
//#endif

Ipp32u          DecodeBegin                           (VC1Context* pContext,
                                                       Ipp32u stream_type);

//sequence layer
VC1Status SequenceLayer                               (VC1Context* pContext);
Ipp32s InitTables                                     (VC1Context* pContext);
Ipp32s InitCommonTables                               (VC1Context* pContext);
Ipp32s InitInterlacedTables                           (VC1Context* pContext);

void FreeTables                                       (VC1Context* pContext);


//picture layer
//Simple/main
VC1Status GetNextPicHeader                            (VC1Context* pContext);
VC1Status DecodePictureHeader                         (VC1Context* pContext);
//VC1Status SetDisplayIndex                             (VC1Context* pContext,VC1FrameBuffer*        pfrmBuff);
VC1Status Decode_PictureLayer                         (VC1Context* pContext);
VC1Status DecodeFrame                                 (VC1Context* pContext);

//Advanced
VC1Status DecodePictureHeader_Adv                     (VC1Context* pContext);
VC1Status GetNextPicHeader_Adv                        (VC1Context* pContext);


//for threading
void PrepareForNextFrame                         (VC1Context*pContext);

//I,P,B headers
VC1Status DecodePicHeader                             (VC1Context* pContext);

VC1Status Decode_FieldPictureLayer_Adv                (VC1Context* pContext);

VC1Status DecodePictHeaderParams_InterlaceFieldPicture_Adv (VC1Context* pContext);
VC1Status Decode_FirstField_Adv                        (VC1Context* pContext);
VC1Status Decode_SecondField_Adv                       (VC1Context* pContext);
VC1Status DecodeSkippicture                       (VC1Context* pContext);

void      ChooseDCTable                               (VC1Context* pContext,
                                                       Ipp32s transDCtableIndex);

void      ChooseACTable                               (VC1PictureLayerHeader* picLayerHeader,
                                                       Ipp32s transACtableIndex1,
                                                       Ipp32s transACtableIndex2);

void   ChooseTTMB_TTBLK_SBP                          (VC1Context* pContext);

void ChooseMBModeInterlaceFrame                       (VC1Context* pContext,
                                                       Ipp32u MV4SWITCH,
                                                       Ipp32u MBMODETAB);
void ChooseMBModeInterlaceField                       (VC1Context* pContext,
                                                       Ipp32s MBMODETAB);
void ChoosePredScaleValuePPictbl                      (VC1PictureLayerHeader* picLayerHeader);
void ChoosePredScaleValueBPictbl                      (VC1PictureLayerHeader* picLayerHeader);
Ipp8u GetTTBLK                                        (VC1Context* pContext,
                                                       Ipp32s blk_num);
// Simple/Main
VC1Status DecodePictureLayer_ProgressiveIpicture            (VC1Context* pContext);
// Advanced
VC1Status DecodePictHeaderParams_ProgressiveIpicture_Adv    (VC1Context* pContext);
VC1Status DecodePictHeaderParams_InterlaceIpicture_Adv      (VC1Context* pContext);
VC1Status DecodeFieldHeaderParams_InterlaceFieldIpicture_Adv (VC1Context* pContext);
VC1Status Decode_InterlaceFieldIpicture_Adv                 (VC1Context* pContext);

// Simple/Main
VC1Status DecodePictureLayer_ProgressivePpicture            (VC1Context* pContext);
// Advanced
VC1Status DecodePictHeaderParams_ProgressivePpicture_Adv    (VC1Context* pContext);
VC1Status DecodePictHeaderParams_InterlacePpicture_Adv      (VC1Context* pContext);
VC1Status DecodeFieldHeaderParams_InterlaceFieldPpicture_Adv (VC1Context* pContext);
VC1Status Decode_InterlaceFieldPpicture_Adv                 (VC1Context* pContext);

// Simple/Main
VC1Status DecodePictureLayer_ProgressiveBpicture            (VC1Context* pContext);
// Advanced
VC1Status DecodePictHeaderParams_ProgressiveBpicture_Adv    (VC1Context* pContext);
VC1Status DecodePictHeaderParams_InterlaceBpicture_Adv      (VC1Context* pContext);
VC1Status Decode_InterlaceFieldBpicture_Adv                 (VC1Context* pContext);
VC1Status DecodeFieldHeaderParams_InterlaceFieldBpicture_Adv(VC1Context* pContext);

VC1Status MVRangeDecode                                (VC1Context* pContext);
VC1Status DMVRangeDecode                               (VC1Context* pContext);

//I picture MB Layer
VC1Status MBLayer_ProgressiveIpicture                  (VC1Context* pContext);
VC1Status MBLayer_IntraField_InterlasedIpicture        (VC1Context* pContext);
VC1Status MBLayer_ProgressiveIpicture_Adv              (VC1Context* pContext);
VC1Status MBLayer_Frame_InterlaceIpicture              (VC1Context* pContext);
VC1Status MBLayer_Field_InterlaceIpicture              (VC1Context* pContext);

//P picture MB Layer
VC1Status MBLayer_ProgressivePpicture                  (VC1Context* pContext);
VC1Status MBLayer_Frame_InterlacedPpicture             (VC1Context* pContext);
VC1Status MBLayer_Field_InterlacedPpicture              (VC1Context* pContext);
VC1Status MBLayer_ProgressivePpicture_Adv              (VC1Context* pContext);

//B picture MB Layer
VC1Status MBLayer_ProgressiveBpicture                  (VC1Context* pContext);
VC1Status MBLayer_Frame_InterlacedBpicture             (VC1Context* pContext);
VC1Status MBLayer_Field_IntrlacedBpicture              (VC1Context* pContext);
VC1Status MBLayer_ProgressiveBpicture_Adv              (VC1Context* pContext);
VC1Status MBLayer_Field_InterlacedBpicture             (VC1Context* pContext);

void GetIntraDCPredictors                              (VC1Context* pContext);
void GetPDCPredictors                                  (VC1Context* pContext);
void GetIntraScaleDCPredictors                         (VC1Context* pContext);
void GetPScaleDCPredictors                             (VC1Context* pContext);
Ipp32s DecodeSymbol                                    (Ipp32u** pbs,
                                                        Ipp32s* bitOffset,
                                                        Ipp16s* run,
                                                        Ipp16s* level,
                                                        Ipp32s* last_flag,
                                                        const IppiACDecodeSet_VC1 * decodeSet,
                                                        IppiEscInfo_VC1* EscInfo);

IppStatus DecodeBlockACIntra_VC1                        (IppiBitstream* pBitstream,
                                                         Ipp16s* pDst,
                                                         const  Ipp8u* pZigzagTbl,
                                                         const IppiACDecodeSet_VC1 * pDecodeSet,
                                                         IppiEscInfo_VC1* pEscInfo);

#pragma warning(disable : 4100)
// interfaces should be tha same
IppStatus DecodeBlockInter8x8_VC1                       (IppiBitstream* pBitstream,
                                                         Ipp16s* pDst,
                                                         const  Ipp8u* pZigzagTbl,
                                                         const IppiACDecodeSet_VC1 * pDecodeSet,
                                                         IppiEscInfo_VC1* pEscInfo,
                                                         Ipp32s subBlockPattern);

IppStatus DecodeBlockInter4x8_VC1                       (IppiBitstream* pBitstream,
                                                         Ipp16s* pDst,
                                                         const  Ipp8u* pZigzagTbl,
                                                         const IppiACDecodeSet_VC1 * pDecodeSet,
                                                         IppiEscInfo_VC1* pEscInfo,
                                                         Ipp32s subBlockPattern);

IppStatus DecodeBlockInter8x4_VC1                       (IppiBitstream* pBitstream,
                                                         Ipp16s* pDst,
                                                         const  Ipp8u* pZigzagTbl,
                                                         const IppiACDecodeSet_VC1 * pDecodeSet,
                                                         IppiEscInfo_VC1* pEscInfo,
                                                         Ipp32s subBlockPattern);

IppStatus DecodeBlockInter4x4_VC1                       (IppiBitstream* pBitstream,
                                                         Ipp16s* pDst,
                                                         const  Ipp8u* pZigzagTbl,
                                                         const IppiACDecodeSet_VC1 * pDecodeSet,
                                                         IppiEscInfo_VC1* pEscInfo,
                                                         Ipp32s subBlockPattern);

inline
Ipp32s CalculateLeftTopRightPositionFlag (VC1SingletonMB* sMB)
{
    Ipp32s LeftTopRightPositionFlag = VC1_COMMON_MB;
    //Top position
    //macroblock is on the first column
    //#0 and #1 blocks have top border
    if(sMB->slice_currMBYpos == 0)
    {
        LeftTopRightPositionFlag |= VC1_TOP_MB;
    }
    //Left position
    //macroblock is on the first row
    //#0 and #2 blocks have left border
    if(sMB->m_currMBXpos == 0)
    {
        LeftTopRightPositionFlag |= VC1_LEFT_MB;
    }
    else if (sMB->m_currMBXpos == sMB->widthMB - 1)
    {
        LeftTopRightPositionFlag |= VC1_RIGHT_MB;
    }
    return LeftTopRightPositionFlag;
}
void CalculateIntraFlag                                (VC1Context* pContext);


//Block layer
VC1Status BLKLayer_Intra_Luma                          (VC1Context* pContext,
                                                        Ipp32s blk_num,
                                                        Ipp32u bias,
                                                        Ipp32u ACPRED);
VC1Status BLKLayer_Intra_Chroma                        (VC1Context* pContext,
                                                        Ipp32s blk_num,
                                                        Ipp32u bias,
                                                        Ipp32u ACPRED);
VC1Status BLKLayer_Inter_Luma                          (VC1Context* pContext,
                                                        Ipp32s blk_num);
VC1Status BLKLayer_Inter_Chroma                        (VC1Context* pContext,
                                                        Ipp32s blk_num);

VC1Status BLKLayer_Intra_Luma_Adv                     (VC1Context* pContext,
                                                       Ipp32s blk_num,
                                                       Ipp32u ACPRED);
VC1Status BLKLayer_Intra_Chroma_Adv                   (VC1Context* pContext,
                                                       Ipp32s blk_num,
                                                       Ipp32u ACPRED);
VC1Status BLKLayer_Inter_Luma_Adv                     (VC1Context* pContext,
                                                       Ipp32s blk_num);
VC1Status BLKLayer_Inter_Chroma_Adv                   (VC1Context* pContext,
                                                       Ipp32s blk_num);

Ipp32s CalculateCBP                                    (VC1MB* pCurrMB,
                                                        Ipp32u decoded_cbpy,
                                                        Ipp32s width);
Ipp32s CalculateDC                                     (VC1Context* pContext,
                                                        Ipp32s DCDiff, Ipp32s blk_num);

//DeQuantization
VC1Status VOPDQuant            (VC1Context* pContext);
VC1Status CalculatePQuant      (VC1Context* pContext);

//Bitplane decoding
void  DecodeBitplane        (VC1Context* pContext, VC1Bitplane* pBitplane, Ipp32s rowMB, Ipp32s colMB, Ipp32s offset);


Ipp16u DecodeMVDiff                      (VC1Context* pContext,Ipp32s hpelfl,
                                          Ipp16s *dmv_x, Ipp16s *dmv_y);

void DecodeMVDiff_Adv                    (VC1Context* pContext,Ipp16s* pdmv_x, Ipp16s* pdmv_y);
Ipp8u DecodeMVDiff_TwoReferenceField_Adv  (VC1Context* pContext,
                                           Ipp16s* pdmv_x,
                                           Ipp16s* pdmv_y);

void Progressive1MVPrediction                               (VC1Context* pContext);
void Progressive4MVPrediction                               (VC1Context* pContext);
void Field1MVPrediction                                     (VC1Context* pContext);
void Field4MVPrediction                                     (VC1Context* pContext);

inline void ApplyMVPrediction  ( VC1Context* pContext,
                                 Ipp32s blk_num,
                                 Ipp16s* pMVx, Ipp16s* pMVy,
                                 Ipp16s dmv_x, Ipp16s dmv_y,
                                 Ipp32s Backwards)
{
    const VC1MVRange *pMVRange = pContext->m_picLayerHeader->m_pCurrMVRangetbl;
    Ipp16u RangeX, RangeY, YBias=0;
    Ipp32s Count;
    VC1MB *pMB = pContext->m_pCurrMB;
    Ipp16s MVx, MVy;
    RangeX = pMVRange->r_x;
    RangeY = pMVRange->r_y;

//#ifdef VC1_DEBUG_ON
//    VM_Debug::GetInstance().vm_debug_frame(-1,VC1_MV,VM_STRING("DMV_X  = %d, DMV_Y  = %d, PredictorX = %d, PredictorY = %d\n"),
//        dmv_x, dmv_y, *pMVx,*pMVy);
//#endif

    dmv_x = dmv_x + *pMVx;
    dmv_y = dmv_y + *pMVy;

//#ifdef VC1_DEBUG_ON
//    VM_Debug::GetInstance().vm_debug_frame(-1,VC1_MV,VM_STRING("DMV_X  = %d, DMV_Y  = %d, RangeX = %d, RangeY = %d\n"),
//        dmv_x, dmv_y, RangeX,RangeY);
//#endif

    // (dmv_x + predictor_x) smod range_x
    //MVx = ((DMV_X + RangeX) & (2 * RangeX - 1)) - RangeX;
    MVx = ((dmv_x + RangeX) & ((RangeX << 1) - 1)) - RangeX;

    // (dmv_y + predictor_y) smod range_y
    //MVy = ((DMV_Y + RangeY - YBias) & (2 * RangeY - 1)) - RangeY + YBias;
    MVy = ((dmv_y + RangeY - YBias) & ( (RangeY <<1) - 1)) - RangeY + YBias;

    if((pMB->mbType&0x03) == VC1_MB_1MV_INTER)
    {
        for(Count = 0; Count < 4; Count++)