mode.cpp

MPEG-4编解码的实现(包括MPEG4视音频编解码)

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

This software module was originally developed by 

	Ming-Chieh Lee ([e-mail]), Microsoft Corporation
	Wei-ge Chen ([e-mail]), Microsoft Corporation
	Bruce Lin ([e-mail]), Microsoft Corporation
	Chuang Gu ([e-mail]), Microsoft Corporation
	Simon Winder ([e-mail]), Microsoft Corporation
	(date: March, 1996)

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 tools 
as specified by the MPEG-4 Video. 
ISO/IEC gives users of the MPEG-4 Video free license to this software module or modifications 
thereof for use in hardware or software products claiming conformance to the MPEG-4 Video. 
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 conforming products. 
Microsoft 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 standard> conforming products. 
This copyright notice must be included in all copies or derivative works. 

Copyright (c) 1996, 1997.


Module Name:

	mode.h

Abstract:

	basic coding modes for VOP and MB

Revision History:
	Dec. 12, 1997:	Interlaced tools added by NextLevel Systems
        May. 9   1998:  add boundary by Hyundai Electronics
                                  Cheol-Soo Park ([e-mail])
        May. 9   1998:  add field based MC padding by Hyundai Electronics
                                  Cheol-Soo Park ([e-mail])
	May 9, 1999:	tm5 rate control by DemoGraFX, [e-mail]
*************************************************************************/


#include <string.h>
#include <iostream.h>
#include <math.h>
#include "typeapi.h"
#include "mode.hpp"
#include "warp.hpp"

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

#define new DEBUG_NEW				   
#endif // __MFC_

// only works for 4:2:0
#define MAX_NUM_MV 4
UInt uiNumBlks = 10;
//#define uiNumBlks 10

CMBMode::~CMBMode ()
{ 
	delete [] m_rgbCodedBlockPattern; 
	delete [] m_rgfltMinErrors; 
}

CMBMode::CMBMode ()
{
	UInt i;
	for (i = 0; i < uiNumBlks + 1; i++) {
		m_rgTranspStatus [i] = NONE;
		m_rgNumNonTranspPixels [i] = 0;
	}
	/*BBM// Added for Boundary by Hyundai(1998-5-9)
        for (i = 0; i < uiNumBlks + 1; i++)
                m_rgTranspStatusBBM[i] = NONE;
        memset (m_bMerged, FALSE, 7 * sizeof(Bool));
	// End of Hyundai(1998-5-9)*/

	// Added for field based MC padding by Hyundai(1998-5-9)
        for (i = 0; i < 5; i++)
			m_rgFieldTranspStatus [i] = ALL;
		memset (m_rgbFieldPadded, 0, 5 * sizeof(Bool));
	// End of Hyundai(1998-5-9)

	m_rgbCodedBlockPattern = new Bool [uiNumBlks];
	memset (m_rgbCodedBlockPattern, FALSE, uiNumBlks * sizeof (Bool));
	m_rgfltMinErrors = new Float [uiNumBlks];
	memset (m_rgfltMinErrors, 0, uiNumBlks * sizeof (Float));
	m_bPadded = FALSE;
	m_bSkip = FALSE;
	m_dctMd = INTRA;
	m_shpmd = UNKNOWN;
	m_mbType = FORWARD;
	m_intStepDelta = 0;
	m_bhas4MVForward = FALSE; 
	m_bhas4MVBackward = FALSE;
	m_bFieldMV = FALSE;
	m_bForwardTop = FALSE;	  
	m_bForwardBottom = FALSE;
	m_bBackwardTop = FALSE;	
	m_bBackwardBottom = FALSE;
	m_bFieldDCT = FALSE;
	m_bPerspectiveForward = FALSE;
	m_bPerspectiveBackward = FALSE;
	m_stepSize = 0;
	m_stepSizeDelayed = 0;
	m_stepSizeAlpha = 0;
	m_bACPrediction = FALSE;
	m_bInterShapeCoding = FALSE;
	m_bColocatedMBSkip = FALSE;
	m_iVideoPacketNumber = 0;	
	m_vctDirectDeltaMV = CVector (0, 0);
}

CMBMode::CMBMode (const CMBMode& md)
{
	memcpy (m_rgTranspStatus, md.m_rgTranspStatus, (uiNumBlks + 1)  * sizeof (TransparentStatus));
	memcpy (m_rgNumNonTranspPixels, md.m_rgNumNonTranspPixels, (uiNumBlks + 1)  * sizeof (UInt));
	memcpy (m_preddir,md.m_preddir,uiNumBlks * sizeof(IntraPredDirection));

	/*BBM// Added for Boundary by Hyundai(1998-5-9)
        memcpy (m_rgTranspStatusBBM, md.m_rgTranspStatusBBM, (uiNumBlks + 1)  * sizeof (TransparentStatus));
        memcpy (m_bMerged, md.m_bMerged, 7 * sizeof (Bool));
	// End of Hyundai(1998-5-9)*/

	// Added for field based MC padding by Hyundai(1998-5-9)
        memcpy (m_rgFieldTranspStatus, md.m_rgFieldTranspStatus, 5  * sizeof (TransparentStatus));
		memcpy (m_rgbFieldPadded, md.m_rgbFieldPadded, 5 * sizeof (Bool));
	// End of Hyundai(1998-5-9)

	m_bPadded = md.m_bPadded;
	m_bSkip = md.m_bSkip;
	m_CODAlpha = md.m_CODAlpha;
	m_mbType = md.m_mbType;
	m_dctMd = md.m_dctMd;
	m_shpmd = md.m_shpmd ;
	m_intStepDelta = md.m_intStepDelta;
	m_bhas4MVForward = md.m_bhas4MVForward; 
	m_bhas4MVBackward = md.m_bhas4MVBackward; 
	m_bPerspectiveForward = md.m_bPerspectiveForward;
	m_bPerspectiveBackward = md.m_bPerspectiveBackward;
	m_stepSize = md.m_stepSize;
	m_stepSizeDelayed = md.m_stepSizeDelayed;
	m_stepSizeAlpha = md.m_stepSizeAlpha;
	m_bACPrediction = md.m_bACPrediction;
	m_bACPredictionAlpha = md.m_bACPredictionAlpha;
	m_bInterShapeCoding = md.m_bInterShapeCoding;
	m_bCodeDcAsAc = md.m_bCodeDcAsAc;
	m_bCodeDcAsAcAlpha = md.m_bCodeDcAsAcAlpha;
	m_bColocatedMBSkip = md.m_bColocatedMBSkip;
	m_iVideoPacketNumber = md.m_iVideoPacketNumber;

	m_rgbCodedBlockPattern = new Bool [uiNumBlks];
	memcpy (m_rgbCodedBlockPattern, md.m_rgbCodedBlockPattern, uiNumBlks * sizeof (Bool));
	m_rgfltMinErrors = new Float [uiNumBlks];
	memcpy (m_rgfltMinErrors, md.m_rgfltMinErrors, uiNumBlks * sizeof (Float));
}

Void CMBMode::operator = (const CMBMode& md)
{
	memcpy (m_rgTranspStatus, md.m_rgTranspStatus, (uiNumBlks + 1) * sizeof (TransparentStatus));
	memcpy (m_rgNumNonTranspPixels, md.m_rgNumNonTranspPixels, (uiNumBlks + 1) * sizeof (UInt));
	memcpy (m_preddir,md.m_preddir,uiNumBlks * sizeof(IntraPredDirection));

	/*BBM// Added for Boundary by Hyundai(1998-5-9)
	memcpy (m_rgTranspStatusBBM, md.m_rgTranspStatusBBM, (uiNumBlks + 1)  * sizeof (TransparentStatus));
        memcpy (m_bMerged, md.m_bMerged, 7 * sizeof (Bool));
	// End of Hyundai(1998-5-9)*/

	// Added for field based MC padding by Hyundai(1998-5-9)
        memcpy (m_rgFieldTranspStatus, md.m_rgFieldTranspStatus, 5  * sizeof (TransparentStatus));
        memcpy (m_rgbFieldPadded, md.m_rgbFieldPadded, 5 * sizeof (Bool));
	// End of Hyundai(1998-5-9)

	m_bPadded = md.m_bPadded;
	m_bSkip = md.m_bSkip;
	m_CODAlpha = md.m_CODAlpha;
	m_mbType = md.m_mbType;
	m_dctMd = md.m_dctMd;
	m_shpmd = md.m_shpmd ;
	m_intStepDelta = md.m_intStepDelta;
	m_bhas4MVForward = md.m_bhas4MVForward; 
	m_bhas4MVBackward = md.m_bhas4MVBackward; 
	m_bPerspectiveForward = md.m_bPerspectiveForward;
	m_bPerspectiveBackward = md.m_bPerspectiveBackward;
	m_stepSize = md.m_stepSize;
	m_stepSizeDelayed = md.m_stepSizeDelayed;
	m_stepSizeAlpha = md.m_stepSizeAlpha;
	m_bACPrediction = md.m_bACPrediction;
	m_bACPredictionAlpha = md.m_bACPredictionAlpha;
	m_bInterShapeCoding = md.m_bInterShapeCoding;
	m_bCodeDcAsAc = md.m_bCodeDcAsAc;
	m_bCodeDcAsAcAlpha = md.m_bCodeDcAsAcAlpha;
	m_bColocatedMBSkip = md.m_bColocatedMBSkip;
	m_iVideoPacketNumber = md.m_iVideoPacketNumber;

	memcpy (m_rgbCodedBlockPattern, md.m_rgbCodedBlockPattern, uiNumBlks * sizeof (Bool));
	memcpy (m_rgfltMinErrors, md.m_rgfltMinErrors, uiNumBlks * sizeof (Float));
}

Void CMBMode::setCodedBlockPattern (const Bool* rgbblockNum)
{ 
	for (UInt i = 0; i < uiNumBlks; i++)
		m_rgbCodedBlockPattern[i] = rgbblockNum [i];
}

Void CMBMode::setMinError (const Float* pfltminError)
{
	for (UInt i = 0; i < uiNumBlks; i++)
		m_rgfltMinErrors[i] = pfltminError [i];

}

CDirectModeData::~CDirectModeData ()
{
	destroyMem ();
}

CDirectModeData::CDirectModeData ()
{
	m_ppmbmd = NULL;
	m_prgmv = NULL;
}

Bool CDirectModeData::inBound (UInt iMbIdx) const
{
	if (iMbIdx >= m_uiNumMB)
		return FALSE;
	else
		return TRUE;
}

Bool CDirectModeData::inBound (UInt idX, UInt idY) const
{
	if (idX >= m_uiNumMBX || idY >= m_uiNumMBY || idX * idY >= m_uiNumMB)
		return FALSE;
	else
		return TRUE;
}

Void CDirectModeData::reassign (UInt numMBX, UInt numMBY)
{
	destroyMem ();
	m_uiNumMBX = numMBX;
	m_uiNumMBY = numMBY;
	m_uiNumMB = m_uiNumMBX * m_uiNumMBY;
	m_ppmbmd = new CMBMode* [m_uiNumMB];
	m_prgmv = new CMotionVector* [m_uiNumMB];
	for (UInt i = 0; i < m_uiNumMB; i++) {
		m_ppmbmd [i] = new CMBMode;
		m_prgmv [i] = new CMotionVector [5];
	}
}

Void CDirectModeData::assign (UInt imb, const CMBMode& mbmd, const CMotionVector* rgmv)
{
	assert (inBound (imb));
	*(m_ppmbmd [imb]) = mbmd;
	memcpy (m_prgmv [imb], rgmv, 5 * sizeof (CMotionVector));
}

Void CDirectModeData::destroyMem ()
{
	if (m_ppmbmd != NULL) {
		for (UInt i = 0; i < m_uiNumMB; i++)
			delete m_ppmbmd [i];
		delete [] m_ppmbmd;
	}
	if (m_prgmv != NULL) {
		for (UInt i = 0; i < m_uiNumMB; i++)
			delete [] m_prgmv [i];
		delete [] m_prgmv;
	}
}

CStatistics::CStatistics ()
{
	reset ();
}
								
Void CStatistics::print (Bool bVOPPrint)
{
	(Void) total ();

	if (bVOPPrint)
		cout << "\t" << "VOP overhead:" << "\t\t" << nBitsHead << "\n";
	cout << "\t" << "Y:" << "\t\t\t" << nBitsY << "\n";
	cout << "\t" << "Cr:" << "\t\t\t" << nBitsCr << "\n";
	cout << "\t" << "Cb:" << "\t\t\t" << nBitsCb << "\n";
	cout << "\t" << "A:" << "\t\t\t" << nBitsA << "\n";
//	cout << "\t" << "1st Shape Code:" << "\t\t" << nBits1stShpCode << "\n";
	cout << "\t" << "CBPY:" << "\t\t\t" << nBitsCBPY << "\n";
	cout << "\t" << "MCBPC:" << "\t\t\t" << nBitsMCBPC << "\n";
	cout << "\t" << "DQUANT:" << "\t\t\t" << nBitsDQUANT << "\n";
	cout << "\t" << "nBitsMODB:" << "\t\t" << nBitsMODB << "\n";
	cout << "\t" << "nBitsCBPB:" << "\t\t" << nBitsCBPB << "\n";
	cout << "\t" << "nBitsMBTYPE:" << "\t\t" << nBitsMBTYPE << "\n";
	cout << "\t" << "nBitsIntraPred:" << "\t\t" << nBitsIntraPred << "\n";
	cout << "\t" << "nBitsNoDCT:" << "\t\t" << nBitsNoDCT << "\n";	
	cout << "\t" << "nBitsCODA:" << "\t\t" << nBitsCODA << "\n";
	cout << "\t" << "nBitsCBPA:" << "\t\t" << nBitsCBPA << "\n";
	cout << "\t" << "nBitsMODBA:" << "\t\t" << nBitsMODBA << "\n";
	cout << "\t" << "nBitsCBPBA:" << "\t\t" << nBitsCBPBA << "\n";
	cout << "\t" << "nBitsInterlace:" << "\t\t" << nBitsInterlace << "\n";
	cout << "\t" << "nBitsSTUFFING:" << "\t\t" << nBitsStuffing << "\n";
	cout << "\t" << "# of Skipped MB:" << "\t" << nSkipMB << "\n";
	cout << "\t" << "# of Inter MB:" << "\t\t" << nInterMB << "\n";
	cout << "\t" << "# of Inter4V MB:" << "\t" << nInter4VMB << "\n";
	cout << "\t" << "# of Intra MB:" << "\t\t" << nIntraMB << "\n";
	cout << "\t" << "# of Direct MB:" << "\t\t" << nDirectMB << "\n";
	cout << "\t" << "# of Forward MB:" << "\t" << nForwardMB << "\n";
	cout << "\t" << "# of Backward MB:" << "\t" << nBackwardMB << "\n";
	cout << "\t" << "# of Interpolate MB:" << "\t" << nInterpolateMB << "\n";
	cout << "\t" << "# of Field Fwd MB:" << "\t" << nFieldForwardMB << "\n";
	cout << "\t" << "# of Field Back MB:" << "\t" << nFieldBackwardMB << "\n";
	cout << "\t" << "# of Field Ave MB:" << "\t" << nFieldInterpolateMB << "\n";
	cout << "\t" << "# of Field Direct MB:" << "\t" << nFieldDirectMB << "\n";
	cout << "\t" << "# of Field DCT MBs:" << "\t" << nFieldDCTMB << "\n";
	cout << "\t" << "Motion:" << "\t\t\t" << nBitsMV << "\n";
	cout << "\t" << "Texture:" << "\t\t" << nBitsTexture << "\n";
//	if (bVOPPrint)
		cout << "\t" << "Shape:" << "\t\t\t" << nBitsShape << "\n";
	cout << "\t" << "Total:" << "\t\t\t" << nBitsTotal << "\n";
	cout << "\t" << "SNR Y:" << "\t\t\t" << dSNRY / nVOPs << " dB\n";
	cout << "\t" << "SNR U:" << "\t\t\t" << dSNRU / nVOPs << " dB\n";
	cout << "\t" << "SNR V:" << "\t\t\t" << dSNRV / nVOPs << " dB\n";
	cout << "\t" << "SNR A:" << "\t\t\t" << dSNRA / nVOPs << " dB\n\n";
	cout << "\t" << "average Qp:" << "\t\t" << (Double)nQp / nQMB << "\n\n";
	cout.flush ();
}

Void CStatistics::operator += (const CStatistics& statSrc)