umc_vc1_enc_mb.h

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

    Ipp32s       blk;


    if (bRawBitplanes)
    {
        err = pCodedBlock->PutBits(1,1); //direct MB
        VC1_ENC_CHECK (err)
        err = pCodedBlock->PutBits(m_uiMBCBPCY==0,1); //skip
        VC1_ENC_CHECK (err)
    }
    if (m_uiMBCBPCY!=0)
    {

        err = pCodedBlock->PutBits(pCBPCYTable[2*(m_uiMBCBPCY&0x3F)], pCBPCYTable[2*(m_uiMBCBPCY&0x3F)+1]);
        VC1_ENC_CHECK (err)
        //err = WriteMBQuantParameter(pCodedPicture, doubleQuant>>1);
        //if (err != UMC::UMC_OK) return err;

        if (bVTS)
        {
            err = WriteVSTSMB (pCodedBlock, pTTMBVLC);
            VC1_ENC_CHECK (err)
        }
        for (blk = 0; blk<6; blk++)
        {

            err = WriteVSTSBlk ( pCodedBlock,
                pTTBLKVLC,
                pSBP4x4Table,
                bVTS,
                blk);

            VC1_ENC_CHECK (err)

                err = WriteBlockAC(pCodedBlock,
                pACTablesSet,
                pACEscInfo,
                blk);

            VC1_ENC_CHECK (err)
        }//for
    }//MBPattern!=0
    return err;
  }
  template <class T>  UMC::Status  WriteBMB      (T*                     pCodedBlock,
                                                                     bool                   bRawBitplanes,
                                                                     Ipp8u                  MVTab,
                                                                     Ipp8u                  MVRangeIndex,
                                                                     const Ipp16u*          pCBPCYTable,
                                                                     bool                   bVTS,
                                                                     const Ipp16s           (*pTTMBVLC)[4][6],
                                                                     const Ipp8u            (*pTTBLKVLC)[6],
                                                                     const Ipp8u*           pSBP4x4Table,
                                                                     const sACTablesSet*    pACTablesSet,
                                                                     sACEscInfo*            pACEscInfo,
                                                                     bool                   bBFraction)
  {
    UMC::Status  err=UMC::UMC_OK;
    Ipp32s       blk;
    Ipp8u        mvType = (m_MBtype == VC1_ENC_B_MB_F)? 0:((m_MBtype == VC1_ENC_B_MB_B)?1:2);
    bool         NotLastInter = false;



    if (m_MBtype == VC1_ENC_B_MB_FB)
    {
        NotLastInter = (m_dMV[1][0].x!=0 || m_dMV[1][0].y!=0 || m_uiMBCBPCY!=0);

    }
    if (bRawBitplanes)
    {
        err = pCodedBlock->PutBits(0,1); //direct MB
        VC1_ENC_CHECK (err)
        err = pCodedBlock->PutBits(0,1); //skip
        VC1_ENC_CHECK (err)
    }
    err = WriteMVDataInter(pCodedBlock, MVDiffTablesVLC[MVTab],MVRangeIndex, m_uiMBCBPCY!=0 || NotLastInter,0, m_MBtype == VC1_ENC_B_MB_F);
    VC1_ENC_CHECK (err)

    err = pCodedBlock->PutBits(BMVTypeVLC[bBFraction][mvType*2],BMVTypeVLC[bBFraction][mvType*2+1]);
    VC1_ENC_CHECK (err)

    if (NotLastInter)
    {
         err = WriteMVDataInter(pCodedBlock, MVDiffTablesVLC[MVTab],MVRangeIndex, m_uiMBCBPCY!=0,0, true);
         VC1_ENC_CHECK (err)
    }

    if (m_uiMBCBPCY!=0)
    {

        err = pCodedBlock->PutBits(pCBPCYTable[2*(m_uiMBCBPCY&0x3F)], pCBPCYTable[2*(m_uiMBCBPCY&0x3F)+1]);
        VC1_ENC_CHECK (err)
        //err = WriteMBQuantParameter(pCodedPicture, doubleQuant>>1);
        //if (err != UMC::UMC_OK) return err;

        if (bVTS)
        {
            err = WriteVSTSMB (pCodedBlock, pTTMBVLC);
            VC1_ENC_CHECK (err)
        }
        for (blk = 0; blk<6; blk++)
        {

            err = WriteVSTSBlk ( pCodedBlock,
                pTTBLKVLC,
                pSBP4x4Table,
                bVTS,
                blk);

            VC1_ENC_CHECK (err)

                err = WriteBlockAC(pCodedBlock,
                pACTablesSet,
                pACEscInfo,
                blk);

            VC1_ENC_CHECK (err)
        }//for
    }//MBPattern!=0
    return err;
  }


   template <class T>
   UMC::Status   WritePMB_SKIP(T*                     pCodedBlock,
                                                  bool                   bRawBitplanes)
   {
        UMC::Status  err=UMC::UMC_OK;
        if (bRawBitplanes)
        {
            err = pCodedBlock->PutBits(1,1);//skip
            VC1_ENC_CHECK (err)
        }
        if (m_bHybrid)
        {

            err = pCodedBlock->PutBits(m_bHybrid-1,1); // Hybrid
            VC1_ENC_CHECK (err)

        }
        return err;
   }
   template <class T>
   UMC::Status   WriteBMB_SKIP_NONDIRECT(T*                     pCodedBlock,
                                                            bool                   bRawBitplanes,
                                                            bool                   bBFraction)
   {
        UMC::Status  err = UMC::UMC_OK;
        Ipp8u mvType;
        switch(m_MBtype)
        {
        case VC1_ENC_B_MB_SKIP_F :
        case VC1_ENC_B_MB_F:
                mvType = 0;
                break;
        case VC1_ENC_B_MB_SKIP_B :
        case VC1_ENC_B_MB_B:
                mvType = 1;
                break;
        default:
                mvType = 2;
                break;
        }
        if (bRawBitplanes)
        {
            err = pCodedBlock->PutBits(0,1); //direct MB
            VC1_ENC_CHECK (err)
            err = pCodedBlock->PutBits(1,1); //skip
            VC1_ENC_CHECK (err)
        }
        err = pCodedBlock->PutBits(BMVTypeVLC[bBFraction][mvType*2],BMVTypeVLC[bBFraction][mvType*2+1]);
        VC1_ENC_CHECK (err);
        return err;
   }
   template <class T>
   UMC::Status   WriteBMB_SKIP_DIRECT(T*                     pCodedBlock,
                                                         bool                   bRawBitplanes)
   {
        UMC::Status  err = UMC::UMC_OK;

        if (bRawBitplanes)
        {
            err = pCodedBlock->PutBits(1,1); //direct MB
            VC1_ENC_CHECK (err)
            err = pCodedBlock->PutBits(1,1); //skip
            VC1_ENC_CHECK (err)
        }

        return err;
   }
 /*  template <class T>
   UMC::Status  WritePMB1MV(T*                     pCodedBlock,
                            bool                   bRawBitplanes,
                            Ipp8u                  MVTab,
                            Ipp8u                  MVRangeIndex,
                            const Ipp16u*          pCBPCYTable,
                            bool                   bVTS,
                            const Ipp16s           (*pTTMBVLC)[4][6],
                            const Ipp8u            (*pTTBLKVLC)[6],
                            const Ipp8u*           pSBP4x4Table,
                            const sACTablesSet*    pACTablesSet,
                            sACEscInfo*            pACEscInfo);
   template <class T>
   UMC::Status   WritePMB_SKIP(T*                     pCodedBlock,
                               bool                   bRawBitplanes);

   template <class T>
   UMC::Status   WriteBMB      (T*                     pCodedBlock,
                                bool                   bRawBitplanes,
                                Ipp8u                  MVTab,
                                Ipp8u                  MVRangeIndex,
                                const Ipp16u*          pCBPCYTable,
                                bool                   bVTS,
                                const Ipp16s           (*pTTMBVLC)[4][6],
                                const Ipp8u            (*pTTBLKVLC)[6],
                                const Ipp8u*           pSBP4x4Table,
                                const sACTablesSet*    pACTablesSet,
                                sACEscInfo*            pACEscInfo,
                                bool                   bBFraction);

   template <class T>
   UMC::Status   WriteBMB_SKIP_NONDIRECT (T*         pCodedBlock,
                                          bool       bRawBitplanes,
                                          bool       bBFraction);
   template <class T>
   UMC::Status   WriteBMB_DIRECT      (T*                     pCodedBlock,
                                       bool                   bRawBitplanes,
                                       const Ipp16u*          pCBPCYTable,
                                       bool                   bVTS,
                                       const Ipp16s           (*pTTMBVLC)[4][6],
                                       const Ipp8u            (*pTTBLKVLC)[6],
                                       const Ipp8u*           pSBP4x4Table,
                                       const sACTablesSet*    pACTablesSet,
                                       sACEscInfo*            pACEscInfo);
   template <class T>
   UMC::Status   WriteBMB_SKIP_DIRECT    (T*         pCodedBlock,
                                         bool       bRawBitplanes);*/
protected:

  /* template <class T>
   UMC::Status   WriteVSTSMB (    T*                      pCodedBlock,
                                  const Ipp16s           (*pTTMBVLC)[4][6]);
   template <class T>
   UMC::Status   WriteVSTSBlk (    T*                      pCodedBlock,
                                   const Ipp8u            (*pTTBLKVLC)[6],
                                   const Ipp8u*            pSBP4x4Table,
                                   bool                    bVTS,
                                   Ipp8u                   blk);*/
    template <class T>
    inline     UMC::Status   WriteBlockDC  (    T*                pCodedBlock,
                                                const Ipp32u*     pEncTable,
                                                Ipp32u            quant,
                                                Ipp8u             blk)
    {
        switch (quant)
        {
        case 1:
               return WriteDCQuant1    (m_iDC[blk],pEncTable, pCodedBlock);
        case 2:
               return WriteDCQuant2    (m_iDC[blk],pEncTable, pCodedBlock);
        default:
               return WriteDCQuantOther (m_iDC[blk],pEncTable, pCodedBlock);
        }
   }
  /* template <class T>  UMC::Status
   WriteBlockAC     (T*                      pCodedBlock,
                     const sACTablesSet*     pACTablesSet,
                     sACEscInfo*             pACEscInfo,
                     Ipp8u                   blk);

   template<class T>  inline
   UMC::Status   (T* pCodedMB, const Ipp16u* table, Ipp8u rangeIndex,  bool   NotSkip, Ipp8u blockNum=0, bool bForward=true);
   template<class T>  inline
   UMC::Status WriteMVDataPIntra (T* pCodedMB, const Ipp16u* table, Ipp8u blockNum=0);*/

};
class VC1EncoderMBData
{
public:

    Ipp16s*     m_pBlock[VC1_ENC_NUMBER_OF_BLOCKS];
    Ipp32u      m_uiBlockStep[VC1_ENC_NUMBER_OF_BLOCKS];

public:

   UMC::Status InitBlocks(Ipp16s* pBuffer);
   void Reset()
   {
       if (!m_pBlock[0]) memset(m_pBlock[0],0,VC1_ENC_BLOCK_SIZE*VC1_ENC_NUMBER_OF_BLOCKS*sizeof(Ipp16s));
   }
   VC1EncoderMBData()
   {
        memset(m_pBlock,        0,sizeof(Ipp16s*)*VC1_ENC_NUMBER_OF_BLOCKS);
        memset(m_uiBlockStep,   0,sizeof(Ipp32u) *VC1_ENC_NUMBER_OF_BLOCKS);
   }
   UMC::Status CopyMBProg(Ipp8u* pY, Ipp32u stepY, Ipp8u* pU, Ipp32u stepU, Ipp8u* pV, Ipp32u stepV)
   {
       if (!m_pBlock[0])
           return UMC::UMC_ERR_NOT_INITIALIZED;

       IppiSize roiSize = {16, 16};

IPP_STAT_START_TIME(m_IppStat->IppStartTime);
       _own_Copy8x8_16x16_8u16s(pY, stepY, m_pBlock[0], m_uiBlockStep[0], roiSize);
       roiSize.height = 8;
       roiSize.width  = 8;
       _own_Copy8x8_16x16_8u16s(pU, stepU, m_pBlock[4], m_uiBlockStep[4], roiSize);
       _own_Copy8x8_16x16_8u16s(pV, stepV, m_pBlock[5], m_uiBlockStep[5], roiSize);
IPP_STAT_END_TIME(m_IppStat->IppStartTime, m_IppStat->IppEndTime, m_IppStat->IppTotalTime);

       return UMC::UMC_OK;
   }
   //UMC::Status GetMBPattern(bool bIntra, Ipp8u &pattern)
   //{
   //    Ipp32s blk;
   //    Ipp32u num = 64 - bIntra;

   //    if (!m_pBlock[0])
   //        return UMC::UMC_ERR_NOT_INITIALIZED;
   //    pattern = 0;
   //    for (blk = 0; blk<6; blk++)
   //    {
   //        Ipp32u n = GetNumZeros(m_pBlock[blk],m_uiBlockStep[blk],bIntra);
   //        pattern |= ((n<num) << (5 - blk));
   //    }
   //    return UMC::UMC_OK;
   //}
   inline static bool IsCodedBlock(Ipp8u MBPattern, Ipp32s blk)
   {