sys_encoder_vopseenc.cpp

完整的RTP RTSP代码库

		if(bPrevRefVopWasCoded) // only swap references if previous vop was coded
		{
			if (m_volmd.volType == BASE_LAYER)
				updateAllRefVOPs ();					// update all reconstructed VOP's
			else if (!bTemporalScalability) { // modified by Sharp (98/2/10)
				if(m_volmd.volType == ENHN_LAYER && m_vopmd.vopPredType == PVOP)
					m_vopmd.iRefSelectCode = 3;
				else if(m_volmd.volType == ENHN_LAYER && m_vopmd.vopPredType == BVOP)
					m_vopmd.iRefSelectCode = 0;
				updateAllRefVOPs (pvopfRefBaseLayer);	// for spatial scalability
			}

// NEWPRED
			if(m_volmd.bNewpredEnable) {
				// set NEWPRED reference picture memory
				g_pNewPredEnc->SetQBuf( m_pvopcRefQ0, m_pvopcRefQ1 );
				if (m_volmd.fAUsage == RECTANGLE) { //rectangular shape
					for( int iSlice = 0; iSlice < g_pNewPredEnc->m_iNumSlice; iSlice++ ) {
						// make next reference picture
						g_pNewPredEnc->makeNextRef(g_pNewPredEnc->m_pNewPredControl, iSlice);
						int		iMBY = g_pNewPredEnc->NowMBA(iSlice)/((g_pNewPredEnc->getwidth())/MB_SIZE);
						PixelC* RefpointY = (PixelC*) m_pvopcRefQ0->pixelsY () + (m_iStartInRefToCurrRctY-EXPANDY_REF_FRAME) + iMBY * MB_SIZE * m_rctRefFrameY.width;
						PixelC* RefpointU = (PixelC*) m_pvopcRefQ0->pixelsU () + (m_iStartInRefToCurrRctUV-EXPANDUV_REF_FRAME) + iMBY * BLOCK_SIZE * m_rctRefFrameUV.width;
						PixelC* RefpointV = (PixelC*) m_pvopcRefQ0->pixelsV () + (m_iStartInRefToCurrRctUV-EXPANDUV_REF_FRAME) + iMBY * BLOCK_SIZE * m_rctRefFrameUV.width;
						g_pNewPredEnc->CopyNPtoVM(iSlice, RefpointY, RefpointU, RefpointV);	
					}
					repeatPadYOrA ((PixelC*) m_pvopcRefQ0->pixelsY () + m_iOffsetForPadY, m_pvopcRefQ0);
					repeatPadUV (m_pvopcRefQ0);
				}
			}
// ~NEWPRED
    		if (m_volmd.bOriginalForME) {
			if (m_vopmd.vopPredType == PVOP || ((m_uiSprite == 2) && (m_vopmd.vopPredType == SPRITE)) || // GMC
    				(m_volmd.volType == ENHN_LAYER && m_vopmd.vopPredType == BVOP && m_vopmd.iRefSelectCode == 0))
    				swapVOPU8Pointers (m_pvopcRefOrig0, m_pvopcRefOrig1);
    		}
		}
//OBSS_SAIT_991015
		else if(m_volmd.volType == ENHN_LAYER && m_volmd.fAUsage == ONE_BIT){
			if (!bTemporalScalability) { 
				if(m_volmd.volType == ENHN_LAYER && m_vopmd.vopPredType == PVOP)
					m_vopmd.iRefSelectCode = 3;
				else if(m_volmd.volType == ENHN_LAYER && m_vopmd.vopPredType == BVOP)
					m_vopmd.iRefSelectCode = 0;
				updateAllRefVOPs (pvopfRefBaseLayer);	// for spatial scalability

    			if (m_volmd.bOriginalForME) {
    				if (m_vopmd.vopPredType == PVOP || 
    					(m_volmd.volType == ENHN_LAYER && m_vopmd.vopPredType == BVOP && m_vopmd.iRefSelectCode == 0))
    					swapVOPU8Pointers (m_pvopcRefOrig0, m_pvopcRefOrig1);
    			}
			}
		}
//~OBSS_SAIT_991015

	    if (m_vopmd.vopPredType != BVOP) {
			if(bPrevRefVopWasCoded)
			{
				// swap zoomed ref images
				CU8Image *puciTmp = m_puciRefQZoom0;
				m_puciRefQZoom0 = m_puciRefQZoom1;
				m_puciRefQZoom1 = puciTmp;
				m_rctRefVOPZoom0 = m_rctRefVOPZoom1;
			}
		    m_vopmd.iSearchRangeBackward = 0;
			if(bPrevRefVopWasCoded)
				if ( !bTemporalScalability || m_volmd.volType == BASE_LAYER ) // added by Sharp (99/1/28)
					m_tPastRef = m_tFutureRef;
		    m_tDistanceBetwIPVOP = (m_t - m_tPastRef) / m_volmd.iTemporalRate;
            m_tFutureRef = m_t;
		    m_iBCount = 0;
			if(m_vopmd.vopPredType == PVOP &&
				m_volmd.volType == ENHN_LAYER && m_vopmd.iRefSelectCode ==3)
				m_tPastRef = m_t;
			if(!m_volmd.bShapeOnly){	//OBSS_SAIT_991015	//BSO of OBSS
				if (m_vopmd.vopPredType == PVOP || (m_uiSprite == 2 && m_vopmd.vopPredType == SPRITE)) { // GMC
					// swap rounding control 0 <-> 1 every coded PVOP
					if( bPrevRefVopWasCoded && !m_volmd.bRoundingControlDisable)
						m_vopmd.iRoundingControlEncSwitch ^= 0x00000001;
					m_vopmd.iRoundingControl = m_vopmd.iRoundingControlEncSwitch;

					m_rctRefVOPZoom0 = m_rctRefVOPY0.upSampleBy2 ();
					biInterpolateY (m_pvopcRefQ0, m_rctRefVOPY0, m_puciRefQZoom0,
						m_rctRefVOPZoom0, m_vopmd.iRoundingControl);

					m_vopmd.iSearchRangeForward = 
						checkrange (m_volmd.iMVRadiusPerFrameAwayFromRef * (m_t - m_tPastRef) / m_volmd.iTemporalRate, 1, 1024);
				} else
					m_vopmd.iSearchRangeForward = 0;
			}//OBSS_SAIT_991015
	    } else {
			// BVOP, set rounding control to zero
			m_vopmd.iRoundingControl = 0;
			if (m_volmd.volType==ENHN_LAYER && m_vopmd.iRefSelectCode==0){
				m_tPastRef = m_tFutureRef;
				m_tFutureRef = m_t;
			}
			m_iBCount++;
			if (m_iBCount == 1 || (m_volmd.volType == ENHN_LAYER && m_vopmd.iRefSelectCode==0))
			{
				if(!m_volmd.bShapeOnly){	//OBSS_SAIT_991015	//BSO of OBSS
					if(bPrevRefVopWasCoded)
					{
						m_rctRefVOPZoom1 = m_rctRefVOPY1.upSampleBy2 ();
						biInterpolateY (m_pvopcRefQ1,m_rctRefVOPY1,
							m_puciRefQZoom1, m_rctRefVOPZoom1, 0);
					}
					if (m_vopmd.iRoundingControlEncSwitch==1 // modified by Sharp (98/2/10) &&	// Need to re-compute because iRoundingControl was 1
						|| (m_volmd.volType == ENHN_LAYER && m_vopmd.iRefSelectCode == 0) || bTemporalScalability) 
					{
						m_rctRefVOPZoom0 = m_rctRefVOPY0.upSampleBy2 ();
						biInterpolateY (m_pvopcRefQ0, m_rctRefVOPY0, m_puciRefQZoom0, m_rctRefVOPZoom0, 0);
					}
				}//OBSS_SAIT_991015
			}
//m_vopmd.iSearchRangeForward = 15;
//m_vopmd.iSearchRangeBackward = 15;
			m_vopmd.iSearchRangeForward = 
				checkrange ((m_t - m_tPastRef) * m_volmd.iMVRadiusPerFrameAwayFromRef / m_volmd.iTemporalRate, 1, 1024);
			m_vopmd.iSearchRangeBackward = 
				checkrange ((m_tFutureRef - m_t) * m_volmd.iMVRadiusPerFrameAwayFromRef / m_volmd.iTemporalRate, 1, 1024);
	    }
	    decideMVInfo();
	    m_statsVOP.nVOPs = 1;
    	if (m_volmd.fAUsage != RECTANGLE)
    		resetBYPlane ();

		if(!bVOPVisible)
		{
			if (m_vopmd.vopPredType != BVOP
				&& m_volmd.fAUsage != RECTANGLE && bPrevRefVopWasCoded)
			{
				// give the current object a dummy size
				m_iNumMBX = m_iNumMBY = m_iNumMB = 1;
				saveShapeMode(); // save the previous reference vop shape mode
			}
//OBSS_SAIT_991015
			if (m_volmd.fAUsage != RECTANGLE ){						
				// give the current object a dummy size						
				m_iNumMBX = m_iNumMBY = m_iNumMB = 1;						
				saveBaseShapeMode(); // save the base layer shape mode		
			}														
//~OBSS_SAIT_991015
			return;   // return if not coded
        }
        
    	// prepare for the current original data
    	// extend the currVOP size to multiples of MBSize, will put zero on extended pixels
    	if (m_volmd.fAUsage != RECTANGLE) {
    		if (m_uiSprite != 1) {		// add by cgu to deal with vop-mc-left-top 12/5
    			findTightBoundingBox ();
//OBSSFIX_MODE3
				if(!(m_volmd.bSpatialScalability && m_volmd.iHierarchyType==0 && !(m_volmd.iEnhnType != 0 && m_volmd.iuseRefShape ==1)))
//				if(!(m_volmd.bSpatialScalability && m_volmd.iHierarchyType==0))//OBSS_SAIT_991015
//~OBSSFIX_MODE3
	    			findBestBoundingBox ();	

			} else if (m_sptMode == BASIC_SPRITE) {
				Int iSpriteWidth =  m_rctSpt.right - m_rctSpt.left;
				if(iSpriteWidth%16)
					iSpriteWidth += 16 - (iSpriteWidth%16);
				Int iSpriteHeight =  m_rctSpt.bottom - m_rctSpt.top;
				if(iSpriteHeight%16)
					iSpriteHeight += 16 - (iSpriteHeight%16);
				m_pvopcOrig->setBoundRct (CRct (0, 0, iSpriteWidth, iSpriteHeight));
			}
			m_rctCurrVOPY = m_pvopcOrig->whereBoundY ();
			m_rctCurrVOPUV = m_pvopcOrig->whereBoundUV ();
			setRefStartingPointers (); // need to compute the starting pointers of the refVOP's (corresponding to the current Rct)
			computeVOPMembers ();
			// Modified for error resilient mode by Toshiba(1998-1-16)
			if (m_volmd.bVPBitTh < 0 || m_volmd.bShapeOnly==TRUE || m_volmd.volType == ENHN_LAYER) { // FIX for C2-1
				m_vopmd.bShapeCodingType = (m_vopmd.vopPredType == IVOP) ? 0 : 1;
			} else {
				m_vopmd.bShapeCodingType = (m_volmd.iBinaryAlphaRR<0)?1:((m_t % m_volmd.iBinaryAlphaRR)==0) ? 0 : 1;
			}
	//		printf("vop_shape_coding_type=%d\n",m_vopmd.bShapeCodingType);
			// End Toshiba(1998-1-16)
		}

#ifdef __TRACE_AND_STATS_
	    m_pbitstrmOut -> trace (m_t, "VOP_Time");
#endif // __TRACE_AND_STATS_
// GMC
	if(m_uiSprite == 2 && vopPredType == SPRITE)
	   if(m_volmd.bOriginalForME==TRUE)
		GlobalMotionEstimation(m_rgstDstQ, m_pvopcRefOrig0, m_pvopcOrig, m_rctRefFrameY, m_rctRefVOPY0, m_rctCurrVOPY, m_iNumOfPnts);
	   else
		GlobalMotionEstimation(m_rgstDstQ, m_pvopcRefOrig1, m_pvopcOrig, m_rctRefFrameY, m_rctRefVOPY0, m_rctCurrVOPY, m_iNumOfPnts);
// ~GMC
// RRV
		if(m_vopmd.RRVmode.iOnOff == 1)
		{
			resetAndCalcRRV();
			redefineVOLMembersRRV();
		}
		else
		{
			m_vopmd.RRVmode.iRRVOnOff	= 0;
			m_iRRVScale	= 1;
		}
// ~RRV

		if (m_uiRateControl>=RC_TM5) {
			m_tm5rc.tm5rc_init_pict(m_vopmd.vopPredType,
								m_pvopcOrig->pixelsBoundY (),
								m_iFrameWidthY,
								m_iNumMBX,
								m_iNumMBY);

			Int iQP = m_tm5rc.tm5rc_start_mb();
			// set them all to avoid testing pred type
			m_vopmd.intStep = m_vopmd.intStepB = m_vopmd.intStepI = iQP;
		}

	    codeVOPHead ();
#if 0
	    cout << "\t" << "Time..." << m_t << " (" << m_t/m_volmd.dFrameHz << " sec)";

	    switch(m_vopmd.vopPredType)		//OBSS_SAIT_991015
	    {
	    case IVOP:
		    cout << "\tIVOP";
	    	break;
	    case PVOP:
	    	cout << "\tPVOP (reference: t=" << m_tPastRef <<")";
	    	break;
// GMC
	    case SPRITE:
		cout << "\tSVOP(GMC) (reference: t=" << m_tPastRef <<")";
	    	break;
// ~GMC
	    case BVOP:
	    	cout << "\tBVOP (past ref: t=" << m_tPastRef
	    		<< ", future ref: t=" << m_tFutureRef <<")";
	    	break;
	    default:
	    	break;
	    }
	    cout << "\n";
	    cout.flush ();
	#endif
	    encodeVOP ();

		if (m_uiRateControl>=RC_TM5) {
			m_tm5rc.tm5rc_update_pict(m_vopmd.vopPredType, m_statsVOP.total());
		}

	    m_statsVOP.nBitsStuffing += m_pbitstrmOut->flush ();

// NEWPRED
		if(m_volmd.bNewpredEnable) {
			g_pNewPredEnc->SetQBuf( m_pvopcRefQ0, m_pvopcRefQ1 );
			for( int iSlice = 0; iSlice < g_pNewPredEnc->m_iNumSlice; iSlice++ ) {	
				g_pNewPredEnc->makeNextBuf(
					g_pNewPredEnc->m_pNewPredControl,
					g_pNewPredEnc->GetCurrentVOP_id(),
					iSlice
				);
			}
		}
// ~NEWPRED

    }
#ifdef __TRACE_AND_STATS_
	if(!m_volmd.bShapeOnly){	//OBSS_SAIT_991015	//BSO of OBSS
		if (m_vopmd.vopPredType == BVOP)
			computeSNRs (m_pvopcCurrQ);
		else
			computeSNRs (m_pvopcRefQ1);
		m_statsVOP.dSNRY = m_rgdSNR [0];
		m_statsVOP.dSNRU = m_rgdSNR [1];
		m_statsVOP.dSNRV = m_rgdSNR [2];
    if (m_volmd.fAUsage == EIGHT_BIT) {
      for(Int iAuxComp=0;iAuxComp<m_volmd.iAuxCompCount;iAuxComp++) // MAC (SB) 26-Nov-99
        m_statsVOP.dSNRA[iAuxComp] = m_rgdSNR[3+iAuxComp];
    }
	}	//OBSS_SAIT_991015
	m_statsVOP.print (TRUE);
	m_statsVOL += m_statsVOP;
#endif // __TRACE_AND_STATS_
	
	// rate control
	if (m_uiRateControl==RC_MPEG4) {
		assert (m_volmd.volType == BASE_LAYER);	//don't no know to do RC for scalability yet
#ifndef __TRACE_AND_STATS_
		cerr << "Compile flag __TRACE_AND_STATS_ required for stats for rate control." << endl;
		exit(1);
#endif // __TRACE_AND_STATS_
		if (m_vopmd.vopPredType == IVOP) { // !!!! check whether CRct has been expanded
			Double dMad = 
				(m_pvopcOrig->getPlane (Y_PLANE)->sumAbs (m_rctCurrVOPY)) / 
				(Double) (m_rctCurrVOPY.area ());
			m_statRC.reset (
				m_nFirstFrame, 
				m_nLastFrame, 
				m_volmd.iTemporalRate, 
				m_volmd.iPbetweenI,
				&m_vopmd.intStep,  // gets saved the first frame, and restored after every later ivop
				m_iBufferSize, 
				dMad, 
				m_statsVOP.total (),
				m_volmd.dFrameHz
			);
		}
		else if (m_vopmd.vopPredType == PVOP || ((m_uiSprite == 2) && (m_vopmd.vopPredType == SPRITE))) // GMC
			m_statRC.updateRCModel (m_statsVOP.total (), m_statsVOP.head ());
	}

	// store the direct mode data (by swaping pointers)
//OBSSFIX_MODE3
	if (m_vopmd.vopPredType != BVOP ||
		(m_volmd.volType == ENHN_LAYER && m_volmd.bSpatialScalability && m_volmd.iHierarchyType == 0 && m_volmd.iEnhnType != 0 && m_volmd.iuseRefShape == 1)) {
//	if (m_vopmd.vopPredType != BVOP) {
//~OBSSFIX_MODE3
		if(m_volmd.fAUsage != RECTANGLE && bPrevRefVopWasCoded)
			saveShapeMode();
//OBSS_SAIT_991015
		if(m_volmd.fAUsage != RECTANGLE)		
			saveBaseShapeMode();				
//~OBSS_SAIT_991015
		CMBMode* pmbmdTmp = m_rgmbmd;
		m_rgmbmd = m_rgmbmdRef;
		m_rgmbmdRef = pmbmdTmp;
		CMotionVector* pmvTmp = m_rgmv;
		m_rgmv = m_rgmvRef;
		m_rgmvRef = pmvTmp;
		//wchen: should not only for pvop
		//if (m_vopmd.vopPredType == PVOP) 
		m_rgmvBackward = m_rgmv + BVOP_MV_PER_REF_PER_MB * m_iSessNumMB;
		
#if 0 // Debugging .. use the same anchor VOPs as reference implementation
		static FILE *pfRefPicInputFile = NULL;
		if (pfRefPicInputFile == NULL) {
			pfRefPicInputFile = fopen("ref.yuv", "rb");
			assert(pfRefPicInputFile != NULL);
		}
		Int iLeadingPixels = m_t * m_rctPrevNoExpandY.area ();
		fseek (pfRefPicInputFile, iLeadingPixels + iLeadingPixels / 2, SEEK_SET);	//4:2:0
		static Int iYDataHeight = m_rctPrevNoExpandY.height ();
		static Int iUVDataHeight = m_rctPrevNoExpandY.height () / 2;
		static Int iYFrmWidth = m_pvopcRefQ1->whereY ().width;
		static Int iUvFrmWidth = m_pvopcRefQ1->whereUV ().width;
		static Int nSkipYPixel = iYFrmWidth * EXPANDY_REF_FRAME + EXPANDY_REF_FRAME;
		static Int nSkipUvPixel = iUvFrmWidth * EXPANDUV_REF_FRAME + EXPANDUV_REF_FRAME;
		PixelC* ppxlcY = (PixelC*) m_pvopcRefQ1->pixelsY () + nSkipYPixel;
		PixelC* ppxlcU = (PixelC*) m_pvopcRefQ1->pixelsU () + nSkipUvPixel;
		PixelC* ppxlcV = (PixelC*) m_pvopcRefQ1->pixelsV () + nSkipUvPixel;
		for (CoordI y = 0; y < iYDataHeight; y++) {
			Int size = (Int) fread (ppxlcY, sizeof (U8), m_rctPrevNoExpandY.width, pfRefPicInputFile);