fgssubbandencoder.cpp

jsvm开发代码包括抽样,编码,抽取,解码等一系列功能,可以做工具或研究用

  m_iLastQP = iLastQP;

  return Err::m_nOK;
}

ErrVal
RQFGSEncoder::xRestoreFGSState(UInt& riLumaScanIdx,
                             UInt& riChromaDCScanIdx,
                             UInt& riChromaACScanIdx,
                             UInt& riStartCycle,
                             UInt& riCycle,
                             UInt& ruiPass,
                             UInt& ruiFragIdx,
//                              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;
  ruiFragIdx = m_uiFragIdx;
//   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&  uiXLumaCbpNextMbX,
                                     UInt&  uiXLumaCbpNextMbY,
                                     UInt&  uiXLumaCbpNext8x8Idx,
                                     UInt   uiXLastMbX,
                                     UInt   uiXLastMbY,
                                     UInt&  ruiLumaCbpBitCount)
{
  UInt uiMbXIdx = 0, uiMbYIdx = 0, uiB8x8 = 0;
  UInt uiLumaCbpBase, uiLumaCbp;
  MbDataAccess *pcMbDataAccessEL, *pcMbDataAccessBL;
  Bool bLumaCbpCodedFlag = false;

  UInt uiFirstMbInSlice  = uiXLumaCbpNextMbY*m_uiWidthInMB+uiXLumaCbpNextMbX ;
  UInt uiLastMbInSlice   = uiXLastMbY*m_uiWidthInMB+uiXLastMbX ;

  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 );
  }

  uiXLumaCbpNextMbX       = uiMbXIdx;
  uiXLumaCbpNextMbY       = uiMbYIdx;
  uiXLumaCbpNext8x8Idx    = uiB8x8;
  m_uiLumaCbpRun  = 0;

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

  m_uiLumaCbpNextMbX = uiXLumaCbpNextMbX;
  m_uiLumaCbpNextMbY = uiXLumaCbpNextMbY;
  m_uiLumaCbpNext8x8Idx = uiXLumaCbpNext8x8Idx;

  return Err::m_nOK;
}

ErrVal
RQFGSEncoder::xEncodeLumaCbpVlc(UInt  uiCurrMbIdxX,
                                UInt  uiCurrMbIdxY,
                                UInt& uiXLumaCbpNextMbX,
                                UInt& uiXLumaCbpNextMbY,
                                UInt& uiXLumaCbpNext8x8Idx,
                                UInt  uiXLastMbX,
                                UInt  uiXLastMbY,
                                UInt& ruiCbpBitCount)
{
  Bool bFirstMb  = true;
  MbDataAccess *pcMbDataAccessEL, *pcMbDataAccessBL;

  if( uiCurrMbIdxX != uiXLumaCbpNextMbX || uiCurrMbIdxY != uiXLumaCbpNextMbY )
    return Err::m_nOK;

  UInt uiFirstMbInSlice  = uiXLumaCbpNextMbY*m_uiWidthInMB+uiXLumaCbpNextMbX ;
  UInt uiLastMbInSlice   = uiXLastMbY*m_uiWidthInMB+uiXLastMbX ;

  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 ? uiXLumaCbpNext8x8Idx : 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
            {
              uiXLumaCbpNextMbX       = uiMbXIdx;
              uiXLumaCbpNextMbY       = uiMbYIdx;
              uiXLumaCbpNext8x8Idx    = uiB8x8;
              m_uiLumaCbpRun  = 0;

              m_uiLumaCbpNextMbX = uiXLumaCbpNextMbX;
              m_uiLumaCbpNextMbY = uiXLumaCbpNextMbY;
              m_uiLumaCbpNext8x8Idx = uiXLumaCbpNext8x8Idx;

              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;

    uiXLumaCbpNextMbX = uiXLastMbX;
    uiXLumaCbpNextMbY = uiXLastMbY;

    m_uiLumaCbpNextMbX = uiXLumaCbpNextMbX;
    m_uiLumaCbpNextMbY = uiXLumaCbpNextMbY;
  }

  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& uiXChromaCbpNextMbX,
                                  UInt& uiXChromaCbpNextMbY,
                                  UInt  uiXLastMbX,
                                  UInt  uiXLastMbY,
                                  UInt& ruiChromaCbpBitCount)
{
  MbDataAccess *pcMbDataAccessEL;

  if( uiCurrMbIdxX != uiXChromaCbpNextMbX || uiCurrMbIdxY != uiXChromaCbpNextMbY )
    return Err::m_nOK;

  UInt uiFirstMbInSlice  = uiXChromaCbpNextMbY*m_uiWidthInMB+uiXChromaCbpNextMbX ;
  UInt uiLastMbInSlice   = uiXLastMbY*m_uiWidthInMB+uiXLastMbX ;


  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;

        uiXChromaCbpNextMbX  = uiMbXIdx;
        uiXChromaCbpNextMbY  = uiMbYIdx;

        m_uiChromaCbpNextMbX = uiXChromaCbpNextMbX;
        m_uiChromaCbpNextMbY = uiXChromaCbpNextMbY;

        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;

    uiXChromaCbpNextMbX = uiXLastMbX;
    uiXChromaCbpNextMbY = uiXLastMbY;

    m_uiChromaCbpNextMbX = uiXChromaCbpNextMbX;
    m_uiChromaCbpNextMbY = uiXChromaCbpNextMbY;
  }

  return Err::m_nOK;
}


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

  RNOK( m_cMbDataCtrlEL    .initSlice ( *m_pcSliceHeader, PRE_PROCESS, false, NULL ) );
  RNOK( m_pcCurrMbDataCtrl->initSlice ( *m_pcSliceHeader, PRE_PROCESS, false, NULL ) );
  m_pcSliceHeader->setSliceType( m_eSliceType );
  if(!uiFracNb)
  {
    RNOK( m_pcSymbolWriter   ->startSlice( *m_pcSliceHeader ) );
  }
  else
  {
    RNOK( m_pcSymbolWriter   ->startFragment() );
  }

  AOT( m_pcSymbolWriter == 0);
  m_pcSliceHeader->setSliceType( F_SLICE );

  rbCorrupted = false;
  Int iLastQP = m_pcSliceHeader->getPicQp();

  UInt  uiBitsLast = m_pcSymbolWriter->getNumberOfWrittenBits();
  Bool  bCheck     = ( uiMaxBits != 0 );
  //FIX_FRAG_CAVLC
  if( uiFracNb )
  {
    RNOK( m_pcSymbolWriter->setFirstBits(m_ucLastByte, m_uiLastBitPos));
  }
  //~FIX_FRAG_CAVLC
  //positions vector for luma (and chromaAC) and chroma DC

  for(ui = 0; ui < 4; ui++)
  {
    m_auiScanPosVectChromaDC[ui] = ui;
  }
  if(m_pcSliceHeader->getFGSCodingMode() == false)
  {
    //grouping size mode
    UInt uiGroupingSize = m_pcSliceHeader->getGroupingSize();
    ui = 0;
    m_auiScanPosVectLuma[ui] = uiGroupingSize-1;
    while( m_auiScanPosVectLuma[ui] < 15)