fgssubbandencoder.cpp

来自「JVT-S203 contains the JSVM 6 reference s」· C++ 代码 · 共 1,959 行 · 第 1/5 页

    }
  }
	}	
    delete []m_aMyELTransformCoefs;
    delete []m_aMyBLTransformCoefs;
    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;

      if( pcMbDataAccessBL->getMbData().isTransformSize8x8() )
        uiLumaCbpBase = 0;

      // this should neven happen
      if( uiLumaCbpBase != 0 && pcMbDataAccessEL->getMbData().isTransformSize8x8() )
        return Err::m_nERR;

      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;

      if( pcMbDataAccessBL->getMbData().isTransformSize8x8() )
        uiLumaCbpBase = 0;

      // this should neven happen
      if( uiLumaCbpBase != 0 && pcMbDataAccessEL->getMbData().isTransformSize8x8() )
        return Err::m_nERR;

      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;