umc_vc1_enc_mb.h

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

        return ((MBPattern &(1 << (5 - blk)))!=0);
   }
};

struct MBEdges
{
    unsigned YExHor:4;
    unsigned YExVer:4;
    unsigned YInHor:4;
    unsigned YInVer:4;

    unsigned YAdUpp:4;
    unsigned YAdBot:4;
    unsigned YAdLef:4;
    unsigned YAdRig:4;

    unsigned UExHor:4;
    unsigned UExVer:4;
    unsigned UAdHor:4;
    unsigned UAdVer:4;

    unsigned VExHor:4;
    unsigned VExVer:4;
    unsigned VAdHor:4;
    unsigned VAdVer:4;
};
class VC1EncoderMBInfo
{

private:

    bool            m_bIntra;
    Ipp8u           m_uiMBPattern;


    //for P frames

    sCoordinate     m_MV [2][6];
    Ipp8u           m_uiIntraPattern;
    Ipp32u          m_uiBlocksPattern;
    MBEdges         m_sMBEdges;


public:
    VC1EncoderMBInfo():
        m_bIntra (true),
        m_uiMBPattern(0),
        m_uiIntraPattern(0),
        m_uiBlocksPattern(0)
    {

        memset(m_MV[0],       0, sizeof(sCoordinate)*6);
        memset(m_MV[1],       0, sizeof(sCoordinate)*6);

    }
    inline void SetEdgesIntra(bool top, bool left)
    {
        m_sMBEdges.YExHor = m_sMBEdges.UExHor = m_sMBEdges.VExHor = 0;
        m_sMBEdges.YExVer = m_sMBEdges.UExVer = m_sMBEdges.VExVer = 0;
        m_sMBEdges.YInHor = m_sMBEdges.YInVer =  0;

        m_sMBEdges.YAdUpp=m_sMBEdges.YAdBot=m_sMBEdges.YAdLef=m_sMBEdges.YAdRig=
        m_sMBEdges.UAdHor=m_sMBEdges.UAdVer=m_sMBEdges.VAdHor=m_sMBEdges.VAdVer = 0xff;

        if (top)
        {
            m_sMBEdges.YExHor = m_sMBEdges.UExHor = m_sMBEdges.VExHor = 0xff;
        }
        if (left)
        {
            m_sMBEdges.YExVer = m_sMBEdges.UExVer = m_sMBEdges.VExVer =  0xff;
        }
    }
    inline void SetInternalBlockEdge(Ipp8u YFlagUp, Ipp8u YFlagBot, Ipp8u UFlagH, Ipp8u VFlagH,
                                     Ipp8u YFlagL,  Ipp8u YFlagR,   Ipp8u UFlagV, Ipp8u VFlagV)
    {
        m_sMBEdges.YAdUpp = YFlagUp  & 0x0F;
        m_sMBEdges.YAdBot = YFlagBot & 0x0F;
        m_sMBEdges.UAdHor = UFlagH   & 0x0F;
        m_sMBEdges.VAdHor = VFlagH   & 0x0F;

        m_sMBEdges.YAdLef = YFlagL   & 0x0F;
        m_sMBEdges.YAdRig = YFlagR   & 0x0F;
        m_sMBEdges.UAdVer = UFlagV   & 0x0F;
        m_sMBEdges.VAdVer = VFlagV   & 0x0F;

    }
    inline void SetExternalEdgeVer(Ipp8u YFlag, Ipp8u UFlag, Ipp8u VFlag)
    {
        m_sMBEdges.YExVer = YFlag & 0x0F;
        m_sMBEdges.UExVer = UFlag & 0x0F;
        m_sMBEdges.VExVer = VFlag & 0x0F;
    }
    inline void SetExternalEdgeHor(Ipp8u YFlag, Ipp8u UFlag, Ipp8u VFlag)
    {
        m_sMBEdges.YExHor = YFlag & 0x0F;
        m_sMBEdges.UExHor = UFlag & 0x0F;
        m_sMBEdges.VExHor = VFlag & 0x0F;
    }
    inline void SetInternalEdge(Ipp8u YFlagV, Ipp8u YFlagH)
    {
        m_sMBEdges.YInVer = YFlagV & 0x0F;
        m_sMBEdges.YInHor = YFlagH & 0x0F;
    }
    inline Ipp32u GetLumaExHorEdge()
    {
        return m_sMBEdges.YExHor;
    }
    inline Ipp32u GetLumaExVerEdge()
    {
        return m_sMBEdges.YExVer;
    }
    inline Ipp32u GetLumaInHorEdge()
    {
        return m_sMBEdges.YInHor;
    }
    inline Ipp32u GetLumaInVerEdge()
    {
        return m_sMBEdges.YInVer;
    }
    inline Ipp32u GetLumaAdUppEdge()
    {
        return m_sMBEdges.YAdUpp;
    }
    inline Ipp32u GetLumaAdBotEdge()
    {
        return m_sMBEdges.YAdBot;
    }
    inline Ipp32u GetLumaAdLefEdge()
    {
        return m_sMBEdges.YAdLef;
    }
    inline Ipp32u GetLumaAdRigEdge()
    {
        return m_sMBEdges.YAdRig;
    }
    inline Ipp32u GetUExHorEdge()
    {
        return m_sMBEdges.UExHor;
    }
    inline Ipp32u GetVExHorEdge()
    {
        return m_sMBEdges.VExHor;
    }
    inline Ipp32u GetUExVerEdge()
    {
        return m_sMBEdges.UExVer;
    }
    inline Ipp32u GetVExVerEdge()
    {
        return m_sMBEdges.VExVer;
    }
    inline Ipp32u GetVAdVerEdge()
    {
        return m_sMBEdges.VAdVer;
    }
   inline Ipp32u GetUAdHorEdge()
    {
        return m_sMBEdges.UAdHor;
    }
    inline Ipp32u GetVAdHorEdge()
    {
        return m_sMBEdges.VAdHor;
    }
    inline Ipp32u GetUAdVerEdge()
    {
        return m_sMBEdges.UAdVer;
    }

    inline  void SetBlocksPattern(Ipp32u blocksPattern)
    {
        m_uiBlocksPattern = blocksPattern;
    }
    inline bool isCoded(Ipp32s blk, Ipp32s subblk)
    {
        return ((m_uiBlocksPattern & (1<<VC_ENC_PATTERN_POS(blk, subblk)))!=0);
    }

    inline void Init( bool intra)
    {
         m_bIntra =  intra;

         SetMVNULL();

         if (intra)
         {
            m_uiIntraPattern = VC1_ENC_PAT_MASK_MB;
         }
         else
         {
            m_uiIntraPattern = 0;
         }
    }
    inline bool isIntra()
    {
        return  (m_bIntra);
    }
    inline bool isIntra(Ipp32s i)
    {
        return  ((m_uiIntraPattern & (1<<i))!=0);
    }

    inline void SetMVNULL()
    {
        m_MV[0][0].x = m_MV[0][1].x = m_MV[0][2].x = m_MV[0][3].x = 0;
        m_MV[0][0].y = m_MV[0][1].y = m_MV[0][2].y = m_MV[0][3].y = 0;
        m_MV[1][0].x = m_MV[1][1].x = m_MV[1][2].x = m_MV[1][3].x = 0;
        m_MV[1][0].y = m_MV[1][1].y = m_MV[1][2].y = m_MV[1][3].y = 0;
    }
    inline void SetMV(sCoordinate mv, bool bForward=true)
    {
        m_MV[bForward][0].x = m_MV[bForward][1].x = m_MV[bForward][2].x = m_MV[bForward][3].x = mv.x;
        m_MV[bForward][0].y = m_MV[bForward][1].y = m_MV[bForward][2].y = m_MV[bForward][3].y = mv.y;
    }
    inline void SetMVChroma(sCoordinate mv, bool bForward=true)
    {
        m_MV[bForward][4].x = m_MV[bForward][5].x = mv.x;
        m_MV[bForward][4].y = m_MV[bForward][5].y = mv.y;
    }

    inline UMC::Status SetMV(sCoordinate mv, Ipp8u blockNum, bool bForward=true)
    {
        if (blockNum>=6)
            return UMC::UMC_ERR_FAILED;
        m_MV[bForward][blockNum].x =  mv.x;
        m_MV[bForward][blockNum].y =  mv.y;
        return UMC::UMC_OK;
    }

    inline UMC::Status GetMV(sCoordinate* mv, Ipp8u blockNum, bool bForward=true)
    {
        if (blockNum>=6)
            return 0;
        mv->x =  m_MV[bForward][blockNum].x ;
        mv->y =  m_MV[bForward][blockNum].y;
        return UMC::UMC_OK;
    }

    inline void        SetMBPattern(Ipp8u pattern)
    {
        m_uiMBPattern = pattern;
    }
    inline Ipp8u       GetPattern()
    {
        return m_uiMBPattern;
    }

};

struct VC1EncoderMB
{
    VC1EncoderMBData    * pData;
    VC1EncoderMBInfo    * pInfo;
};

class VC1EncoderMBs
{
private:
    VC1EncoderMBInfo ** m_MBInfo; // rows of macroblocks info
    VC1EncoderMBData ** m_MBData; // rows of macroblocks data
    Ipp8s               m_iCurrRowIndex;
    Ipp8s               m_iPrevRowIndex;
    Ipp32u              m_iCurrMBIndex;
    Ipp32u              m_uiMBsInRow;
    Ipp32u              m_uiMBsInCol;
    Ipp16s*             m_pMBData;

    //MEMORY ALLOCATOR
    UMC::MemoryAllocator *m_pMemoryAllocator;
    bool                  m_bOwnAllocator;
    UMC::MemID            m_pMBDataID;

public:
    VC1EncoderMBs():
        m_iCurrRowIndex(0),
        m_iPrevRowIndex(-1),
        m_iCurrMBIndex(0),
        m_uiMBsInRow(0),
        m_pMBData(0),
        m_uiMBsInCol(0),
        m_pMemoryAllocator(NULL),
        m_bOwnAllocator(false),
        m_pMBDataID((UMC::MemID)-1)

    {
        m_MBInfo = 0;
        m_MBData = 0;
    }
    ~VC1EncoderMBs()
    {
        Close();
    }

    VC1EncoderMBInfo*       GetCurrMBInfo();
    VC1EncoderMBInfo*       GetTopMBInfo();
    VC1EncoderMBInfo*       GetLeftMBInfo();
    VC1EncoderMBInfo*       GetTopLeftMBInfo();
    VC1EncoderMBInfo*       GetTopRightMBInfo();
    VC1EncoderMBInfo*       GetPevMBInfo(Ipp8u x, Ipp8u y);

    VC1EncoderMBData*       GetCurrMBData();
    VC1EncoderMBData*       GetTopMBData();
    VC1EncoderMBData*       GetLeftMBData();
    VC1EncoderMBData*       GetTopLeftMBData();

    VC1EncoderMB*           GetCurrMB();
    VC1EncoderMB*           GetTopMB();
    VC1EncoderMB*           GetLeftMB();
    VC1EncoderMB*           GetTopLeft();

    UMC::Status             Init(Ipp32u MBsInRow, Ipp32u MBsInCol);
    UMC::Status             Close();
    UMC::Status             NextMB();
    UMC::Status             NextRow();
    UMC::Status             StartRow();
    UMC::Status             Reset();

    void SetMemoryAllocator(UMC::MemoryAllocator *pMemoryAllocator, bool bOwnAllocator);

};


}

#endif
#endif //defined (UMC_ENABLE_VC1_VIDEO_ENCODER)