uvlcreader.cpp

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

}

ErrVal
UvlcReader::xRQdecodeTCoeffsRef( TCoeff*       piCoeff,
                                 TCoeff*       piCoeffBase,
                                 const UChar*  pucScan,
                                 UInt          uiScanIndex )
{
  UInt    uiBaseSign;
  TCoeff* piCoeffPtr;

  uiBaseSign = (piCoeffBase[pucScan[uiScanIndex]] < 0) ? 1 : 0;
  piCoeffPtr = & piCoeff[pucScan[uiScanIndex]];
  RNOKS( m_pSymGrp->xFetchSymbol( this, uiBaseSign, piCoeffPtr, "REF_COEFF" ) );

  return Err::m_nOK;
}


ErrVal
UvlcReader::xGetGolomb(UInt& uiSymbol, UInt uiK)
{
  UInt uiCode;
  UInt uiR;
  UInt uiQ = 0;
  UInt uiC = 0;
  UInt uiT = uiK >> 1;

  while ( uiT > 0 )
  {
    uiC++;
    uiT >>= 1;
  }

  // Unary part
  do {
    RNOKS( xGetFlag( uiCode ) );
    uiQ++;
  } while ( uiCode != 0 );
  uiQ--;

  uiSymbol = uiQ * uiK;

  if ( uiC == 0 )
  {
    return Err::m_nOK;
  }

  // Binary part
  RNOKS( xGetFlag( uiCode ) );
  if ( uiCode == 0 )
  {
    if ( uiC > 1 )
    {
      RNOKS( xGetCode( uiR, uiC-1 ) );
    } else {
      uiR = 0;
    }
  } else {
    RNOKS( xGetCode( uiCode, uiC ) );
    uiR = uiCode + uiC;
  }
  DTRACE_N;

  uiSymbol += uiR;

  return Err::m_nOK;
}

ErrVal
UvlcReader::RQdecodeEobOffsets_Luma()
{
  RNOK( m_pSymGrp->Init() );
  m_uiCbpStat4x4[0] = m_uiCbpStat4x4[1] = 0;
  m_uiCbpStats[0][0] = m_uiCbpStats[0][1] = m_uiCbpStats[1][0] = m_uiCbpStats[1][1] = 0;

  RNOKS( xRQdecodeEobOffsets( m_auiShiftLuma, 16 ) );
  return Err::m_nOK;
}

ErrVal
UvlcReader::RQdecodeEobOffsets_Chroma()
{
  m_auiShiftChroma[0] = 15;
  RNOK( xRQdecodeEobOffsets( m_auiShiftChroma+1, 15 ) );

  return Err::m_nOK;
}

ErrVal
UvlcReader::xRQdecodeEobOffsets( UInt* pauiShift, UInt uiMax )
{
  UInt uiNumEnd = 1;
  DTRACE_T("num_end_vals");
  for (UInt uiEc=0; uiEc<3; uiEc++)
  {
    UInt uiCode;
    RNOKS( xGetFlag( uiCode ) );
    if (uiCode)
    {
      uiNumEnd++;
    } else {
      break;
    }
  }
  DTRACE_V(uiNumEnd-1);
  DTRACE_N;

  if (uiNumEnd == 4)
  {
    uiNumEnd = 0;
  }
  for (UInt ui=0; ui<uiNumEnd; ui++)
  {
    pauiShift[ui] = uiMax - 1;
  }
  UInt uiLevel;
  DTRACE_T("eobShiftXXX[ num_end_vals ]");
  RNOKS( xGetGolomb( uiLevel, 2 ) );
  pauiShift[uiNumEnd] = uiLevel;
  
  RNOKS( xDecodeMonSeq( pauiShift+uiNumEnd+1, uiLevel, uiMax-uiNumEnd-1 ) );

  return Err::m_nOK;
}


ErrVal
UvlcReader::RQdecodeBestCodeTableMap( UInt uiMaxH )
{
  UInt uiW = uiMaxH-1;

  memset(m_auiBestCodeTab, 0, sizeof(UInt)*uiMaxH);

  DTRACE_T("num_sig_vlc_selectors");
  RNOKS( xGetCode(uiW, 4) );

  DTRACE_TY("u(4) ");
  DTRACE_V(uiW);
  DTRACE_N;
  DTRACE_T("sig_vlc_selector[i]");
  for(UInt uiH = 0; uiH <= uiW; uiH++)
  {
    RNOKS(xGetSigRunTabCode(m_auiBestCodeTab[uiH]));
  }
  DTRACE_N;

  return Err::m_nOK;
}

ErrVal
UvlcReader::RQvlcFlush()
{
  return Err::m_nOK;
}

ErrVal
UvlcReader::RQupdateVlcTable()
{
  m_pSymGrp->UpdateVlc();

  return Err::m_nOK;
}


ErrVal
UvlcReader::xDecodeMonSeq ( UInt* auiSeq, UInt uiStart, UInt uiLen )
{
  UInt uiPos   = 0;
  UInt uiLevel = uiStart;
  while ( uiLevel > 0 && uiPos < uiLen )
  {
    UInt uiRun;
    DTRACE_T("eob_run");
    RNOKS( xGetGolomb( uiRun, 1 ) );
    for (UInt ui=0; ui<uiRun; ui++,uiPos++)
      auiSeq[uiPos] = uiLevel;
    uiLevel--;
  }
  for (; uiPos < uiLen; uiPos++)
  {
    auiSeq[uiPos] = 0;
  }
  
  return Err::m_nOK;
}

ErrVal 
UvlcReader::xGetSigRunCode( UInt& uiVal, UInt uiCodeTab )
{
  if( uiCodeTab == 0)
  {
    RNOKS(xGetUnaryCode( uiVal ));
  }
  else if( uiCodeTab == 1)
  {
    RNOKS(xGetCodeCB1( uiVal ));
  }
  else if( uiCodeTab == 2)
  {
    RNOKS(xGetCodeCB2( uiVal ));
  }
  else if( uiCodeTab == 3)
  {
    UInt uiCode; 

    RNOKS( xGetFlag( uiCode ) );

    if(uiCode == 1)
    {
      uiVal = 0;
    }
    else
    {
      RNOKS( xGetCodeCB2( uiCode ) );
      uiVal = uiCode+1;
    }
  }
  else
  {
    UInt uiCode; 

    RNOKS( xGetFlag( uiCode ) );

    if(uiCode == 1)
    {
      uiVal = 0;
    }
    else
    {
      RNOKS( xGetCodeCB1( uiCode ) );
      uiVal = uiCode+1;
    }
  }

  return Err::m_nOK;
}


ErrVal 
UvlcReader::xGetCodeCB1 ( UInt& uiVal )
{
  UInt uiPrefixLen = 0;
  UInt uiFlag;

  do
  {
    RNOKS(xGetFlag(uiFlag));
    uiPrefixLen++;
  }
  while (uiFlag == 0);
  RNOKS( xGetFlag( uiFlag) );
  
  uiVal = (2*(uiPrefixLen-1))+(1-uiFlag);
  return Err::m_nOK;
}

ErrVal 
UvlcReader::xGetCodeCB2( UInt& uiVal )
{
  UInt uiPrefixLen = 0;
  UInt uiCode;

  do
  {
    RNOKS( xGetCode( uiCode, 2) );
    uiPrefixLen++;
  }
  while (uiCode == 0);

  uiVal = (3*(uiPrefixLen-1))+(3-uiCode);
  return Err::m_nOK;
}

ErrVal 
UvlcReader::xGetUnaryCode( UInt& uiVal )
{
  UInt uiCode;
  UInt uiSymbol = 0;

  do
  {
    RNOKS( xGetFlag( uiCode ) );
    if(uiCode == 1)
    {
      uiVal = uiSymbol;
      break;
    }
    else
    {
      uiSymbol++;
    }
  }
  while (true);
  return Err::m_nOK;
}

ErrVal
UvlcReader::xGetSigRunTabCode(UInt &uiTab)
{
  UInt uiFlag;

  RNOKS(xGetFlag(uiFlag));
  if(uiFlag == 1)
  {
    uiTab = 0;
  }
  else
  {
    RNOKS(xGetFlag(uiFlag));
    if(uiFlag == 1)
    {
      uiTab = 1;
    }
    else 
    {
      RNOKS(xGetFlag(uiFlag));
      if(uiFlag == 1)
      {
        uiTab  = 2;
      }
      else
      {
        RNOKS(xGetFlag(uiFlag));
        uiTab = 4-uiFlag;
      }
    }
  }
  return Err::m_nOK;
}

ErrVal
UvlcReader::RQcompSepAlign()
{
  RNOKS( m_pcBitReadBuffer->getBitsUntilByteAligned() );

  return Err::m_nOK;
}


ErrVal
UvlcReader::RQreset( const SliceHeader& rcSliceHeader )
{
  m_pSymGrp->Init();
  return Err::m_nOK;
}


UcSymGrpReader::UcSymGrpReader( UvlcReader* pParent )
{
  Init();
}

ErrVal
UcSymGrpReader::Init()
{
  m_uiCode         = 0;
  m_uiLen          = CAVLC_SYMGRP_SIZE;
  m_auiSymCount[0] = m_auiSymCount[1] = m_auiSymCount[2] = 0;
  m_uiTable = 0;
  m_uiCodedFlag    = false;

  return Err::m_nOK;
}

ErrVal
// actually used only for refinement coefficients
UcSymGrpReader::xFetchSymbol( UvlcReader* pcUvlcReader,
                              UInt        uiBaseSign,
                              TCoeff*     piCoeffPtr,
                              Char*       pcTraceString )
{
  if( m_uiLen == CAVLC_SYMGRP_SIZE )
  {
    UInt uiTemp;
   
    m_uiCodedFlag = true;
    RNOKS( pcUvlcReader->codeFromBitstream2Di( g_auiRefSymCode[m_uiTable], g_auiRefSymLen[m_uiTable], 27, 1, m_uiCode, uiTemp ) );

    UInt uiCode = m_uiCode;
    UInt uiDenom = 9;

    for(UInt ui = 0; ui < CAVLC_SYMGRP_SIZE; ui++)
    {
      UChar ucSym;
      ucSym = uiCode/uiDenom;
      m_auiSymbolBuf[ui] = ucSym;
      m_auiSymCount[ucSym]++;

      uiCode = (uiCode % uiDenom);
      uiDenom /= 3;
    }
  
    m_uiLen   = 0;
    m_uiCode  = 0;
  }

  *piCoeffPtr = 0;
  if (m_auiSymbolBuf[m_uiLen] > 0) {
    UInt uiSymbol = m_auiSymbolBuf[m_uiLen] - 1;
    UInt uiSignEL = ( uiBaseSign ^ uiSymbol );
    *piCoeffPtr   = ( uiSignEL ? -1 : 1 );
  }

  m_uiLen ++;

  return Err::m_nOK;
}

Bool
UcSymGrpReader::UpdateVlc()
{
  UInt uiFlag = m_uiCodedFlag;
  if (uiFlag) {
    // updating
    m_uiTable = 0;
    if (m_auiSymCount[0] < 2 *(m_auiSymCount[1] + m_auiSymCount[2]) ||
      m_auiSymCount[1] < 2 * m_auiSymCount[2]) {
      m_uiTable = 1;
    }

    // scaling
    m_auiSymCount[0] = (m_auiSymCount[0] >> 1);
    m_auiSymCount[1] = (m_auiSymCount[1] >> 1);
    m_auiSymCount[2] = (m_auiSymCount[2] >> 1);
    m_uiCodedFlag = false;
    
    m_uiLen = CAVLC_SYMGRP_SIZE;
  }
  return (uiFlag != 0);
}

ErrVal
UcSymGrpReader::Flush()
{
  m_uiCode         = 0;

  m_uiLen          = CAVLC_SYMGRP_SIZE;

  return Err::m_nOK;
}
ErrVal
UvlcReader::RQdecodeCycleSymbol( UInt& uiCycle )
{
  RNOKS( xGetFlag( uiCycle ) );
  if ( uiCycle > 0 )
  {
    UInt uiTemp;
    RNOKS( xGetFlag( uiTemp ) );
    uiCycle += uiTemp;
  }
  uiCycle++;
  return Err::m_nOK;
}


ErrVal
UvlcReader::RQdecodeDeltaQp( MbDataAccess& rcMbDataAccess)
{
  Int   iDQp = 0;

  DTRACE_T ("DQp");

  RNOKS( xGetSvlcCode( iDQp ) );

  DTRACE_TY ("se(v)");
  DTRACE_N;

  rcMbDataAccess.addDeltaQp( iDQp );

  return Err::m_nOK;
}


ErrVal
UvlcReader::RQdecode8x8Flag( MbDataAccess& rcMbDataAccess,
                             MbDataAccess& rcMbDataAccessBase ) 
{
  UInt uiSymbol = 0;
  
  RNOKS( xGetFlag( uiSymbol ) );
  DTRACE_T( "TRAFO_8x8" );
  DTRACE_V( uiSymbol );
  DTRACE_N;

  rcMbDataAccess    .getMbData().setTransformSize8x8( uiSymbol == 1 );
  rcMbDataAccessBase.getMbData().setTransformSize8x8( uiSymbol == 1 );

  return Err::m_nOK;
}


ErrVal
UvlcReader::RQdecodeCBP_8x8( MbDataAccess& rcMbDataAccess,
                             MbDataAccess& rcMbDataAccessBase,
                             B8x8Idx       c8x8Idx )
{
  UInt  uiSymbol        = 0;
  m_uiCbp8x8 = rcMbDataAccess.getMbData().getMbCbp() & 0x0F;

  uiSymbol = (m_uiCbp8x8 >> c8x8Idx.b8x8Index()) & 0x1;

  if ( uiSymbol )
  {
    rcMbDataAccessBase.getMbData().setMbCbp( rcMbDataAccessBase.getMbData().getMbCbp() | ( 1 << c8x8Idx.b8x8Index() ) );
  }

  DTRACE_T( "CBP_Luma" );
  DTRACE_V( uiSymbol );
  DTRACE_N;

  return Err::m_nOK;
}


ErrVal
UvlcReader::RQdecodeBCBP_4x4(  MbDataAccess&  rcMbDataAccess,
                               MbDataAccess&  rcMbDataAccessBase,
                               Bool           b8x8,