errenc.cpp

网络MPEG4IP流媒体开发源代码

/*************************************************************************

This software module was originally developed by 

	Yoshihiro Kikuchi (TOSHIBA CORPORATION)
	Takeshi Nagai (TOSHIBA CORPORATION)

    and edited by:

	Toshiaki Watanabe (TOSHIBA CORPORATION)
	Noboru Yamaguchi (TOSHIBA CORPORATION)

	and also edited by 

	Xuemin Chen ([e-mail]) Next Level System, Inc.
	Bob Eifrig ([e-mail]) Next Level Systems, Inc.

  in the course of development of the <MPEG-4 Video(ISO/IEC 14496-2)>. This
  software module is an implementation of a part of one or more <MPEG-4 Video
  (ISO/IEC 14496-2)> tools as specified by the <MPEG-4 Video(ISO/IEC 14496-2)
  >. ISO/IEC gives users of the <MPEG-4 Video(ISO/IEC 14496-2)> free license
  to this software module or modifications thereof for use in hardware or
  software products claiming conformance to the <MPEG-4 Video(ISO/IEC 14496-2
  )>. Those intending to use this software module in hardware or software
  products are advised that its use may infringe existing patents. The
  original developer of this software module and his/her company, the
  subsequent editors and their companies, and ISO/IEC have no liability for
  use of this software module or modifications thereof in an implementation.
  Copyright is not released for non <MPEG-4 Video(ISO/IEC 14496-2)>
  conforming products. TOSHIBA CORPORATION retains full right to use the code
  for his/her own purpose, assign or donate the code to a third party and to
  inhibit third parties from using the code for non <MPEG-4 Video(ISO/IEC
  14496-2)> conforming products. This copyright notice must be included in
  all copies or derivative works.
  Copyright (c)1997.

Revision History:

	May 9, 1999:	tm5 rate control by DemoGraFX, [e-mail]

*************************************************************************/

#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <iostream.h>

#include "typeapi.h"
#include "codehead.h"
#include "entropy/bitstrm.hpp"
#include "entropy/entropy.hpp"
#include "entropy/huffman.hpp"
#include "mode.hpp"
#include "global.hpp"
#include "vopses.hpp"
#include "vopseenc.hpp"

#ifdef __MFC_
#ifdef _DEBUG
#undef THIS_FILE
static char BASED_CODE THIS_FILE[] = __FILE__;
#endif

#define new DEBUG_NEW				   
#endif // __MFC_

// inline functions
inline Int clog2(Int a)	{return ( ((a)<=0) ? 0 : (int) ceil( log10( (double) (a) ) / log10(2.0) ) );}


Void CVideoObjectEncoder::VideoPacketResetVOP(
)
{
	m_iVPCounter = m_pbitstrmOut -> getCounter();		// reset coding bits counter
	assert(m_iNumMBX>0 && m_iNumMBY>0);
	m_numBitsVPMBnum = clog2 (m_iNumMBX * m_iNumMBY);	// number of bits for macroblock_number
	m_numVideoPacket = 1;								// reset number of video packet in a VOP
	m_iVPMBnum = 0;									// start MB in the 1st VP
}


Void CVideoObjectEncoder::codeVideoPacketHeader (
	Int iMBX, Int iMBY, Int QuantScale
)
{
	m_iVPMBnum = VPMBnum(iMBX, iMBY);
	m_statsVOP.nBitsHead += codeVideoPacketHeader(QuantScale);
}

#if 0 // revised HEC for shape
Int CVideoObjectEncoder::codeVideoPacketHeader (Int QuantScale)
{
#ifdef __TRACE_AND_STATS_
	m_pbitstrmOut->trace ("Video_Packet_Header\n");
#endif // __TRACE_AND_STATS_
	UInt nBits = 0;
	assert(m_iVPMBnum > 0 && m_iVPMBnum < m_iNumMBX * m_iNumMBY);
	assert(QuantScale > 0 && QuantScale < 32);

	m_pbitstrmOut->flush ();
	Int nBitsResyncMarker = NUMBITS_VP_RESYNC_MARKER;
	if(m_volmd.bShapeOnly==FALSE)
	{
		if(m_vopmd.vopPredType == PVOP)
			nBitsResyncMarker += (m_vopmd.mvInfoForward.uiFCode - 1);
		else if(m_vopmd.vopPredType == BVOP)
			nBitsResyncMarker += max(m_vopmd.mvInfoForward.uiFCode, m_vopmd.mvInfoBackward.uiFCode) - 1;
	}
	m_pbitstrmOut -> putBits (RESYNC_MARKER, nBitsResyncMarker, "resync_marker");
	m_pbitstrmOut -> putBits (m_iVPMBnum, m_numBitsVPMBnum, "VPH_macroblock_number");
	if(m_volmd.bShapeOnly==FALSE) {
		m_pbitstrmOut -> putBits (QuantScale, NUMBITS_VP_QUANTIZER, "VPH_quant_scale");
	}

	Bool	HEC = ((++m_numVideoPacket) == 2);	// use HEC in 2nd VP
	m_pbitstrmOut -> putBits (HEC, NUMBITS_VP_HEC, "VPH_header_extension_code");
#ifdef __TRACE_AND_STATS_
	nBits += nBitsResyncMarker + m_numBitsVPMBnum + NUMBITS_VP_QUANTIZER + NUMBITS_VP_HEC;
#endif // __TRACE_AND_STATS_
	if( HEC == TRUE ) {
		m_pbitstrmOut -> putBits ((Int) 0xFFFFFFFE, (UInt) m_nBitsModuloBase + 1, "VPH_Modulo_Time_Base");
		m_pbitstrmOut->putBits ((Int) 1, 1, "Marker"); // marker bit
		m_pbitstrmOut -> putBits (m_iVopTimeIncr, m_iNumBitsTimeIncr, "VPH_Time_Incr");
		m_pbitstrmOut->putBits ((Int) 1, 1, "Marker"); // marker bit
		m_pbitstrmOut -> putBits (m_vopmd.vopPredType, NUMBITS_VP_PRED_TYPE, "VPH_Pred_Type");
#ifdef __TRACE_AND_STATS_
		nBits += m_nBitsModuloBase+1 + m_iNumBitsTimeIncr +2 + NUMBITS_VP_PRED_TYPE + NUMBITS_VP_INTRA_DC_SWITCH_THR;
#endif // __TRACE_AND_STATS_
		if(m_volmd.bShapeOnly==FALSE) {
			m_pbitstrmOut -> putBits (m_vopmd.iIntraDcSwitchThr, NUMBITS_VP_INTRA_DC_SWITCH_THR, "VOP_DC_VLC_Switch");
			if(m_vopmd.vopPredType != IVOP) {
				m_pbitstrmOut -> putBits (m_vopmd.mvInfoForward.uiFCode, NUMBITS_VOP_FCODE, "VPH_Fcode_Forward");
#ifdef __TRACE_AND_STATS_
				nBits += NUMBITS_VOP_FCODE;
#endif // __TRACE_AND_STATS_
				if (m_vopmd.vopPredType == BVOP) {
					m_pbitstrmOut -> putBits (m_vopmd.mvInfoBackward.uiFCode, NUMBITS_VOP_FCODE, "VOP_Fcode_Backward");
#ifdef __TRACE_AND_STATS_
					nBits += NUMBITS_VOP_FCODE;
#endif // __TRACE_AND_STATS_
				}
			}
		}
	}

	return nBits;
}
#else
Int CVideoObjectEncoder::codeVideoPacketHeader (Int QuantScale)
{
#ifdef __TRACE_AND_STATS_
	m_pbitstrmOut->trace ("Video_Packet_Header\n");
#endif // __TRACE_AND_STATS_
	UInt nBits = 0;
	assert(m_iVPMBnum > 0 && m_iVPMBnum < m_iNumMBX * m_iNumMBY);
	assert(QuantScale > 0 && QuantScale < 32);

	m_pbitstrmOut->flush ();
	Int nBitsResyncMarker = NUMBITS_VP_RESYNC_MARKER;
	Bool	HEC = ((++m_numVideoPacket) == 2);	// use HEC in 2nd VP
	if(m_volmd.bShapeOnly==FALSE)
	{
		if(m_vopmd.vopPredType == PVOP)
			nBitsResyncMarker += (m_vopmd.mvInfoForward.uiFCode - 1);
		else if(m_vopmd.vopPredType == BVOP)
			nBitsResyncMarker += max(m_vopmd.mvInfoForward.uiFCode, m_vopmd.mvInfoBackward.uiFCode) - 1;
	}
	m_pbitstrmOut -> putBits (RESYNC_MARKER, nBitsResyncMarker, "resync_marker");

	if(m_volmd.fAUsage != RECTANGLE) {
		m_pbitstrmOut -> putBits (HEC, NUMBITS_VP_HEC, "VPH_header_extension_code");
		if (HEC == TRUE && !(m_uiSprite == 1 && m_vopmd.vopPredType == IVOP)) {
			m_pbitstrmOut->putBits (m_rctCurrVOPY.width, NUMBITS_VOP_WIDTH, "VPH_VOP_Width");
			m_pbitstrmOut->putBits ((Int) 1, 1, "Marker"); // marker bit
			m_pbitstrmOut->putBits (m_rctCurrVOPY.height (), NUMBITS_VOP_HEIGHT, "VPH_VOP_Height");
			m_pbitstrmOut->putBits ((Int) 1, 1, "Marker"); // marker bit
#ifdef __TRACE_AND_STATS_
			nBits += NUMBITS_VOP_WIDTH + NUMBITS_VOP_HEIGHT + 2;
#endif // __TRACE_AND_STATS_

			if (m_rctCurrVOPY.left >= 0) {
				m_pbitstrmOut -> putBits (m_rctCurrVOPY.left, NUMBITS_VOP_HORIZONTAL_SPA_REF, "VPH_VOP_Hori_Ref");
			} else {
				m_pbitstrmOut -> putBits (m_rctCurrVOPY.left & 0x00001FFFF, NUMBITS_VOP_HORIZONTAL_SPA_REF, "VPH_VOP_Hori_Ref");
			}
			m_pbitstrmOut->putBits ((Int) 1, 1, "Marker"); // marker bit
			if (m_rctCurrVOPY.top >= 0) {
				m_pbitstrmOut -> putBits (m_rctCurrVOPY.top, NUMBITS_VOP_VERTICAL_SPA_REF, "VPH_VOP_Vert_Ref");
			} else {
				m_pbitstrmOut -> putBits (m_rctCurrVOPY.top & 0x00001FFFF, NUMBITS_VOP_VERTICAL_SPA_REF, "VPH_VOP_Vert_Ref");
			}
			m_pbitstrmOut->putBits ((Int) 1, 1, "Marker"); // marker bit
#ifdef __TRACE_AND_STATS_
			nBits += NUMBITS_VOP_HORIZONTAL_SPA_REF + NUMBITS_VOP_VERTICAL_SPA_REF + 2;
#endif // __TRACE_AND_STATS_
		}
	}

	m_pbitstrmOut -> putBits (m_iVPMBnum, m_numBitsVPMBnum, "VPH_macroblock_number");
	if(m_volmd.bShapeOnly==FALSE) {
		m_pbitstrmOut -> putBits (QuantScale, NUMBITS_VP_QUANTIZER, "VPH_quant_scale");
	}

	if(m_volmd.fAUsage == RECTANGLE)
		m_pbitstrmOut -> putBits (HEC, NUMBITS_VP_HEC, "VPH_header_extension_code");
#ifdef __TRACE_AND_STATS_
	nBits += nBitsResyncMarker + m_numBitsVPMBnum + NUMBITS_VP_QUANTIZER + NUMBITS_VP_HEC;
#endif // __TRACE_AND_STATS_
	if( HEC == TRUE ) {
		m_pbitstrmOut -> putBits ((Int) 0xFFFFFFFE, (UInt) m_nBitsModuloBase + 1, "VPH_Modulo_Time_Base");
		m_pbitstrmOut->putBits ((Int) 1, 1, "Marker"); // marker bit
		m_pbitstrmOut -> putBits (m_iVopTimeIncr, m_iNumBitsTimeIncr, "VPH_Time_Incr");
		m_pbitstrmOut->putBits ((Int) 1, 1, "Marker"); // marker bit
		m_pbitstrmOut -> putBits (m_vopmd.vopPredType, NUMBITS_VP_PRED_TYPE, "VPH_Pred_Type");
#ifdef __TRACE_AND_STATS_
		nBits += m_nBitsModuloBase+1 + m_iNumBitsTimeIncr +2 + NUMBITS_VP_PRED_TYPE + NUMBITS_VP_INTRA_DC_SWITCH_THR;
#endif // __TRACE_AND_STATS_

		if(m_volmd.fAUsage != RECTANGLE) {
			m_pbitstrmOut->putBits (m_volmd.bNoCrChange, 1, "VPH_VOP_CR_Change_Disable");
#ifdef __TRACE_AND_STATS_
			nBits ++;
#endif // __TRACE_AND_STATS_
			if (m_volmd.bShapeOnly==FALSE && m_vopmd.vopPredType != IVOP)  
			{  
				m_pbitstrmOut -> putBits (m_vopmd.bShapeCodingType, 1, "VPH_shape_coding_type");
#ifdef __TRACE_AND_STATS_
				nBits ++;
#endif // __TRACE_AND_STATS_
			}
		}

		if(m_volmd.bShapeOnly==FALSE) {
			m_pbitstrmOut -> putBits (m_vopmd.iIntraDcSwitchThr, NUMBITS_VP_INTRA_DC_SWITCH_THR, "VOP_DC_VLC_Switch");
			if(m_vopmd.vopPredType != IVOP) {
				m_pbitstrmOut -> putBits (m_vopmd.mvInfoForward.uiFCode, NUMBITS_VOP_FCODE, "VPH_Fcode_Forward");
#ifdef __TRACE_AND_STATS_
				nBits += NUMBITS_VOP_FCODE;
#endif // __TRACE_AND_STATS_
				if (m_vopmd.vopPredType == BVOP) {
					m_pbitstrmOut -> putBits (m_vopmd.mvInfoBackward.uiFCode, NUMBITS_VOP_FCODE, "VOP_Fcode_Backward");
#ifdef __TRACE_AND_STATS_
					nBits += NUMBITS_VOP_FCODE;
#endif // __TRACE_AND_STATS_
				}
			}
		}
	}

	return nBits;
}
#endif

UInt CVideoObjectEncoder::encodeMVVP (const CMotionVector* pmv, const CMBMode* pmbmd, Int iMBX, Int iMBY)
{
	Int iMBnum = iMBY * m_iNumMBX + iMBX;
	assert(iMBnum >= m_iVPMBnum);
	return encodeMV (pmv, pmbmd, bVPNoLeft(iMBnum, iMBX), bVPNoRightTop(iMBnum, iMBX), bVPNoTop(iMBnum),
		iMBX, iMBY);
}


//////////////////////////////////////////////////////////////////
////  The following functions are for Data partitioning mode  ////
//////////////////////////////////////////////////////////////////

Void CVideoObjectEncoder::encodeNSForPVOP_DP ()	
{
	assert( m_volmd.bDataPartitioning );
	assert( m_vopmd.vopPredType==PVOP );
	//assert(m_volmd.nBits==8);

	if (m_uiSprite == 0)	//low latency: not motion esti
		motionEstPVOP ();

	// Rate Control
	if (m_uiRateControl == RC_MPEG4) {
		Double Ec = m_iMAD / (Double) (m_iNumMBY * m_iNumMBX * 16 * 16);
		m_statRC.setMad (Ec);
		if (m_statRC.noCodedFrame () >= RC_START_RATE_CONTROL) {
			UInt newQStep = m_statRC.updateQuanStepsize ();	
			m_vopmd.intStepDiff = newQStep - m_vopmd.intStep;	// DQUANT
			m_vopmd.intStep = newQStep;
		}
		cout << "\t" << "Q:" << "\t\t\t" << m_vopmd.intStep << "\n";
		m_statRC.setQc (m_vopmd.intStep);
	}

	// MB rate control
	//Int iIndexofQ = 0;
	//Int rgiQ [4] = {-1, -2, 1, 2};
	// -----

	Int iMBX, iMBY;
	CoordI y = 0; 
	CMBMode* pmbmd = m_rgmbmd;
	Int iQPPrev = m_vopmd.intStep;
	CMotionVector* pmv = m_rgmv;
	PixelC* ppxlcRefY = (PixelC*) m_pvopcRefQ1->pixelsY () + m_iStartInRefToCurrRctY;
	PixelC* ppxlcRefU = (PixelC*) m_pvopcRefQ1->pixelsU () + m_iStartInRefToCurrRctUV;
	PixelC* ppxlcRefV = (PixelC*) m_pvopcRefQ1->pixelsV () + m_iStartInRefToCurrRctUV;
	
	PixelC* ppxlcOrigY = (PixelC*) m_pvopcOrig->pixelsBoundY ();
	PixelC* ppxlcOrigU = (PixelC*) m_pvopcOrig->pixelsBoundU ();
	PixelC* ppxlcOrigV = (PixelC*) m_pvopcOrig->pixelsBoundV ();
	
	Int iVPCounter = m_statsVOP.total();
	Int iVPtotal;
	m_iVPMBnum = 0;
	CStatistics m_statsVP;
	// DCT coefficient buffer for Data Partitioning mode
	Int*** iCoefQ_DP = new Int** [m_iNumMB];

	// Set not to output but count bitstream
	m_pbitstrmOut->SetDontSendBits(TRUE);

	Bool bRestartDelayedQP = TRUE;

	for (iMBY = 0; iMBY < m_iNumMBY; iMBY++, y += MB_SIZE) {
		PixelC* ppxlcRefMBY = ppxlcRefY;
		PixelC* ppxlcRefMBU = ppxlcRefU;
		PixelC* ppxlcRefMBV = ppxlcRefV;
		PixelC* ppxlcOrigMBY = ppxlcOrigY;
		PixelC* ppxlcOrigMBU = ppxlcOrigU;
		PixelC* ppxlcOrigMBV = ppxlcOrigV;
		CoordI x = 0; 
		for (iMBX = 0; iMBX < m_iNumMBX; iMBX++, x += MB_SIZE)	{

////#ifdef __TRACE_AND_STATS_
////			m_statsMB.reset ();
////			m_pbitstrmOut->trace (CSite (iMBX, iMBY), "MB_X_Y");
////#endif // __TRACE_AND_STATS_

			m_statsMB.reset ();

			// MB rate control
			//pmbmd->m_intStepDelta = 0;
			//iIndexofQ = (iIndexofQ + 1) % 4;
			//if (!pmbmd ->m_bhas4MVForward && !pmbmd ->m_bSkip) {
			//	if (pmbmd ->m_dctMd == INTRA)
			//		pmbmd ->m_dctMd == INTRAQ;
			//	else if (pmbmd ->m_dctMd == INTER)
			//		pmbmd->m_dctMd = INTERQ;
			//	pmbmd->m_intStepDelta = rgiQ [iIndexofQ];
			//}
			// -----

			pmbmd->m_stepSize = iQPPrev + pmbmd->m_intStepDelta;
			if(bRestartDelayedQP)
				pmbmd->m_stepSizeDelayed = pmbmd->m_stepSize;
			else
				pmbmd->m_stepSizeDelayed = iQPPrev;

			copyToCurrBuff (ppxlcOrigMBY, ppxlcOrigMBU, ppxlcOrigMBV, m_iFrameWidthY, m_iFrameWidthUV); 
			encodePVOPMB (
				ppxlcRefMBY, ppxlcRefMBU, ppxlcRefMBV,
				pmbmd, pmv,
				iMBX, iMBY,
				x, y
			);

			Int iVPlastMBnum = iMBY * m_iNumMBX + iMBX;

			// copy DCT coefficient to buffer
			iCoefQ_DP[iVPlastMBnum] = new Int* [6];
			Int iBlk;
			for (iBlk = 0; iBlk < 6; iBlk++) {
				iCoefQ_DP [iVPlastMBnum] [iBlk] = new Int [BLOCK_SQUARE_SIZE];

				for( Int t = 0; t < BLOCK_SQUARE_SIZE; t++ )
					iCoefQ_DP[iVPlastMBnum][iBlk][t] = m_rgpiCoefQ[iBlk][t];
			}

			if (!pmbmd->m_bSkip)
			{
				iQPPrev = pmbmd->m_stepSize;
				bRestartDelayedQP = FALSE;
			}

			pmbmd++;
			pmv += PVOP_MV_PER_REF_PER_MB;
#ifdef __TRACE_AND_STATS_
			m_statsVOP += m_statsMB;
#endif // __TRACE_AND_STATS_
			ppxlcRefMBY += MB_SIZE;
			ppxlcRefMBU += BLOCK_SIZE;
			ppxlcRefMBV += BLOCK_SIZE;
			ppxlcOrigMBY += MB_SIZE;
			ppxlcOrigMBU += BLOCK_SIZE;
			ppxlcOrigMBV += BLOCK_SIZE;

			iVPtotal = (int) m_statsVOP.total() - iVPCounter;
			if( iVPtotal > m_volmd.bVPBitTh || iVPlastMBnum == m_iNumMB-1 /* last MB in a VOP */) {
				// Set to output bitstream
				m_pbitstrmOut->SetDontSendBits(FALSE);
				// encode video packet
				iVPCounter = m_statsVOP.total();
				m_statsVP.reset();
				if( m_iVPMBnum > 0 )
				{
					m_statsVP.nBitsHead = codeVideoPacketHeader (m_rgmbmd[m_iVPMBnum].m_stepSize);
					bRestartDelayedQP = TRUE;
				}

				DataPartitioningMotionCoding(m_iVPMBnum, iVPlastMBnum, &m_statsVP, iCoefQ_DP);

				m_pbitstrmOut -> putBits (MOTION_MARKER, NUMBITS_DP_MOTION_MARKER, "motion_marker");
				m_statsVP.nBitsHead += NUMBITS_DP_MOTION_MARKER;

				DataPartitioningTextureCoding(m_iVPMBnum, iVPlastMBnum, &m_statsVP, iCoefQ_DP);

				//assert( iVPtotal + m_statsVP.nBitsHead == (int) m_statsVP.total() );

				m_iVPMBnum = iVPlastMBnum + 1;

				// Set not to output but count bitstream
				m_pbitstrmOut->SetDontSendBits(TRUE);
			}

		}
		MacroBlockMemory** ppmbmTemp = m_rgpmbmAbove;
		m_rgpmbmAbove = m_rgpmbmCurr;
		m_rgpmbmCurr  = ppmbmTemp;