Пример #1
0
ErrVal Frame::removeFieldBuffer( PicType ePicType )
{
  ASSERT( m_ePicType==FRAME );

  if( ePicType==TOP_FIELD )
  {
		if( NULL != m_pcFrameTopField )
    {
      // remove the default yuv memory from buffers
      RNOK( m_pcFrameTopField->uninit () );
      RNOK( m_pcFrameTopField->destroy() );
      m_pcFrameTopField = NULL;
    }
  }
  else if( ePicType==BOT_FIELD )
  {
    if( NULL != m_pcFrameBotField )
    {
      // remove the default yuv memory from buffers
      RNOK( m_pcFrameBotField->uninit () );
      RNOK( m_pcFrameBotField->destroy() );
      m_pcFrameBotField = NULL;
    }
  }

  return Err::m_nOK;
}
Пример #2
0
ErrVal
MVCScalableModifyCode::WriteTrailingBits()
{
	RNOK( WriteFlag( 1 ) );
	RNOK( WriteAlignZero() );
	return Err::m_nOK;
}
Пример #3
0
ErrVal
ReconstructionBypass::xPad8x8Blk_MbAff( YuvMbBufferExtension* pcBuffer, UInt ui8x8Blk, Bool bV0, Bool bV1, Bool bH, Bool bC0, Bool bC1 )
{
  Bool    bSwitch     = ( !bV0 && bV1 && bH ) || ( !bV0 && !bH && !bC0 && ( bV1 || bC1 ) );
  Bool    bDouble     = ( bV0 && bV1 ) || ( ( bV0 || bC0 ) && !bH && ( bV1 || bC1 ) );
  ROT( bSwitch && bDouble );
  Bool    bFromAbove  = ( ui8x8Blk < 2 );
  Bool    bFromLeft   = ( ui8x8Blk % 2 == 0 );
  B8x8Idx cIdx( (Par8x8)ui8x8Blk );

  if( bDouble )
  {
    RNOK( xPadBlock_MbAff( pcBuffer, cIdx, bV0, bH, bC0, true,   bFromAbove, bFromLeft ) );
    RNOK( xPadBlock_MbAff( pcBuffer, cIdx, bV1, bH, bC1, true,  !bFromAbove, bFromLeft ) );
  }
  else if( bSwitch )
  {
    RNOK( xPadBlock_MbAff( pcBuffer, cIdx, bV1, bH, bC1, false, !bFromAbove, bFromLeft ) );
  }
  else
  {
    RNOK( xPadBlock_MbAff( pcBuffer, cIdx, bV0, bH, bC0, false,  bFromAbove, bFromLeft ) );
  }

  return Err::m_nOK;
}
Пример #4
0
ErrVal MbDecoder::xDecodeMbIntra4x4( MbDataAccess& rcMbDataAccess, 
                                     IntYuvMbBuffer& cYuvMbBuffer,
                                     IntYuvMbBuffer&  rcPredBuffer )
{
  Int  iStride = cYuvMbBuffer.getLStride();

  MbTransformCoeffs& rcCoeffs = m_cTCoeffs;

  for( B4x4Idx cIdx; cIdx.isLegal(); cIdx++ )
  {
    rcMbDataAccess.getMbData().intraPredMode( cIdx ) = rcMbDataAccess.decodeIntraPredMode( cIdx );

    XPel* puc = cYuvMbBuffer.getYBlk( cIdx );

    UInt uiPredMode = rcMbDataAccess.getMbData().intraPredMode( cIdx );
    RNOK( m_pcIntraPrediction->predictLumaBlock( puc, iStride, uiPredMode, cIdx ) );

    rcPredBuffer.loadLuma( cYuvMbBuffer, cIdx );

    if( rcMbDataAccess.getMbData().is4x4BlkCoded( cIdx ) )
    {
      RNOK( m_pcTransform->invTransform4x4Blk( puc, iStride, rcCoeffs.get( cIdx ) ) );
    }
  }

  UInt uiChromaCbp = rcMbDataAccess.getMbData().getCbpChroma4x4();
  RNOK( xDecodeChroma( rcMbDataAccess, cYuvMbBuffer, rcPredBuffer, uiChromaCbp, true ) );

  return Err::m_nOK;
}
Пример #5
0
ErrVal MbDecoder::xDecodeChroma( MbDataAccess& rcMbDataAccess, YuvMbBuffer& rcRecYuvBuffer, UInt uiChromaCbp, Bool bPredChroma )
{
  MbTransformCoeffs& rcCoeffs = m_cTCoeffs;

  Pel*  pucCb   = rcRecYuvBuffer.getMbCbAddr();
  Pel*  pucCr   = rcRecYuvBuffer.getMbCrAddr();
  Int   iStride = rcRecYuvBuffer.getCStride();

  if( bPredChroma )
  {
    RNOK( m_pcIntraPrediction->predictChromaBlock( pucCb, pucCr, iStride, rcMbDataAccess.getMbData().getChromaPredMode() ) );
  }

  ROTRS( 0 == uiChromaCbp, Err::m_nOK );

  Int                 iScale;
  Bool                bIntra    = rcMbDataAccess.getMbData().isIntra();
  UInt                uiUScalId = ( bIntra ? 1 : 4 );
  UInt                uiVScalId = ( bIntra ? 2 : 5 );
  const UChar*        pucScaleU = rcMbDataAccess.getSH().getScalingMatrix( uiUScalId );
  const UChar*        pucScaleV = rcMbDataAccess.getSH().getScalingMatrix( uiVScalId );

  // scaling has already been performed on DC coefficients
  iScale = ( pucScaleU ? pucScaleU[0] : 16 );
  m_pcTransform->invTransformChromaDc( rcCoeffs.get( CIdx(0) ), iScale );     
  iScale = ( pucScaleV ? pucScaleV[0] : 16 );
  m_pcTransform->invTransformChromaDc( rcCoeffs.get( CIdx(4) ), iScale );

  RNOK( m_pcTransform->invTransformChromaBlocks( pucCb, iStride, rcCoeffs.get( CIdx(0) ) ) );
  RNOK( m_pcTransform->invTransformChromaBlocks( pucCr, iStride, rcCoeffs.get( CIdx(4) ) ) );

  return Err::m_nOK;
}
Пример #6
0
ErrVal MbDecoder::xDecodeMbIntra16x16( MbDataAccess&    rcMbDataAccess,
                                       IntYuvMbBuffer&  cYuvMbBuffer,
                                       IntYuvMbBuffer& rcPredBuffer )
{
  Int  iStride = cYuvMbBuffer.getLStride();

  RNOK( m_pcIntraPrediction->predictLumaMb( cYuvMbBuffer.getMbLumAddr(), iStride, rcMbDataAccess.getMbData().intraPredMode() ) );

  rcPredBuffer.loadLuma( cYuvMbBuffer );

  MbTransformCoeffs& rcCoeffs = m_cTCoeffs;

  Quantizer           cQuantizer;   cQuantizer.setQp    ( rcMbDataAccess, false );
  const QpParameter   rcLQp       = cQuantizer.getLumaQp();
  Int                 iScaleY     = g_aaiDequantCoef[rcLQp.rem()][0] << rcLQp.per();
  const UChar*        pucScaleY   = rcMbDataAccess.getSH().getScalingMatrix( 0 );

  if( pucScaleY )
  {
    iScaleY  *= pucScaleY[0];
    iScaleY >>= 4;
  }

  RNOK( m_pcTransform->invTransformDcCoeff( rcCoeffs.get( B4x4Idx(0) ), iScaleY ) );

  for( B4x4Idx cIdx; cIdx.isLegal(); cIdx++ )
  {
    RNOK( m_pcTransform->invTransform4x4Blk( cYuvMbBuffer.getYBlk( cIdx ), iStride, rcCoeffs.get( cIdx ) ) );
  }

  UInt uiChromaCbp = rcMbDataAccess.getMbData().getCbpChroma16x16();
  RNOK( xDecodeChroma( rcMbDataAccess, cYuvMbBuffer, rcPredBuffer, uiChromaCbp, true ) );

  return Err::m_nOK;
}
Пример #7
0
ErrVal MbDecoder::calcMv( MbDataAccess& rcMbDataAccess,
                          MbDataAccess* pcMbDataAccessBaseMotion )
{
  if( rcMbDataAccess.getMbData().getBLSkipFlag() )
  {
    return Err::m_nOK;
  }

  if( rcMbDataAccess.getMbData().getMbMode() == INTRA_4X4 )
  {
    //----- intra prediction -----
    rcMbDataAccess.getMbMotionData( LIST_0 ).setRefIdx( BLOCK_NOT_PREDICTED );
    rcMbDataAccess.getMbMotionData( LIST_0 ).setAllMv ( Mv::ZeroMv() );
    rcMbDataAccess.getMbMotionData( LIST_1 ).setRefIdx( BLOCK_NOT_PREDICTED );
    rcMbDataAccess.getMbMotionData( LIST_1 ).setAllMv ( Mv::ZeroMv() );
  }
  else
  {
    if( rcMbDataAccess.getMbData().getMbMode() == MODE_8x8 || rcMbDataAccess.getMbData().getMbMode() == MODE_8x8ref0 )
    {
      for( B8x8Idx c8x8Idx; c8x8Idx.isLegal(); c8x8Idx++ )
      {
        //----- motion compensated prediction -----
        RNOK( m_pcMotionCompensation->calcMvSubMb( c8x8Idx, rcMbDataAccess, pcMbDataAccessBaseMotion ) );
      }
    }
    else
    {
      //----- motion compensated prediction -----
      RNOK( m_pcMotionCompensation->calcMvMb( rcMbDataAccess, pcMbDataAccessBaseMotion ) );
    }
  }

  return Err::m_nOK;
}
Пример #8
0
// ----------------------------------------------------------------------
//
// FUNCTION:	AddMultiviewRefsToList
//
// INPUTS:	recPicBufUnitList:  A list of refernce pictures potentially
//				    containing multiview references.
//		rcList:  A RefFrameList object to add multiview references to.
//		refDirection:  Direction of references to add to rcList. 
//
// PURPOSE:	This function goes through each reference in recPicBufUnitList,
//		finds all multiview references with the given refDirection,
//		and adds them to rcList.  
//
// MODIFIED:	Tue Mar 14, 2006
//
// ----------------------------------------------------------------------
// modified to be a member of RecPicBuffer 26 Dec, 2006
// and the format has also been adjusted (AddMultiviewRef)
// Simplified again for JVT-V043 7 Feb. 2007
// and some cleanup
ErrVal 
RecPicBuffer::AddMultiviewRef( RecPicBufUnitList& recPicBufUnitList,
			                          RefFrameList& rcList, const int maxListSize,
			                          const MultiviewReferenceDirection refDirection, SliceHeader&   rcSliceheader,
									  QuarterPelFilter* pcQuarterPelFilter) {


  RefFrameList tempList;
  RecPicBufUnitList::iterator iter;

  for (iter  = recPicBufUnitList.begin();iter != recPicBufUnitList.end(); iter++) {
    if ( refDirection == (*iter)->GetMultiviewReferenceDirection() ) {
			if(m_pcPicEncoder->derivation_Inter_View_Flag((*iter)->getViewId(), rcSliceheader)){                        //JVT-W056  Samsung
				RecPicBufUnit* bufUnitToAdd = (*iter);   
				if( 1)
				{
					RNOK( bufUnitToAdd->getRecFrame()->initHalfPel() );
				}
				if( ! bufUnitToAdd->getRecFrame()->isExtended() )
				{
					RNOK( bufUnitToAdd->getRecFrame()->extendFrame( pcQuarterPelFilter, FRAME, rcSliceheader.getSPS().getFrameMbsOnlyFlag() ));
				}
				rcList.add( bufUnitToAdd->getRecFrame()->getPic(rcSliceheader.getPicType()) );
			}
    }
  }
  return Err::m_nOK;
}
Пример #9
0
ErrVal
PictureParameterSet::xReadFrext( HeaderSymbolReadIf* pcReadIf )
{
const CommonMainH264* pcMainH264 = CommonMain::getMainH264();
  ASSERT(pcMainH264 != NULL);
  const CommonElt* pcCurrent = pcMainH264->getEltCurrent();
  const CommonSyntax* pcSyntax;

  const CommonControl* pcControlIf0 = pcCurrent->addControl("if" , "more_rbsp_data", pcReadIf->moreRBSPData());
  ROTRS( ! pcReadIf->moreRBSPData(), Err::m_nOK );

  pcSyntax = pcCurrent->addSyntax("transform_8x8_mode_flag", "u(1)");
  RNOK  ( pcReadIf->getFlag ( m_bTransform8x8ModeFlag,                    "PPS: transform_8x8_mode_flag" ) );
  pcSyntax->setValue(m_bTransform8x8ModeFlag);
  pcSyntax = pcCurrent->addSyntax("pic_scaling_matrix_present_flag", "u(1)");
  RNOK  ( pcReadIf->getFlag ( m_bPicScalingMatrixPresentFlag,             "PPS: pic_scaling_matrix_present_flag" ) );
  pcSyntax->setValue(m_bPicScalingMatrixPresentFlag);
  
	const CommonControl* pcControlIf1 = pcCurrent->addControl("if" , "pic_scaling_matrix_present_flag", m_bPicScalingMatrixPresentFlag);
  if( m_bPicScalingMatrixPresentFlag )
  {
	  pcMainH264->setEltCurrent(pcControlIf1);
    RNOK( m_cPicScalingMatrix.read( pcReadIf, m_bTransform8x8ModeFlag ) );
	pcMainH264->setEltCurrent(pcCurrent);
  }
   pcSyntax = pcCurrent->addSyntax("second_chroma_qp_index_offset", "se(v)");
  RNOK  ( pcReadIf->getSvlc ( m_iSecondChromaQpIndexOffset,               "PPS: second_chroma_qp_index_offset" ) );
  pcSyntax->setValue(m_iSecondChromaQpIndexOffset);
  ROT   ( m_iSecondChromaQpIndexOffset < -12 || m_iSecondChromaQpIndexOffset > 12 );

  return Err::m_nOK;
}
ErrVal ControlMngH264AVCDecoder::initSliceForReading( const SliceHeader& rcSH )
{
  m_uiCurrLayer   = rcSH.getLayerId();

  MbSymbolReadIf* pcMbSymbolReadIf;
  
  if( rcSH.getPPS().getEntropyCodingModeFlag() )
  {
    pcMbSymbolReadIf = m_pcCabacReader;
  }
  else
  {
    pcMbSymbolReadIf = m_pcUvlcReader;
  }

	if ( rcSH.getTrueSlice())
	{
		RNOK( pcMbSymbolReadIf->startSlice( rcSH ) );
	}
  RNOK( m_pcMbParser->initSlice( pcMbSymbolReadIf ) );
#ifdef LF_INTERLACE
  m_pcSliceHeader = &rcSH;
#endif

  return Err::m_nOK;
}
Пример #11
0
ErrVal MbCoder::xWriteIntraPredModes( MbDataAccess& rcMbDataAccess )
{
  ROFRS( rcMbDataAccess.getMbData().isIntra(), Err::m_nOK );

  if( rcMbDataAccess.getMbData().isIntra4x4() )
  {
    if( rcMbDataAccess.getSH().getPPS().getTransform8x8ModeFlag() )
    {
      RNOK( m_pcMbSymbolWriteIf->transformSize8x8Flag( rcMbDataAccess ) );
    }

    if( rcMbDataAccess.getMbData().isTransformSize8x8() )
    {
      for( B8x8Idx cIdx; cIdx.isLegal(); cIdx++ )
      {
        RNOK( m_pcMbSymbolWriteIf->intraPredModeLuma( rcMbDataAccess, cIdx ) );
      }
    }
    else
    {
      for( S4x4Idx cIdx; cIdx.isLegal(); cIdx++ )
      {
        RNOK( m_pcMbSymbolWriteIf->intraPredModeLuma( rcMbDataAccess, cIdx ) );
      }
    }
  }

  if( rcMbDataAccess.getMbData().isIntra4x4() || rcMbDataAccess.getMbData().isIntra16x16() )
  {
    RNOK( m_pcMbSymbolWriteIf->intraPredModeChroma( rcMbDataAccess ) );
  }

  return Err::m_nOK;
}
Пример #12
0
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_cpDFPBuffer.init( uiSize+1 ) );
  m_cpDFPBuffer.clear();

  m_bInitDone     = true;

  return Err::m_nOK;
}
ErrVal ControlMngH264AVCDecoder::initMbForDecoding( MbDataAccess*& rpcMbDataAccess,UInt  uiMbIndex)
#endif
{
  ROF( m_uiCurrLayer < MAX_LAYERS );
  
#ifndef   LF_INTERLACE
  UInt uiMbY, uiMbX;

  uiMbY = uiMbIndex         / m_auiMbXinFrame[m_uiCurrLayer];
  uiMbX = uiMbIndex - uiMbY * m_auiMbXinFrame[m_uiCurrLayer];
#endif

  RNOK( m_pcMbDataCtrl                          ->initMb( rpcMbDataAccess, uiMbY, uiMbX ) );
#ifdef   LF_INTERLACE
  RNOK( m_apcYuvFullPelBufferCtrl[m_uiCurrLayer]->initMb(                  uiMbY, uiMbX, bMbAFF ) ); // for future use
#else //!LF_INTERLACE
  RNOK( m_apcYuvFullPelBufferCtrl[m_uiCurrLayer]->initMb(                  uiMbY, uiMbX ) );
#endif //LF_INTERLACE
#ifdef   LF_INTERLACE
  RNOK( m_pcMotionCompensation                  ->initMb(                  uiMbY, uiMbX, *rpcMbDataAccess ) ) ;
#else
  RNOK( m_pcMotionCompensation                  ->initMb(                  uiMbY, uiMbX ) ) ;
#endif
  return Err::m_nOK;
}
Пример #14
0
ErrVal
MVCScalableModifyCode::WritePayloadHeader( enum h264::SEI::MessageType eType, UInt uiSize )
{
	//type
	{
		UInt uiTemp = eType;
		UInt uiByte = 0xFF;	
		while( 0xFF == uiByte )
		{
			uiByte  = (0xFF > uiTemp) ? uiTemp : 0xff;
			uiTemp -= 0xFF;
			RNOK( WriteCode( uiByte, 8 ) );
		}
	}

	// size
	{
		UInt uiTemp = uiSize;
		UInt uiByte = 0xFF;

		while( 0xFF == uiByte )
		{
			uiByte  = (0xFF > uiTemp) ? uiTemp : 0xff;
			uiTemp -= 0xFF;
			RNOK( WriteCode( uiByte, 8 ) );
		}
	}
	return Err::m_nOK;
}
Пример #15
0
ErrVal VUI::LayerInfo::write( HeaderSymbolWriteIf* pcWriteIf ) const
{
  RNOK( pcWriteIf->writeCode( m_uiDependencyID, 3,  "VUI: dependency_id"  ) );
  RNOK( pcWriteIf->writeCode( m_uiQualityId,    4,  "VUI: quality_level"  ) );
  RNOK( pcWriteIf->writeCode( m_uiTemporalId,   3,  "VUI: temporal_level" ) );
  return Err::m_nOK;
}
Пример #16
0
ErrVal CabaEncoder::writeExGolombLevel( UInt uiSymbol, CabacContextModel& rcCCModel  )
{
  if( uiSymbol )
  {
    RNOK( writeSymbol( 1, rcCCModel ) );
    UInt uiCount = 0;
    Bool bNoExGo = (uiSymbol < 13);

    while( --uiSymbol && ++uiCount < 13 )
    {
      RNOK( writeSymbol( 1, rcCCModel ) );
    }
    if( bNoExGo )
    {
      RNOK( writeSymbol( 0, rcCCModel ) );
    }
    else
    {
      RNOK( writeEpExGolomb( uiSymbol, 0 ) );
    }
  }
  else
  {
    RNOK( writeSymbol( 0, rcCCModel ) );
  }

  return Err::m_nOK;
}
ErrVal ControlMngH264AVCDecoder::initSlice( SliceHeader& rcSH, ProcessingState eProcessingState )
{
  m_uiCurrLayer   = rcSH.getLayerId();
  m_pcMbDataCtrl  = rcSH.getFrameUnit()->getMbDataCtrl();

  RNOK( m_pcMbDataCtrl->initSlice( rcSH, eProcessingState, true, NULL ) );
  RNOK( m_pcSampleWeighting->initSlice( rcSH ) );

  if( PARSE_PROCESS == eProcessingState && rcSH.getTrueSlice())//TMM_EC
  {
    MbSymbolReadIf* pcMbSymbolReadIf;
    
    if( rcSH.getPPS().getEntropyCodingModeFlag() )
    {
      pcMbSymbolReadIf = m_pcCabacReader;
    }
    else
    {
      pcMbSymbolReadIf = m_pcUvlcReader;
    }

    RNOK( pcMbSymbolReadIf->startSlice( rcSH ) );
    RNOK( m_pcMbParser->initSlice( pcMbSymbolReadIf ) );

  }

  if( DECODE_PROCESS == eProcessingState)
  {
    RNOK( m_pcMotionCompensation->initSlice( rcSH ) );
  }

  return Err::m_nOK;
}
Пример #18
0
ErrVal
RecPicBuffer::xStorePicture( RecPicBufUnit* pcRecPicBufUnit,
                             PicBufferList& rcOutputList,
                             PicBufferList& rcUnusedList,
                             SliceHeader*   pcSliceHeader,
                             Bool           bTreatAsIdr )
{
  ROF( pcRecPicBufUnit == m_pcCurrRecPicBufUnit );

  if( bTreatAsIdr )
  {
    RNOK( xClearOutputAll( rcOutputList, rcUnusedList ) );
    m_cUsedRecPicBufUnitList.push_back( pcRecPicBufUnit );
  }
  else
  {
    m_cUsedRecPicBufUnitList.push_back( pcRecPicBufUnit );

    if( !pcSliceHeader->getInterViewRef()) // 
    {
    RNOK( xUpdateMemory( pcSliceHeader ) );
    }
    RNOK( xOutput( rcOutputList, rcUnusedList ) );
  }
  RNOK( xDumpRecPicBuffer() );

  m_pcCurrRecPicBufUnit = m_cFreeRecPicBufUnitList.popFront();

  return Err::m_nOK;
}
Пример #19
0
ErrVal
RecPicBuffer::xCheckMissingPics( SliceHeader*   pcSliceHeader,
                                 PicBufferList& rcOutputList,
                                 PicBufferList& rcUnusedList )
{
  ROTRS( pcSliceHeader->isIdrNalUnit(), Err::m_nOK );
  ROTRS( ( ( m_uiLastRefFrameNum + 1 ) % m_uiMaxFrameNum ) == pcSliceHeader->getFrameNum(), Err::m_nOK );

  UInt  uiMissingFrames = pcSliceHeader->getFrameNum() - m_uiLastRefFrameNum - 1;
  if( pcSliceHeader->getFrameNum() <= m_uiLastRefFrameNum )
  {
    uiMissingFrames += m_uiMaxFrameNum;
  }
  ROF( pcSliceHeader->getSPS().getRequiredFrameNumUpdateBehaviourFlag() );
  
  for( UInt uiIndex = 1; uiIndex <= uiMissingFrames; uiIndex++ )
  {
    Bool  bTreatAsIdr   = ( m_cUsedRecPicBufUnitList.empty() );
    Int   iPoc          = ( bTreatAsIdr ? 0 : m_cUsedRecPicBufUnitList.back()->getPoc() );
    UInt  uiFrameNum    = ( m_uiLastRefFrameNum + uiIndex ) % m_uiMaxFrameNum;

    RNOK( m_pcCurrRecPicBufUnit->initNonEx( iPoc, uiFrameNum ) );
    RNOK( xStorePicture( m_pcCurrRecPicBufUnit, rcOutputList, rcUnusedList, pcSliceHeader, bTreatAsIdr ) );
  }

  m_uiLastRefFrameNum = ( m_uiLastRefFrameNum + uiMissingFrames ) % m_uiMaxFrameNum;
  return Err::m_nOK;
}
Пример #20
0
ErrVal
RecPicBuffer::ProcessRef(SliceHeader&   rcSliceHeader, RefFrameList&  rcList ,RefFrameList&  rcListTemp, QuarterPelFilter* pcQuarterPelFilter)
{
  UInt uiPos; 
  PicType ePicType=rcSliceHeader.getPicType();
  bool bFieldPic=(ePicType!=FRAME);

  for( uiPos = 0; uiPos < rcListTemp.getSize() ; uiPos++ )
  {
    IntFrame* pcRefFrame = rcListTemp.getEntry( uiPos );
	if( 1)//! ( pcRefFrame->isHalfPel() && pcRefFrame->isPicReady(FRAME) ) )
    {
      RNOK( pcRefFrame->initHalfPel() );
    }
    if( ! pcRefFrame->isExtended() )
    {
		RNOK( pcRefFrame->extendFrame( pcQuarterPelFilter, FRAME, rcSliceHeader.getSPS().getFrameMbsOnlyFlag() ));
    }
  }

  if(bFieldPic)//lufeng
	xFieldList(rcSliceHeader,rcList,rcListTemp);
  else
  {
	   for( uiPos = 0; uiPos < rcListTemp.getSize() ; uiPos++ )
	   {
		   rcListTemp[uiPos+1]->getFullPelYuvBuffer()->fillMargin();//lufeng: for frame ref
		 rcList.add(rcListTemp[uiPos+1]);
	   }
  }

  return Err::m_nOK;
}
Пример #21
0
ErrVal
SliceEncoder::updatePictureResTransform( ControlData&     rcControlData,
                                         UInt          uiMbInRow )
{
  ROF( m_bInitDone );

  SliceHeader&  rcSliceHeader         = *rcControlData.getSliceHeader           ();
  MbDataCtrl*   pcMbDataCtrl          =  rcControlData.getMbDataCtrl            ();
  MbDataCtrl*   pcBaseLayerCtrl       =  rcControlData.getBaseLayerCtrl         ();
  UInt          uiMbAddress           =  0;
  UInt          uiLastMbAddress       =  rcSliceHeader.getMbInPic() - 1;

  //====== initialization ======
  RNOK( pcMbDataCtrl->initSlice( rcSliceHeader, DECODE_PROCESS, false, NULL ) );

  // Update the macroblock state
  // Must be done after the bit-stream has been constructed
  for( ; uiMbAddress <= uiLastMbAddress; )
  {
    UInt          uiMbY               = 0;
    UInt          uiMbX               = 0;
    MbDataAccess* pcMbDataAccess      = 0;
    MbDataAccess* pcMbDataAccessBase  = 0;

    rcSliceHeader.getMbPositionFromAddress( uiMbY, uiMbX, uiMbAddress );
    RNOK( pcMbDataCtrl      ->initMb          ( pcMbDataAccess,     uiMbY, uiMbX ) );
    if( pcBaseLayerCtrl )
    {
      RNOK( pcBaseLayerCtrl ->initMb          ( pcMbDataAccessBase, uiMbY, uiMbX ) );
      pcMbDataAccess->setMbDataAccessBase( pcMbDataAccessBase );
    }

    // modify QP values (as specified in G.8.1.5.1.2)
    if( pcMbDataAccess->getMbData().getMbCbp() == 0 && ( pcMbDataAccess->getMbData().getMbMode() == INTRA_BL || pcMbDataAccess->getMbData().getResidualPredFlag() ) )
    {
      pcMbDataAccess->getMbData().setQp   ( pcMbDataAccessBase->getMbData().getQp() );
      pcMbDataAccess->getMbData().setQp4LF( pcMbDataAccessBase->getMbData().getQp() );
    }

    // if cbp==0, tranform size is not transmitted, in this case inherit the transform size from base layer
    if( ( pcMbDataAccess->getMbData().getResidualPredFlag() && ! pcMbDataAccess->getMbData().isIntra() && ! pcMbDataAccessBase->getMbData().isIntra() ) || ( pcMbDataAccess->getMbData().getMbMode() == INTRA_BL ) )
    {
      if( ( pcMbDataAccess->getMbData().getMbCbp() & 0x0F ) == 0 )
      {
        pcMbDataAccess->getMbData().setTransformSize8x8( pcMbDataAccessBase->getMbData().isTransformSize8x8() );
      }
    }

    // set I_PCM mode (for deblocking) when CBP is 0, mbMode is I_BL, and base layer mbMode is I_PCM
    if( pcMbDataAccess->getMbData().getMbCbp() == 0 && pcMbDataAccess->getMbData().isIntraBL() && pcMbDataAccessBase->getMbData().isPCM() )
    {
      pcMbDataAccess->getMbData().setMbMode( MODE_PCM );
    }

    uiMbAddress++;
  }

  return Err::m_nOK;
}
Пример #22
0
ErrVal Frame::store( PicBuffer* pcPicBuffer, PicType ePicType )
{
  ASSERT( m_ePicType == FRAME );
  RNOK  ( getFullPelYuvBuffer()->storeToPicBuffer     ( pcPicBuffer ) );
  ROTRS ( ePicType   == FRAME, Err::m_nOK );
  RNOK  ( getFullPelYuvBuffer()->interpolatedPicBuffer( pcPicBuffer, ePicType == TOP_FIELD ) );
  return Err::m_nOK;
}
Пример #23
0
ErrVal VUI::ChromaLocationInfo::write( HeaderSymbolWriteIf* pcWriteIf ) const
{
  RNOK( pcWriteIf->writeFlag( m_bChromaLocationInfoPresentFlag, "VUI: chroma_location_info_present_flag"));
  ROFRS( m_bChromaLocationInfoPresentFlag, Err::m_nOK );

  RNOK( pcWriteIf->writeUvlc( m_uiChromaLocationFrame,          "VUI: chroma_location_frame"));
  RNOK( pcWriteIf->writeUvlc( m_uiChromaLocationField,          "VUI: chroma_location_field"));
  return Err::m_nOK;
}
ErrVal ControlMngH264AVCDecoder::initSliceForDecoding( const SliceHeader& rcSH )
{
  m_uiCurrLayer   = rcSH.getLayerId();

  RNOK( m_pcMotionCompensation->initSlice( rcSH ) );
  RNOK( m_pcSampleWeighting->initSlice( rcSH ) );

  return Err::m_nOK;
}
Пример #25
0
ErrVal Frame::addFrameFieldBuffer()
{
  ASSERT( m_ePicType==FRAME );

  RNOK( addFieldBuffer( TOP_FIELD ) );
  RNOK( addFieldBuffer( BOT_FIELD ) );

  return Err::m_nOK;
}
ErrVal ControlMngH264AVCDecoder::initSlice0( SliceHeader *rcSH )
{
  UInt  uiLayer             = rcSH->getLayerId                    ();
  /*
//JVT-T054{
  if(rcSH->getBaseLayerId() != MSYS_UINT_MAX && rcSH->getQualityLevel() != 0)
  {
    if( !m_apcMCTFDecoder[uiLayer]->isActive())
    {
      m_apcMCTFDecoder[uiLayer]->initSlice0( rcSH );
    }
    //if(!m_apcMCTFDecoder[uiLayer]->getResizeParameters())
      RNOK( xInitESS( rcSH ) );
    return Err::m_nOK;
  }
//JVT-T054}
*/
  ROTRS( m_uiInitilized[uiLayer], Err::m_nOK );
  m_auiMbXinFrame[uiLayer]  = rcSH->getSPS().getFrameWidthInMbs   ();
  m_auiMbYinFrame[uiLayer]  = rcSH->getSPS().getFrameHeightInMbs  ();

  UInt uiSizeX = m_auiMbXinFrame  [uiLayer] << 4;
  UInt uiSizeY = m_auiMbYinFrame  [uiLayer] << 4;

  RNOK( m_apcYuvFullPelBufferCtrl [uiLayer]->initSlice( uiSizeY, uiSizeX, YUV_Y_MARGIN, YUV_X_MARGIN ) );

  if( uiLayer == 0 )
  {
    m_bLayer0IsAVC  = ( rcSH->getNalUnitType() == NAL_UNIT_CODED_SLICE || 
                        rcSH->getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR);
    
    RNOK( m_pcFrameMng->initSlice               ( rcSH ) );
    m_pcH264AVCDecoder->setReconstructionLayerId( uiLayer );
    m_pcH264AVCDecoder->setBaseAVCCompatible    ( m_bLayer0IsAVC );
  }
  else
  {
    m_pcH264AVCDecoder->setReconstructionLayerId( uiLayer );
  }

  if( (rcSH->getNalUnitType() == NAL_UNIT_CODED_SLICE_SCALABLE ||  
      rcSH->getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_SCALABLE) &&
			rcSH->getTrueSlice())//TMM_EC
  {
    /*
      if(!rcSH->getSvcMvcFlag() )
        m_apcMCTFDecoder[uiLayer]->initSlice0( rcSH );
        */
  }

  RNOK( xInitESS( rcSH ) );

  m_uiInitilized[uiLayer] = true;

  return Err::m_nOK;
}
Пример #27
0
ErrVal VUI::TimingInfo::write( HeaderSymbolWriteIf* pcWriteIf ) const
{
  RNOK( pcWriteIf->writeFlag( m_bTimingInfoPresentFlag,         "VUI: timing_info_present_flag"));
  ROFRS( m_bTimingInfoPresentFlag, Err::m_nOK );

  RNOK( pcWriteIf->writeCode( m_uiNumUnitsInTick, 32,           "VUI: num_units_in_tick"));
  RNOK( pcWriteIf->writeCode( m_uiTimeScale, 32,                "VUI: time_scale"));
  RNOK( pcWriteIf->writeFlag( m_bFixedFrameRateFlag,            "VUI: fixed_frame_rate_flag"));
  return Err::m_nOK;
}
Пример #28
0
ErrVal MbDecoder::compensatePrediction( MbDataAccess& rcMbDataAccess )
{
  ROTRS( rcMbDataAccess.getMbData().isIntra(), Err::m_nOK );

  IntYuvMbBuffer cIntYuvMbBuffer;
  YuvMbBuffer    cYuvMbBuffer;
  RNOK( m_pcMotionCompensation->compensateMb( rcMbDataAccess, &cYuvMbBuffer, false, false ) );
  cIntYuvMbBuffer.loadBuffer( &cYuvMbBuffer );
  RNOK( m_pcFrameMng->getPredictionIntFrame()->getFullPelYuvBuffer()->loadBuffer( &cIntYuvMbBuffer ) );
  return Err::m_nOK;
}
Пример #29
0
ErrVal
VUI::copyExceptHRDParametersAndSVCExt( const VUI& rcVUI )
{
  m_bVuiParametersPresentFlag  = rcVUI.m_bVuiParametersPresentFlag;
  m_bOverscanInfoPresentFlag   = rcVUI.m_bOverscanInfoPresentFlag;
  m_bOverscanAppropriateFlag   = rcVUI.m_bOverscanAppropriateFlag;
  RNOK( m_cAspectRatioInfo       .copy( rcVUI.m_cAspectRatioInfo       ) );
  RNOK( m_cVideoSignalType       .copy( rcVUI.m_cVideoSignalType       ) );
  RNOK( m_cChromaLocationInfo    .copy( rcVUI.m_cChromaLocationInfo    ) );
  RNOK( m_cBitstreamRestriction  .copy( rcVUI.m_cBitstreamRestriction  ) );
  return Err::m_nOK;
}
Пример #30
0
__inline ErrVal CabaEncoder::xWriteBitAndBitsToFollow( UInt uiBit)
{
  RNOK( xWriteBit( uiBit ) );
  // invert bit
  uiBit = 1-uiBit;

  while( m_uiBitsToFollow > 0)
  {
    m_uiBitsToFollow--;
    RNOK( xWriteBit( uiBit ) );
  }
  return Err::m_nOK;
}