fgssubbandencoder.cpp

JMVM MPEG MVC/3DAV 测试平台 国际通用标准

    delete []m_auiMbCbpStored;
    delete []m_auiBCBPStored;
    delete []m_aiBLQP;
    delete []m_abELtransform8x8;

    return Err::m_nOK;
}

ErrVal
RQFGSEncoder::xStoreFGSState(UInt iLumaScanIdx,
                             UInt iChromaDCScanIdx,
                             UInt iChromaACScanIdx,
                             UInt iStartCycle,
                             UInt iCycle,
                             UInt uiPass,
                             UInt bAllowChromaDC,
                             UInt bAllowChromaAC,
                             UInt uiMbYIdx,
                             UInt uiMbXIdx,
                             UInt uiB8YIdx,
                             UInt uiB8XIdx,
                             UInt uiBlockYIdx,
                             UInt uiBlockXIdx,
                             UInt iLastBitsLuma,
                             UInt uiBitsLast,
                             UInt uiFGSPart,
                             UInt uiPlane,
                             Int iLastQP)
{
  m_iLumaScanIdx = iLumaScanIdx;
  m_iChromaDCScanIdx = iChromaDCScanIdx;
  m_iChromaACScanIdx = iChromaACScanIdx;
  m_iStartCycle = iStartCycle;
  m_iCycle = iCycle;
  m_uiPass = uiPass;
  m_bAllowChromaDC = bAllowChromaDC;
  m_bAllowChromaAC = bAllowChromaAC;
  m_uiMbYIdx = uiMbYIdx;
  m_uiMbXIdx = uiMbXIdx;
  m_uiB8YIdx = uiB8YIdx;
  m_uiB8XIdx = uiB8XIdx;
  m_uiBlockYIdx = uiBlockYIdx;
  m_uiBlockXIdx = uiBlockXIdx;
  m_iLastBitsLuma = iLastBitsLuma;
  m_uiBitsLast = uiBitsLast;
  m_uiFGSPart = uiFGSPart;
  m_uiPlane = uiPlane;
  m_iLastQP = iLastQP;

  return Err::m_nOK;
}

ErrVal
RQFGSEncoder::xRestoreFGSState(UInt& riLumaScanIdx,
                             UInt& riChromaDCScanIdx,
                             UInt& riChromaACScanIdx,
                             UInt& riStartCycle,
                             UInt& riCycle,
                             UInt& ruiPass,
                             UInt& rbAllowChromaDC,
                             UInt& rbAllowChromaAC,
                             UInt& ruiMbYIdx,
                             UInt& ruiMbXIdx,
                             UInt& ruiB8YIdx,
                             UInt& ruiB8XIdx,
                             UInt& ruiBlockYIdx,
                             UInt& ruiBlockXIdx,
                             UInt& riLastBitsLuma,
                             UInt& ruiBitsLast,
                             UInt& ruiFGSPart,
                             UInt& ruiPlane,
                             Int& riLastQP)
{
  riLumaScanIdx = m_iLumaScanIdx;
  riChromaDCScanIdx = m_iChromaDCScanIdx;
  riChromaACScanIdx = m_iChromaACScanIdx;
  riStartCycle = m_iStartCycle;
  riCycle = m_iCycle;
  ruiPass = m_uiPass;
  rbAllowChromaDC = m_bAllowChromaDC;
  rbAllowChromaAC = m_bAllowChromaAC;
  ruiMbYIdx = m_uiMbYIdx;
  ruiMbXIdx = m_uiMbXIdx;
  ruiB8YIdx = m_uiB8YIdx;
  ruiB8XIdx = m_uiB8XIdx;
  ruiBlockYIdx = m_uiBlockYIdx;
  ruiBlockXIdx = m_uiBlockXIdx;
  riLastBitsLuma = m_iLastBitsLuma;
  ruiBitsLast = m_uiBitsLast;
  ruiFGSPart = m_uiFGSPart;
  ruiPlane = m_uiPlane;
  riLastQP = m_iLastQP;
  return Err::m_nOK;
}
//~JVT-P031

UInt gauiB8x8Mapping[4] = { 0, 2, 3, 1 }; 

static UInt UvlcCodeLength(UInt uiSymbol)
{
  UInt uiCodeLength = 1;

  uiSymbol ++;
  while( 1 != uiSymbol )
  {
    uiSymbol >>= 1;
    uiCodeLength += 2;
  }

  return uiCodeLength;
}

ErrVal
RQFGSEncoder::xEncodeLumaCbpVlcStart(UInt&  uiLumaCbpNextMbX,
                                     UInt&  uiLumaCbpNextMbY,
                                     UInt&  uiLumaCbpNext8x8Idx,
                                     UInt   uiLastMbX,
                                     UInt   uiLastMbY,
                                     UInt&  ruiLumaCbpBitCount)
{
  UInt uiMbXIdx = 0, uiMbYIdx = 0, uiB8x8 = 0;
  UInt uiLumaCbpBase, uiLumaCbp;
  MbDataAccess *pcMbDataAccessEL, *pcMbDataAccessBL;
  Bool bLumaCbpCodedFlag = false;

  UInt uiFirstMbInSlice  = uiLumaCbpNextMbY*m_uiWidthInMB+uiLumaCbpNextMbX ;
  UInt uiLastMbInSlice   = uiLastMbY*m_uiWidthInMB+uiLastMbX ;

  for(UInt uiMbAddress= uiFirstMbInSlice ;uiMbAddress<=uiLastMbInSlice ;)
  {
        uiMbYIdx = uiMbAddress / m_uiWidthInMB;
        uiMbXIdx = uiMbAddress % m_uiWidthInMB;		
    
      RNOK( m_pcCurrMbDataCtrl ->initMb( pcMbDataAccessBL, uiMbYIdx, uiMbXIdx ) );
      RNOK( m_cMbDataCtrlEL     .initMb( pcMbDataAccessEL, uiMbYIdx, uiMbXIdx ) );

      uiLumaCbpBase = pcMbDataAccessBL->getMbData().getMbCbp() & 0x0F;
      uiLumaCbp     = pcMbDataAccessEL->getMbData().getMbCbp() & 0x0F;

      if( uiLumaCbpBase != 15 )
      {
        for( uiB8x8 = 0; uiB8x8 < 4; uiB8x8 ++ )
        {
          Bool bLumaCbpFlagBase = (uiLumaCbpBase >> gauiB8x8Mapping[uiB8x8]) & 1;
          if( ! bLumaCbpFlagBase )
          {
            m_bLastLumaCbpFlag  = (uiLumaCbp     >> gauiB8x8Mapping[uiB8x8]) & 1;
            break;
          }
        }
        
        bLumaCbpCodedFlag = true;
        break;
      }
      else
        pcMbDataAccessEL->getMbData().setMbCbp(pcMbDataAccessEL->getMbData().getMbCbp() | uiLumaCbpBase);
    

    if( bLumaCbpCodedFlag )
      break;
  
		//--ICU/ETRI FMO Implementation
    uiMbAddress = m_pcSliceHeader->getFMO()->getNextMBNr(uiMbAddress );
  }	

  uiLumaCbpNextMbX       = uiMbXIdx;
  uiLumaCbpNextMbY       = uiMbYIdx;
  uiLumaCbpNext8x8Idx    = uiB8x8;
  m_uiLumaCbpRun  = 0;

  ((UvlcWriter *) m_pcSymbolWriter)->writeFlag(! m_bLastLumaCbpFlag, "Luma_CBP_first_flag");
  ruiLumaCbpBitCount ++;

  m_uiLumaCbpNextMbX = uiLumaCbpNextMbX;
  m_uiLumaCbpNextMbY = uiLumaCbpNextMbY;
  m_uiLumaCbpNext8x8Idx = uiLumaCbpNext8x8Idx;

  return Err::m_nOK;
}

ErrVal
RQFGSEncoder::xEncodeLumaCbpVlc(UInt  uiCurrMbIdxX,
                                UInt  uiCurrMbIdxY,
                                UInt& uiLumaCbpNextMbX,
                                UInt& uiLumaCbpNextMbY,
                                UInt& uiLumaCbpNext8x8Idx,
                                UInt  uiLastMbX,
                                UInt  uiLastMbY,
                                UInt& ruiCbpBitCount)
{
  Bool bFirstMb  = true;
  MbDataAccess *pcMbDataAccessEL, *pcMbDataAccessBL;

  if( uiCurrMbIdxX != uiLumaCbpNextMbX || uiCurrMbIdxY != uiLumaCbpNextMbY )
    return Err::m_nOK;

  UInt uiFirstMbInSlice  = uiLumaCbpNextMbY*m_uiWidthInMB+uiLumaCbpNextMbX ;
  UInt uiLastMbInSlice   = uiLastMbY*m_uiWidthInMB+uiLastMbX ;

  for(UInt uiMbAddress= uiFirstMbInSlice ;uiMbAddress<=uiLastMbInSlice ;)
  {
        UInt uiMbYIdx = uiMbAddress / m_uiWidthInMB;
        UInt uiMbXIdx = uiMbAddress % m_uiWidthInMB;
  {
    {
      RNOK( m_pcCurrMbDataCtrl ->initMb( pcMbDataAccessBL, uiMbYIdx, uiMbXIdx ) );
      RNOK( m_cMbDataCtrlEL     .initMb( pcMbDataAccessEL, uiMbYIdx, uiMbXIdx ) );

      UInt uiLumaCbpBase = pcMbDataAccessBL->getMbData().getMbCbp() & 0x0F;
      UInt uiLumaCbp     = pcMbDataAccessEL->getMbData().getMbCbp() & 0x0F;

      for( UInt uiB8x8 = bFirstMb ? uiLumaCbpNext8x8Idx : 0; uiB8x8 < 4; uiB8x8 ++ )
      {
        Bool bLumaCbpFlagBase = (uiLumaCbpBase >> gauiB8x8Mapping[uiB8x8]) & 1;
        Bool bLumaCbpFlag     = (uiLumaCbp     >> gauiB8x8Mapping[uiB8x8]) & 1;

        if( ! bLumaCbpFlagBase )
        {
          if( bLumaCbpFlag == m_bLastLumaCbpFlag )
            m_uiLumaCbpRun ++;
          else
          {
            ((UvlcWriter *) m_pcSymbolWriter)->writeUvlc(m_uiLumaCbpRun - 1, "Luma_CBP_run");
            ruiCbpBitCount += UvlcCodeLength(m_uiLumaCbpRun - 1);

            m_bLastLumaCbpFlag = bLumaCbpFlag;

            // is it in the next MB?
            if( uiCurrMbIdxX == uiMbXIdx && uiCurrMbIdxY == uiMbYIdx )
              m_uiLumaCbpRun  = 1;
            else
            {
              uiLumaCbpNextMbX       = uiMbXIdx;
              uiLumaCbpNextMbY       = uiMbYIdx;
              uiLumaCbpNext8x8Idx    = uiB8x8;
              m_uiLumaCbpRun  = 0;

              m_uiLumaCbpNextMbX = uiLumaCbpNextMbX;
              m_uiLumaCbpNextMbY = uiLumaCbpNextMbY;
              m_uiLumaCbpNext8x8Idx = uiLumaCbpNext8x8Idx;

              return Err::m_nOK;
            }
          }
        }
      }

      pcMbDataAccessEL->getMbData().setMbCbp(pcMbDataAccessEL->getMbData().getMbCbp() | uiLumaCbpBase);

      bFirstMb = false;
    }
  }

  uiMbAddress = m_pcSliceHeader->getFMO()->getNextMBNr(uiMbAddress );

  } // end for FGS ROI 1

  if( m_uiLumaCbpRun > 0 )
  {
    ((UvlcWriter *) m_pcSymbolWriter)->writeUvlc(m_uiLumaCbpRun - 1, "Luma_CBP_run");

    ruiCbpBitCount += UvlcCodeLength(m_uiLumaCbpRun - 1);

    m_uiLumaCbpRun = 0;

    uiLumaCbpNextMbX = uiLastMbX;
    uiLumaCbpNextMbY = uiLastMbY;

    m_uiLumaCbpNextMbX = uiLumaCbpNextMbX;
    m_uiLumaCbpNextMbY = uiLumaCbpNextMbY;
  }

  return Err::m_nOK;
}

Bool gaabTransitionFlag[3][3] = { { 0, 0, 1 }, { 1, 0, 0 }, { 0, 1, 0 } };


ErrVal
RQFGSEncoder::xEncodeChromaCbpVlcStart(UInt   uiCurrMbIdxX,
                                       UInt   uiCurrMbIdxY,
                                       UInt&  ruiChromaCbpBitCount)
{
  MbDataAccess *pcMbDataAccessEL;
  UInt uiChromaCbp;
  UInt uiInitialChromaCbp;

  RNOK( m_cMbDataCtrlEL     .initMb( pcMbDataAccessEL, uiCurrMbIdxY, uiCurrMbIdxX ) );
  uiChromaCbp = pcMbDataAccessEL->getMbData().getMbCbp() >> 4;

  uiInitialChromaCbp = uiChromaCbp == 0 ? 1 : 0;
  ((UvlcWriter *) m_pcSymbolWriter)->writeFlag(uiInitialChromaCbp != 0, "Chroma_CBP_first");
  ruiChromaCbpBitCount ++;

  m_bChromaCbpTransition = gaabTransitionFlag[uiInitialChromaCbp][uiChromaCbp];

  m_uiLastChromaCbp = uiChromaCbp;
  m_uiChromaCbpRun  = 0;

  return Err::m_nOK;
}


ErrVal
RQFGSEncoder::xEncodeChromaCbpVlc(UInt  uiCurrMbIdxX,
                                  UInt  uiCurrMbIdxY,
                                  UInt& uiChromaCbpNextMbX,
                                  UInt& uiChromaCbpNextMbY,
                                  UInt  uiLastMbX,
                                  UInt  uiLastMbY,
                                  UInt& ruiChromaCbpBitCount)
{
  MbDataAccess *pcMbDataAccessEL;

  if( uiCurrMbIdxX != uiChromaCbpNextMbX || uiCurrMbIdxY != uiChromaCbpNextMbY )
    return Err::m_nOK;

  UInt uiFirstMbInSlice  = uiChromaCbpNextMbY*m_uiWidthInMB+uiChromaCbpNextMbX ;
  UInt uiLastMbInSlice   = uiLastMbY*m_uiWidthInMB+uiLastMbX ;


  for(UInt uiMbAddress= uiFirstMbInSlice ;uiMbAddress<=uiLastMbInSlice ;)
  {
	UInt uiMbYIdx = uiMbAddress / m_uiWidthInMB;
    UInt uiMbXIdx = uiMbAddress % m_uiWidthInMB;
	{
    {
      RNOK( m_cMbDataCtrlEL.initMb( pcMbDataAccessEL, uiMbYIdx, uiMbXIdx ) );
      UInt uiChromaCbp = (pcMbDataAccessEL->getMbData().getMbCbp() >> 4);

      if( uiChromaCbp == m_uiLastChromaCbp )
        m_uiChromaCbpRun ++;
      else
      {
        ((UvlcWriter *) m_pcSymbolWriter)->writeFlag(m_bChromaCbpTransition, "Chroma_CBP_transition");
        ruiChromaCbpBitCount ++;

        ((UvlcWriter *) m_pcSymbolWriter)->writeUvlc(m_uiChromaCbpRun - 1, "Chroma_CBP_run");
        ruiChromaCbpBitCount += UvlcCodeLength(m_uiChromaCbpRun - 1);

        m_uiChromaCbpRun = 0;

        m_bChromaCbpTransition = gaabTransitionFlag[m_uiLastChromaCbp][uiChromaCbp];
        m_uiLastChromaCbp   = uiChromaCbp;

        uiChromaCbpNextMbX  = uiMbXIdx;
        uiChromaCbpNextMbY  = uiMbYIdx;

        m_uiChromaCbpNextMbX = uiChromaCbpNextMbX;
        m_uiChromaCbpNextMbY = uiChromaCbpNextMbY;

        return Err::m_nOK;
      }
    }
  }

  uiMbAddress = m_pcSliceHeader->getFMO()->getNextMBNr(uiMbAddress );
  }	

  if( m_uiChromaCbpRun > 0 )
  {
    ((UvlcWriter *) m_pcSymbolWriter)->writeFlag(m_bChromaCbpTransition, "Chroma_CBP_transition");
    ruiChromaCbpBitCount ++;

    ((UvlcWriter *) m_pcSymbolWriter)->writeUvlc(m_uiChromaCbpRun - 1, "Chromama_CBP_run");
    ruiChromaCbpBitCount += UvlcCodeLength(m_uiChromaCbpRun - 1);

    m_uiChromaCbpRun = 0;

    uiChromaCbpNextMbX = uiLastMbX;
    uiChromaCbpNextMbY = uiLastMbY;

    m_uiChromaCbpNextMbX = uiChromaCbpNextMbX;
    m_uiChromaCbpNextMbY = uiChromaCbpNextMbY;
  }

  return Err::m_nOK;
}



ErrVal
RQFGSEncoder::xEncodingFGS( Bool& rbFinished,
                            Bool& rbCorrupted,
                            UInt uiMaxBits,
                            UInt uiFracNb,
                            FILE* pFile ) //JVT-P031 (modified for fragments)
{
  Bool bRestore = true;
  Bool bFirstPass = true;