mbdatactrl.cpp

JVT-Z203_jsvm.rar

  Int   iAbsMvDiffThreshold = ( m_cMvScale.m_bRSChangeFlag ? 0 : 1 );
  Int   iXO                 = ( i8x8BlkIdx  & 1 ) << 1;
  Int   iYO                 = ( i8x8BlkIdx >> 1 ) << 1;
  Bool  bHorMatch           = true;
  Bool  bVerMatch           = true;

  //===== derive partition size =====
  {
    for( Int iListIdx = 0; iListIdx < m_iMaxListIdx; iListIdx++ )
    {
      bHorMatch = bHorMatch && ( xMvDiff( m_aaacMv[iListIdx][iXO  ][iYO  ], m_aaacMv[iListIdx][iXO+1][iYO  ] ) <= iAbsMvDiffThreshold );
      bHorMatch = bHorMatch && ( xMvDiff( m_aaacMv[iListIdx][iXO  ][iYO+1], m_aaacMv[iListIdx][iXO+1][iYO+1] ) <= iAbsMvDiffThreshold );
      bVerMatch = bVerMatch && ( xMvDiff( m_aaacMv[iListIdx][iXO  ][iYO  ], m_aaacMv[iListIdx][iXO  ][iYO+1] ) <= iAbsMvDiffThreshold );
      bVerMatch = bVerMatch && ( xMvDiff( m_aaacMv[iListIdx][iXO+1][iYO  ], m_aaacMv[iListIdx][iXO+1][iYO+1] ) <= iAbsMvDiffThreshold );
    }
    const BlkMode aiBlkMode[4]  = { BLK_4x4, BLK_8x4, BLK_4x8, BLK_8x8 };
    m_aeBlkMode[i8x8BlkIdx]     = aiBlkMode[ ( bVerMatch ? 2 : 0 ) + ( bHorMatch ? 1 : 0 ) ];
  }
  ROTRS( m_cMvScale.m_bRSChangeFlag,          Err::m_nOK );
  ROTRS( m_aeBlkMode[i8x8BlkIdx] == BLK_4x4,  Err::m_nOK );

  //===== combine motion vectors =====
  {
    for( Int iListIdx = 0; iListIdx < m_iMaxListIdx; iListIdx++ )
    {
      switch( m_aeBlkMode[i8x8BlkIdx] )
      {
      case BLK_8x8:
        {
          Mv  cNewMv  = ( m_aaacMv[iListIdx][iXO  ][iYO  ] + m_aaacMv[iListIdx][iXO+1][iYO  ] + 
                          m_aaacMv[iListIdx][iXO  ][iYO+1] + m_aaacMv[iListIdx][iXO+1][iYO+1] + Mv(2,2) ) >> 2;
          m_aaacMv[iListIdx][iXO  ][iYO  ]  = cNewMv;
          m_aaacMv[iListIdx][iXO+1][iYO  ]  = cNewMv;
          m_aaacMv[iListIdx][iXO  ][iYO+1]  = cNewMv;
          m_aaacMv[iListIdx][iXO+1][iYO+1]  = cNewMv;
          break;
        }
      case BLK_8x4:
        {
          Mv  cNewMvA = ( m_aaacMv[iListIdx][iXO  ][iYO  ] + m_aaacMv[iListIdx][iXO+1][iYO  ] + Mv(1,1) ) >> 1;
          Mv  cNewMvB = ( m_aaacMv[iListIdx][iXO  ][iYO+1] + m_aaacMv[iListIdx][iXO+1][iYO+1] + Mv(1,1) ) >> 1;
          m_aaacMv[iListIdx][iXO  ][iYO  ]  = cNewMvA;
          m_aaacMv[iListIdx][iXO+1][iYO  ]  = cNewMvA;
          m_aaacMv[iListIdx][iXO  ][iYO+1]  = cNewMvB;
          m_aaacMv[iListIdx][iXO+1][iYO+1]  = cNewMvB;
          break;
        }
      case BLK_4x8:
        {
          Mv  cNewMvA = ( m_aaacMv[iListIdx][iXO  ][iYO  ] + m_aaacMv[iListIdx][iXO  ][iYO+1] + Mv(1,1) ) >> 1;
          Mv  cNewMvB = ( m_aaacMv[iListIdx][iXO+1][iYO  ] + m_aaacMv[iListIdx][iXO+1][iYO+1] + Mv(1,1) ) >> 1;
          m_aaacMv[iListIdx][iXO  ][iYO  ]  = cNewMvA;
          m_aaacMv[iListIdx][iXO+1][iYO  ]  = cNewMvB;
          m_aaacMv[iListIdx][iXO  ][iYO+1]  = cNewMvA;
          m_aaacMv[iListIdx][iXO+1][iYO+1]  = cNewMvB;
          break;
        }
      default:
        ROT(1);
      }
    }
  }

  return Err::m_nOK;
}


Bool
MotionUpsampling::x8x8BlocksHaveSameMotion( ListIdx eListIdx, Int i8x8IdxA, Int i8x8IdxB )
{
  // reference indexes
  ROFRS( m_aaaiRefIdx[eListIdx][i8x8IdxA&1][i8x8IdxA>>1] == m_aaaiRefIdx[eListIdx][i8x8IdxB&1][i8x8IdxB>>1], false );
  // motion vectors
  ROFRS( m_aaacMv[eListIdx][(i8x8IdxA&1)<<1][(i8x8IdxA>>1)<<1] == m_aaacMv[eListIdx][(i8x8IdxB&1)<<1][(i8x8IdxB>>1)<<1], false );
  return true;
}


ErrVal
MotionUpsampling::xDeriveMbMode()
{
  m_eMbMode = MODE_8x8;
  ROFRS( m_aeBlkMode[0] == BLK_8x8, Err::m_nOK );
  ROFRS( m_aeBlkMode[1] == BLK_8x8, Err::m_nOK );
  ROFRS( m_aeBlkMode[2] == BLK_8x8, Err::m_nOK );
  ROFRS( m_aeBlkMode[3] == BLK_8x8, Err::m_nOK );

  //===== summarize 8x8 blocks when possible =====
  Bool  bHorMatch   = true;
  Bool  bVerMatch   = true;
  for( Int iListIdx = 0; iListIdx < m_iMaxListIdx; iListIdx++ )
  {
    bHorMatch = bHorMatch && x8x8BlocksHaveSameMotion( ListIdx( iListIdx ), 0, 1 );
    bHorMatch = bHorMatch && x8x8BlocksHaveSameMotion( ListIdx( iListIdx ), 2, 3 );
    bVerMatch = bVerMatch && x8x8BlocksHaveSameMotion( ListIdx( iListIdx ), 0, 2 );
    bVerMatch = bVerMatch && x8x8BlocksHaveSameMotion( ListIdx( iListIdx ), 1, 3 );
  }
  const MbMode aiMbMode[4]  = { MODE_8x8, MODE_16x8, MODE_8x16, MODE_16x16 };
  m_eMbMode                 = aiMbMode[ ( bVerMatch ? 2 : 0 ) + ( bHorMatch ? 1 : 0 ) ];
  return Err::m_nOK;
}


ErrVal
MotionUpsampling::xDeriveFwdBwd()
{
  m_uiFwdBwd = 0;
  for( Int n = 3; n >= 0; n--)
  {
    m_uiFwdBwd <<= 4;
    m_uiFwdBwd  += ( m_aaaiRefIdx[0][n&1][n>>1] > 0 ? 1 : 0 );
    m_uiFwdBwd  += ( m_aaaiRefIdx[1][n&1][n>>1] > 0 ? 2 : 0 );
  }
  return Err::m_nOK;
}


ErrVal
MotionUpsampling::xSetInterIntraIdc()
{
  if( m_cMvScale.m_bRSChangeFlag )
  {
    m_aabBaseIntra[0][0]  = false;
    m_aabBaseIntra[0][1]  = false;
    m_aabBaseIntra[1][0]  = false;
    m_aabBaseIntra[1][1]  = false;
    return Err::m_nOK;
  }

  for( Int iY = 0; iY < 2; iY++ )
  for( Int iX = 0; iX < 2; iX++ )
  {
    Int iXPos     = iX * 15;
    Int iYPos     = iY * 15;
    Int iPartIdc  = -2;
    RNOK( xGetRefLayerPartIdc( iXPos, iYPos, iPartIdc ) );
    m_aabBaseIntra[iX][iY] = ( iPartIdc == -1 );
  }
  return Err::m_nOK;   
}


ErrVal
MotionUpsampling::xSetResPredSafeFlag()
{
  ROFRS( m_bCheckResidualPred,        Err::m_nOK );
  ROTRS( m_cMvScale.m_bRSChangeFlag,  Err::m_nOK );

  for( Int iY = 0; iY < 4 && m_bResPredSafe; iY++ )
  for( Int iX = 0; iX < 4 && m_bResPredSafe; iX++ )
  {
    Int   iXPos0          = ( iX << 2 );
    Int   iYPos0          = ( iY << 2 );
    Bool  bSamePartition  = true;
    Bool  bSomeNoInter    = false;
    Int   aiPartIdc[4], k;
    for( k = 0; k < 4; k++ )
    {
      RNOK( xGetRefLayerPartIdc( iXPos0+3*(k&1), iYPos0+3*(k>>1), aiPartIdc[k] ) );
      bSamePartition  = ( bSamePartition && ( aiPartIdc[k] == aiPartIdc[0] ) );
      bSomeNoInter    = ( bSomeNoInter   || ( aiPartIdc[k] < 0 ) );
    }
    if( bSamePartition || bSomeNoInter )
    {
      m_bResPredSafe  = bSomeNoInter;
      continue;
    }
      
    //===== check differences =====
    for( Int iListIdx = 0; iListIdx < 2 && m_bResPredSafe; iListIdx++ )
    {
      Int aiRefIdx[4];
      Mv  acMv    [4];
      for( k = 0; k < 4; k++ )
      {
        Int           iMbIdxBase        = aiPartIdc[k] >> 4;
        B4x4Idx       c4x4IdxBase       = aiPartIdc[k] & 15;
        MbData&       rcMbDataBase      = m_rcMbDataCtrlBase.getMbDataByIndex ( (UInt)iMbIdxBase );
        MbMotionData& rcMotionDataBase  = rcMbDataBase      .getMbMotionData  ( ListIdx( iListIdx ) );
        aiRefIdx[k] = rcMotionDataBase.getRefIdx( c4x4IdxBase );
        acMv    [k] = rcMotionDataBase.getMv    ( c4x4IdxBase );
      }
      //----- check reference indices -----
      for( k = 0; k < 4 && m_bResPredSafe; k++ )
      {
        m_bResPredSafe = ( aiRefIdx[k] == aiRefIdx[0] );
      }
      //----- check motion vectors -----
      if( m_bResPredSafe )
      {
        Mv cMvAverage = ( acMv[0] + acMv[1] + acMv[2] + acMv[3] + Mv(2,2) ) >> 2;

        for( k = 0; k < 4 && m_bResPredSafe; k++ )
        {
          m_bResPredSafe = ( acMv[k].getAbsMvDiff( cMvAverage ) <= m_iMvThreshold );
        }
      }
    }
  }
  return Err::m_nOK;   
}


ErrVal
MotionUpsampling::xSetPredMbData()
{
  //=== get MbData reference ===
  Int           iFieldPic     = ( m_rcResizeParameters.m_bFieldPicFlag ? 1 : 0 );
  Int           iMbStride     = ( m_rcResizeParameters.m_iFrameWidth >> 4 ) << iFieldPic;
  Int           iMbOffset     = ( m_rcResizeParameters.m_iFrameWidth >> 4 )  * iFieldPic;
  Int           iMbIdx        = iMbOffset + m_iMbYCurr * iMbStride + m_iMbXCurr;
  MbData&       rcMbData      = m_rcMbDataCtrlCurr.getMbDataByIndex( (UInt)iMbIdx );
  MbMotionData* apcMotion[2]  = { &rcMbData.getMbMotionData( LIST_0 ), &rcMbData.getMbMotionData( LIST_1 ) };

  //=== reset MbDataStruct data data ===
  rcMbData.clear();

  //=== set motion data (ref idx & motion vectors ) ===
  if( ! m_bInCropWindow || m_bIntraBL )
  {
    for( Int iListIdx = 0; iListIdx < 2; iListIdx++ )
    {
      apcMotion[iListIdx]->clear( BLOCK_NOT_PREDICTED );
    }
  }
  else
  {
    Int    iListIdx = 0;
    for( ; iListIdx < m_iMaxListIdx; iListIdx++ )
    {
      for( B8x8Idx c8x8Idx; c8x8Idx.isLegal(); c8x8Idx++ )
      {
        apcMotion[iListIdx]->setRefIdx( m_aaaiRefIdx[iListIdx][c8x8Idx.b8x8Index()&1][c8x8Idx.b8x8Index()>>1], c8x8Idx.b8x8() );
      }
      for( B4x4Idx c4x4Idx; c4x4Idx.isLegal(); c4x4Idx++ )
      {
        apcMotion[iListIdx]->setMv( m_aaacMv[iListIdx][c4x4Idx.x()][c4x4Idx.y()], c4x4Idx );
      }
    }
    for( ; iListIdx < 2; iListIdx++ )
    {
      apcMotion[iListIdx]->clear( BLOCK_NOT_PREDICTED );
    }
  }
  apcMotion[0]->setFieldMode( m_bCurrFieldMb );
  apcMotion[1]->setFieldMode( m_bCurrFieldMb );

  //=== set general Mb data ===
  rcMbData.setInCropWindowFlag( m_bInCropWindow );
  rcMbData.setFieldFlag       ( m_bCurrFieldMb );
  rcMbData.setSafeResPred     ( m_bResPredSafe );
  if( m_bInCropWindow )
  {
    rcMbData.setMbMode( m_eMbMode );
    rcMbData.setFwdBwd( (UShort)m_uiFwdBwd );
    for( Int iBlk = 0; iBlk < 4; iBlk++ )
    {
      rcMbData.setBlkMode   ( Par8x8( iBlk ), m_aeBlkMode[iBlk] );
      rcMbData.setBaseIntra ( iBlk&1, iBlk>>1, m_aabBaseIntra[iBlk&1][iBlk>>1] );
    }
  }

  //=== values for SNR scalability ===
  if( ( m_bSCoeffPred || m_bTCoeffPred ) && m_bInCropWindow )
  {
    Int     iMbXBase      = m_iMbXCurr -   ( m_rcResizeParameters.m_iLeftFrmOffset >> 4 );
    Int     iMbYBase      = m_iMbYCurr - ( ( m_rcResizeParameters.m_iTopFrmOffset >> 4 ) >> iFieldPic );
    Int     iMbStrideBase = ( m_rcResizeParameters.m_iRefLayerFrmWidth >> 4 ) << iFieldPic;
    Int     iMbOffsetBase = ( m_rcResizeParameters.m_iRefLayerFrmWidth >> 4 )  * iFieldPic;
    Int     iMbIdxBase    = iMbOffsetBase + iMbYBase * iMbStrideBase + iMbXBase;
    MbData& rcMbDataBase  = m_rcMbDataCtrlBase.getMbDataByIndex( (UInt)iMbIdxBase );

    rcMbData.copyTCoeffs    ( rcMbDataBase );
    rcMbData.setBLSkipFlag  ( rcMbDataBase.getBLSkipFlag() );
    if( m_bIntraBL )
    {
      rcMbData.setMbMode    ( rcMbDataBase.getMbMode() );
    }
    if( m_bTCoeffPred )
    {
      rcMbData.copyIntraPred( rcMbDataBase );
    }
  }
 
  return Err::m_nOK;
}




MbDataCtrl::MbDataCtrl():
  m_pcMbTCoeffs     ( NULL ),
  m_pcMbData        ( NULL ),
  m_pcMbDataAccess  ( NULL ),
  m_pcSliceHeader   ( NULL ),
  m_ucLastMbQp      ( 0 ),
  m_ucLastMbQp4LF   ( 0 ),
  m_uiMbStride      ( 0 ),
  m_uiMbOffset      ( 0 ),
  m_iMbPerLine      ( 0 ),
  m_iMbPerColumn    ( 0 ),
  m_uiSize          ( 0 ),
  m_uiMbProcessed   ( 0 ),
  m_uiSliceId       ( 0 ),
	m_iColocatedOffset( 0 ),
  m_eProcessingState( PRE_PROCESS),
  m_pcMbDataCtrl0L1 ( NULL ),
  m_bUseTopField    ( false ),
  m_bPicCodedField  ( false ),
  m_bInitDone       ( false )
{
  m_apcMbMvdData    [LIST_0]  = NULL;
  m_apcMbMvdData    [LIST_1]  = NULL;
  m_apcMbMotionData [LIST_0]  = NULL;
  m_apcMbMotionData [LIST_1]  = NULL;
}

MbDataCtrl::~MbDataCtrl()
{
  AOT( xDeleteData() );
  AOT( m_bInitDone );
}

ErrVal MbDataCtrl::xCreateData( UInt uiSize )
{
  uiSize++;

  ROT( NULL == ( m_pcMbTCoeffs         = new MbTransformCoeffs [ uiSize ] ) );
  ROT( NULL == ( m_apcMbMotionData[0]  = new MbMotionData      [ uiSize ] ) );
  ROT( NULL == ( m_apcMbMotionData[1]  = new MbMotionData      [ uiSize ] ) );
  ROT( NULL == ( m_apcMbMvdData[0]     = new MbMvData          [ uiSize ] ) );
  ROT( NULL == ( m_apcMbMvdData[1]     = new MbMvData          [ uiSize ] ) );
  ROT( NULL == ( m_pcMbData            = new MbData            [ uiSize ] ) );

  for( UInt uiIdx = 0; uiIdx < uiSize; uiIdx++ )
  {
    m_pcMbData[ uiIdx ].init( m_pcMbTCoeffs        + uiIdx,
                              m_apcMbMvdData   [0] + uiIdx,
                              m_apcMbMvdData   [1] + uiIdx,
                              m_apcMbMotionData[0] + uiIdx,
                              m_apcMbMotionData[1] + uiIdx );
  }

  // clear outside mb data
  m_pcMbData[uiSize-1].getMbTCoeffs().setAllCoeffCount( 0 );
  m_pcMbData[uiSize-1].initMbData( 0, 0, MSYS_UINT_MAX, NOT_SPECIFIED_SLICE );

  return Err::m_nOK;
}

ErrVal MbDataCtrl::xDeleteData()
{