mbdatactrl.cpp

JVT-Z203_jsvm.rar

  H264AVC_DELETE_CLASS( m_pcMbDataAccess );

  H264AVC_DELETE( m_pcMbTCoeffs );
  H264AVC_DELETE( m_apcMbMvdData[1] );
  H264AVC_DELETE( m_apcMbMvdData[0] );
  H264AVC_DELETE( m_apcMbMotionData[1] );
  H264AVC_DELETE( m_apcMbMotionData[0] );
  H264AVC_DELETE( m_pcMbData );
  m_uiSize          = 0;
  return Err::m_nOK;
}

ErrVal MbDataCtrl::xResetData()
{
  UInt uiIdx;
  for( uiIdx = 0; uiIdx < m_uiSize; uiIdx++ )
  {
    m_pcMbData[ uiIdx ].reset();
  }
  for( uiIdx = 0; uiIdx < m_uiSize; uiIdx++ )
  {
    m_pcMbTCoeffs[ uiIdx ].clear();
  }
  for( uiIdx = 0; uiIdx < m_uiSize; uiIdx++ )
  {
    m_apcMbMvdData[0][ uiIdx ].clear();
  }
  for( uiIdx = 0; uiIdx < m_uiSize; uiIdx++ )
  {
    m_apcMbMvdData[1][ uiIdx ].clear();
  }
  for( uiIdx = 0; uiIdx < m_uiSize; uiIdx++ )
  {
    m_apcMbMotionData[0][ uiIdx ].reset();
  }
  for( uiIdx = 0; uiIdx < m_uiSize; uiIdx++ )
  {
    m_apcMbMotionData[1][ uiIdx ].reset();
  }
  return Err::m_nOK;
}


Bool MbDataCtrl::isPicDone( const SliceHeader& rcSH )
{
  return ( m_uiMbProcessed == rcSH.getSPS().getMbInFrame() || m_uiMbProcessed == rcSH.getMbInPic());
}

Bool MbDataCtrl::isFrameDone( const SliceHeader& rcSH )
{
  return ( m_uiMbProcessed == rcSH.getSPS().getMbInFrame());
}


ErrVal MbDataCtrl::init( const SequenceParameterSet& rcSPS )
{
  AOT_DBG( m_bInitDone );

  UInt uiSize = rcSPS.getMbInFrame();

  ROT( 0 == uiSize );
  if( m_uiSize == uiSize )
  {
    RNOK( xResetData() );
  }
  else
  {
    RNOK( xDeleteData() );
    RNOK( xCreateData( uiSize ) );
    m_uiSize = uiSize;
  }

  m_iMbPerLine = rcSPS.getFrameWidthInMbs();

  RNOK( m_cDBFPBuffer   .init( uiSize + 1 ) );
  RNOK( m_cILDBFPBuffer .init( uiSize + 1 ) );
  m_cDBFPBuffer   .clear();
  m_cILDBFPBuffer .clear();
  m_bInitDone     = true;

  return Err::m_nOK;
}

ErrVal
MbDataCtrl::copyMotion( MbDataCtrl& rcMbDataCtrl )
{
  for( UInt n = 0; n < m_uiSize; n++ )
  {
    RNOK( m_pcMbData[n].copyMotion( rcMbDataCtrl.m_pcMbData[n], m_uiSliceId ) );
  }
  m_bPicCodedField = rcMbDataCtrl.m_bPicCodedField;
  return Err::m_nOK;
}



ErrVal
MbDataCtrl::upsampleMotion( SliceHeader*      pcSliceHeader,
                            ResizeParameters* pcResizeParameters,
                            MbDataCtrl*       pcBaseMbDataCtrl, 
                            RefFrameList*     pcRefFrameList0,
                            RefFrameList*     pcRefFrameList1,
                            Bool              bFieldResampling,
                            Bool              bResidualPredCheck,
                            Int               iMvThreshold )
{
  ROF( pcSliceHeader );
  ROF( pcResizeParameters );
  ROF( pcBaseMbDataCtrl );

  MotionUpsampling  cMotionUpsampling( *this, *pcSliceHeader, *pcResizeParameters, *pcBaseMbDataCtrl,
                                       pcRefFrameList0, pcRefFrameList1, bFieldResampling, bResidualPredCheck, iMvThreshold );
  Int               iMbXMax = ( pcResizeParameters->m_iFrameWidth  >> 4 );
  Int               iMbYMax = ( pcResizeParameters->m_iFrameHeight >> 4 ) >> ( pcResizeParameters->m_bFieldPicFlag ? 1 : 0 );

  for( Int iMbY = 0; iMbY < iMbYMax; iMbY++ )
  for( Int iMbX = 0; iMbX < iMbXMax; iMbX++ )
  {
    RNOK( cMotionUpsampling.resample( iMbX, iMbY ) );
  }
  return Err::m_nOK;
}


ErrVal MbDataCtrl::uninit()
{
  m_ucLastMbQp      = 0;
  m_ucLastMbQp4LF   = 0;
  m_uiMbStride      = 0;
  m_uiMbOffset      = 0;
  m_iMbPerLine      = 0;
  m_iMbPerColumn    = 0;
  m_uiMbProcessed   = 0;
  m_uiSliceId       = 0;
  m_pcMbDataCtrl0L1 = 0;

  for( UInt n = 0; n < m_cDBFPBuffer.size(); n++ )
  {
    delete m_cDBFPBuffer.get( n );
    m_cDBFPBuffer.set( n, 0 );
  }
  RNOK( m_cDBFPBuffer.uninit() );
  for( UInt m = 0; m < m_cILDBFPBuffer.size(); m++ )
  {
    delete m_cILDBFPBuffer.get( m );
    m_cILDBFPBuffer.set( m, 0 );
  }
  RNOK( m_cILDBFPBuffer.uninit() );

  m_bInitDone = false;
  return Err::m_nOK;
}


ErrVal MbDataCtrl::reset()
{
  m_ucLastMbQp      = 0;
  m_ucLastMbQp4LF   = 0;
  m_uiMbProcessed   = 0;
  m_uiSliceId       = 0;
  m_pcMbDataCtrl0L1 = 0;
  return Err::m_nOK;
}

//TMM {
ErrVal MbDataCtrl::initUsedField( SliceHeader& rcSH, RefFrameList& rcRefFrameList1 )
{
   if( /*!rcSH.getFieldPicFlag() &&*/
        rcRefFrameList1.getSize() !=0 && 
        rcRefFrameList1[1]->getPic(TOP_FIELD) != NULL && 
        rcRefFrameList1[1]->getPic(BOT_FIELD) != NULL )
   {
     Int iCurrPoc     = rcSH.getPoc();
     Int iTopDiffPoc  = iCurrPoc - rcRefFrameList1[1]->getPic(TOP_FIELD)->getPoc();
     Int iBotDiffPoc  = iCurrPoc - rcRefFrameList1[1]->getPic(BOT_FIELD)->getPoc();
     m_bUseTopField   = ( abs( iTopDiffPoc ) < abs( iBotDiffPoc ) );
   }

  return Err::m_nOK;
}
//TMM }

ErrVal MbDataCtrl::initSlice( SliceHeader& rcSH, 
                              ProcessingState eProcessingState, 
                              Bool bDecoder, 
                              MbDataCtrl* pcMbDataCtrl )
{
  AOF_DBG( m_bInitDone );

  m_eProcessingState  = eProcessingState;
  m_pcMbDataCtrl0L1   = NULL;
	m_iColocatedOffset  = 0;
  m_bPicCodedField    = rcSH.getFieldPicFlag();

  if( rcSH.isBSlice() )
  {
    if( pcMbDataCtrl )
    {
      m_pcMbDataCtrl0L1 = pcMbDataCtrl;
    }
    if( rcSH.isH264AVCCompatible() && rcSH.isBSlice() && bDecoder && m_eProcessingState == DECODE_PROCESS && m_pcMbDataCtrl0L1 )
    {
      const RefFrameList* pcRefFrameList  = rcSH.getRefFrameList( rcSH.getPicType(), LIST_1 );
      ROF( pcRefFrameList );
      const Frame*        pcPic0L1        = pcRefFrameList->getEntry( 0 );
      ROF( pcPic0L1 );
      const Frame*        pcFrame0L1      = pcPic0L1->getFrame();
      ROF( pcFrame0L1 );

      Int iCurrPoc      = rcSH.getPoc();
      Int iTopDiffPoc   = iCurrPoc - pcFrame0L1->getTopFieldPoc();
      Int iBotDiffPoc   = iCurrPoc - pcFrame0L1->getBotFieldPoc();
      m_bUseTopField    = ( abs( iTopDiffPoc ) < abs( iBotDiffPoc ) );

      if( pcMbDataCtrl )
      {
        m_pcMbDataCtrl0L1 = pcMbDataCtrl;
      }

      if( FRAME != rcSH.getPicType() )
      {
        if( pcPic0L1->getPicType() != rcSH.getPicType() && m_pcMbDataCtrl0L1->isPicCodedField() )
        {
          m_iColocatedOffset = m_iMbPerLine;
        }
      }
    }
  }

  if( PARSE_PROCESS == m_eProcessingState || ENCODE_PROCESS == m_eProcessingState )
  {
    m_uiSliceId++;

    DBFilterParameter* pcDBF   = new DBFilterParameter( rcSH.getDeblockingFilterParameter() );
    DBFilterParameter* pcILDBF = new DBFilterParameter( rcSH.getInterLayerDeblockingFilterParameter() );
    if( m_cDBFPBuffer.get( m_uiSliceId ) )
    {
      delete m_cDBFPBuffer.get( m_uiSliceId );
      m_cDBFPBuffer  .set( m_uiSliceId, 0 );
    }
    if( m_cILDBFPBuffer.get( m_uiSliceId ) )
    {
      delete m_cILDBFPBuffer.get( m_uiSliceId );
      m_cILDBFPBuffer.set( m_uiSliceId, 0 );
    }
    m_cDBFPBuffer  .set( m_uiSliceId, pcDBF );
    m_cILDBFPBuffer.set( m_uiSliceId, pcILDBF );
  }
  m_pcSliceHeader = &rcSH;


  Int iMbPerColumn  = rcSH.getSPS().getFrameHeightInMbs ();
  m_iMbPerLine      = rcSH.getSPS().getFrameWidthInMbs  ();
  m_uiMbOffset      = rcSH.getBottomFieldFlag() ? 1 * m_iMbPerLine : 0;
  m_uiMbStride      = rcSH.getFieldPicFlag   () ? 2 * m_iMbPerLine : m_iMbPerLine;
  m_iMbPerColumn    = rcSH.getFieldPicFlag   () ?  iMbPerColumn>>1 : iMbPerColumn;
  m_ucLastMbQp      = rcSH.getSliceQp();

  H264AVC_DELETE_CLASS( m_pcMbDataAccess );
  return Err::m_nOK;
}


const MbData& MbDataCtrl::xGetColMbData( UInt uiIndex )
{
  return (( m_pcMbDataCtrl0L1 == NULL ) ? xGetOutMbData() : m_pcMbDataCtrl0L1->getMbData( uiIndex ));
}

const MbData& MbDataCtrl::xGetRefMbData( UInt uiSliceId, 
                                         Int uiCurrSliceID, 
                                         Int iMbY, 
                                         Int iMbX, 
                                         Bool bLoopFilter )
{
  // check whether ref mb is inside
  ROTRS( iMbX < 0,               xGetOutMbData() );
  ROTRS( iMbY < 0,               xGetOutMbData() );
  ROTRS( iMbX >= m_iMbPerLine,   xGetOutMbData() );
  ROTRS( iMbY >= m_iMbPerColumn, xGetOutMbData() );

  //--ICU/ETRI FMO Implementation
//  ROTRS( uiCurrSliceID != getSliceGroupIDofMb(iMbY * m_uiMbStride + iMbX + m_uiMbOffset ) , xGetOutMbData() );
  ROTRS( uiCurrSliceID != getSliceGroupIDofMb(iMbY * (m_uiMbStride>>(UInt)m_pcSliceHeader->getFieldPicFlag()) + iMbX ) , xGetOutMbData() ); //TMM_INTERLACE

  // get the ref mb data
  const MbData& rcMbData = getMbData( iMbY * m_uiMbStride + iMbX + m_uiMbOffset );
  // test slice id
  return (( rcMbData.getSliceId() == uiSliceId || bLoopFilter ) ? rcMbData : xGetOutMbData() );
}

ErrVal MbDataCtrl::initMb( MbDataAccess*& rpcMbDataAccess, UInt uiMbY, UInt uiMbX, const Bool bFieldFlag, const Int iForceQp )
{
  UInt     uiCurrIdx    = uiMbY        * m_uiMbStride + uiMbX + m_uiMbOffset;
  MbData&  rcMbDataCurr = m_pcMbData[ uiCurrIdx ];
  rcMbDataCurr.setFieldFlag( bFieldFlag );

  return initMb( rpcMbDataAccess, uiMbY, uiMbX, iForceQp );
}

ErrVal MbDataCtrl::initMb( MbDataAccess*& rpcMbDataAccess, UInt uiMbY, UInt uiMbX, const Int iForceQp )
{
  ROF( m_bInitDone );

  AOT_DBG( uiMbY * m_uiMbStride + uiMbX + m_uiMbOffset >= m_uiSize );

  Bool     bLf          = (m_eProcessingState == POST_PROCESS);
  Bool     bMbAff       = m_pcSliceHeader->isMbaffFrame();
  Bool     bTopMb       = ((bMbAff && (uiMbY % 2)) ? false : true);
  UInt     uiMbYComp    = ( bMbAff ? ( bTopMb ? uiMbY+1 : uiMbY-1 ) : uiMbY );
  UInt     uiCurrIdx    = uiMbY * m_uiMbStride + uiMbX + m_uiMbOffset;
  UInt     uiCompIdx    = uiMbYComp    * m_uiMbStride + uiMbX + m_uiMbOffset;
  ROT( uiCompIdx >= m_uiSize );
  ROT( uiCurrIdx >= m_uiSize );
  MbData&  rcMbDataCurr = m_pcMbData[ uiCurrIdx ];
	MbData&  rcMbDataComp = m_pcMbData[ uiCompIdx ];


    //----- get co-located MbIndex -----
  UInt     uiIdxColTop;
  UInt     uiIdxColBot;
  if( ! m_pcSliceHeader->getFieldPicFlag() )
  {
    UInt  uiMbYColTop = 2 * ( uiMbY / 2 );
    uiIdxColTop       = uiMbYColTop * m_uiMbStride + uiMbX + m_uiMbOffset;
    uiIdxColBot       = uiIdxColTop + m_uiMbStride;
    if( uiIdxColBot >= m_pcSliceHeader->getMbInPic() )
    {
      uiIdxColBot = uiIdxColTop;
    }
  }
  else if( ! m_pcSliceHeader->getBottomFieldFlag() )
  {
    uiIdxColTop       = uiCurrIdx   + m_iColocatedOffset;
    uiIdxColBot       = uiIdxColTop - m_iColocatedOffset + m_iMbPerLine;
  }
  else
  {
    uiIdxColBot       = uiCurrIdx   - m_iColocatedOffset;
    uiIdxColTop       = uiIdxColBot + m_iColocatedOffset - m_iMbPerLine;
  }
  
  if( m_pcMbDataAccess )
  {
    m_ucLastMbQp    = m_pcMbDataAccess->getMbData().getQp();
    m_ucLastMbQp4LF = m_pcMbDataAccess->getMbData().getQp4LF();
  }

  UInt uiSliceId = rcMbDataCurr.getSliceId();
  if( PARSE_PROCESS == m_eProcessingState || ENCODE_PROCESS == m_eProcessingState)
  {
    if( 0 == uiSliceId )
    {