sesenc.cpp

jpeg and mpeg 编解码技术源代码

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

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
	(date: March, 1996)
and edited by
        Wei Wu ([e-mail]) Rockwell Science Center

and also edited by
	Yoshihiro Kikuchi (TOSHIBA CORPORATION)
	Takeshi Nagai (TOSHIBA CORPORATION)
	Toshiaki Watanabe (TOSHIBA CORPORATION)
	Noboru Yamaguchi (TOSHIBA CORPORATION)

	Marc Mongenet ([e-mail]), Swiss Federal Institute of Technology, Lausanne (EPFL)

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:

	sesEnc.cpp

Abstract:

	Encoder for one video session.

Revision History:
	Sept. 30, 1997: Error resilient tools added by Toshiba
	Nov.  27, 1997: Spatial Scalable tools added, and modified for Spatial Scalable
						by Takefumi Nagumo([e-mail]) SONY
	Dec 11, 1997:	Interlaced tools added by NextLevel Systems (GI)
						(B.Eifrig, [e-mail], X.Chen, [e-mail])
	Jun 17, 1998:	add Complexity Estimation syntax support
					Marc Mongenet (Marc.Mongenet@epfl) - EPFL
	May 9, 1999:	tm5 rate control by DemoGraFX, [e-mail]

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

#include "stdlib.h"
#include "stdio.h"
#include "math.h"
#include "fstream.h"
#include "iostream.h"

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

#include "mode.hpp"
#include "sesenc.hpp"

#include "tps_enhcbuf.hpp" // added by Sharp (98/2/12)
#include "vopses.hpp"
#include "vopseenc.hpp"
#include "enhcbufenc.hpp" // added by Sharp (98/2/12)

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

#define new DEBUG_NEW				   
#endif // __MFC_

#ifdef __PC_COMPILER_					//OS specific stuff
#define SUB_CMPFILE "%s\\%2.2d\\%s.cmp"
#define SUB_TRCFILE "%s\\%2.2d\\%s.trc"
#define SUB_YUVFILE	"%s\\%2.2d\\%s.yuv"
#define SUB_SEGFILE	"%s\\%2.2d\\%s.seg"
#define ENHN_SUB_CMPFILE "%s\\%2.2d\\%s_e.cmp"
#define ENHN_SUB_TRCFILE "%s\\%2.2d\\%s_e.trc"
#define ENHN_SUB_YUVFILE "%s\\%2.2d\\%s_e.yuv"
#define ENHN_SUB_SEGFILE "%s\\%2.2d\\%s_e.seg"
#define SUB_VDLFILE "%s\\%2.2d\\%s.spt"	//for sprite i/o
#define SUB_PNTFILE "%s\\%2.2d\\%s.pnt"	//for sprite i/o
#define ROOT_YUVFILE "%s\\%s.yuv"
#define ROOT_SEGFILE "%s\\%s.seg"
#define IOS_BINARY ios::binary
#define MKDIR "mkdir %s\\%2.2d"
#else
#define SUB_CMPFILE "%s/%2.2d/%s.cmp"
#define SUB_TRCFILE "%s/%2.2d/%s.trc"
#define SUB_YUVFILE	"%s/%2.2d/%s.yuv"
#define SUB_SEGFILE	"%s/%2.2d/%s.seg"
#define ENHN_SUB_CMPFILE "%s/%2.2d/%s_e.cmp"
#define ENHN_SUB_TRCFILE "%s/%2.2d/%s_e.trc"
#define ENHN_SUB_YUVFILE "%s/%2.2d/%s_e.yuv"
#define ENHN_SUB_SEGFILE "%s/%2.2d/%s_e.seg"
#define SUB_VDLFILE "%s/%2.2d/%s.vdl"	//for sprite i/o
#define SUB_PNTFILE "%s/%2.2d/%s.pnt"	//for sprite i/o
#define ROOT_YUVFILE "%s/%s.yuv"
#define ROOT_SEGFILE "%s/%s.seg"
#define IOS_BINARY ios::binary
//#define IOS_BINARY 0
#define MKDIR "mkdir %s/%2.2d"
#endif

#define BASE_LAYER 0
#define ENHN_LAYER 1

#define _FOR_GSSP_

Bool fileExistence (const Char* pchFile) 
{
	Bool ret = 1;
	FILE* pf = fopen (pchFile, "r");
	if (pf == NULL)
		ret = 0;
	else
		fclose (pf);
	return ret;
}

Void CSessionEncoder::createReconDir (UInt idx) const
{
	Char pchTmp [100];
	sprintf (pchTmp, SUB_YUVFILE, m_pchReconYUVDir, idx, m_pchPrefix);
	FILE* pf = fopen (pchTmp, "wb");
	if (pf == NULL) {
		sprintf (pchTmp, MKDIR, m_pchReconYUVDir, idx);
		system (pchTmp);																	
	}
	else
		fclose (pf);
}

Void CSessionEncoder::createCmpDir (UInt idx) const
{
	Char pchTmp [100];
	sprintf (pchTmp, SUB_CMPFILE, m_pchOutStrFiles, idx, m_pchPrefix);
	FILE* pf = fopen (pchTmp, "wb");
	if (pf == NULL) {
		sprintf (pchTmp, MKDIR, m_pchOutStrFiles, idx);
		system (pchTmp);																	
	}
	else
		fclose (pf);
}

CSessionEncoder::~CSessionEncoder ()
{
	delete [] m_rgvolmd [BASE_LAYER];
	delete [] m_rgvolmd [ENHN_LAYER];
	delete [] m_rgvopmd [BASE_LAYER];
	delete [] m_rgvopmd [ENHN_LAYER];

	// sprite 
	for (Int iVO = 0; iVO < m_iNumVO; iVO++) {
		delete [] m_ppstSrc [iVO];
		for (Int ifr = 0; ifr < m_iNumFrame; ifr++)
			delete [] m_pppstDst [iVO] [ifr];
		delete [] m_pppstDst [iVO];
	}
	delete [] m_ppstSrc;
	delete [] m_pppstDst;
}


CSessionEncoder::CSessionEncoder (CSessionEncoderParams *param)
{
	m_iFirstFrame = param->iFirstFrm;
	m_iLastFrame = param->iLastFrm;
	m_iFirstVO = param->uiFirstVO; 
	m_iLastVO = param->iLastVO;
	m_rgbSpatialScalability = param->rgbSpatialScalability;
	m_rguiRateControl = param->rguiRateControl; 
	m_rguiBudget = param->rguiBudget;
	m_pchPrefix = param->pchPrefix; 
	m_pchBmpFiles = param->pchBmpFiles;
	m_rgfChrType = param->rgfChrType; 
	m_pchReconYUVDir = param->pchOutBmpFiles; 
	m_pchOutStrFiles = param->pchOutStrFiles;
	m_pchSptDir = param->pchSptDir; 
	m_pchSptPntDir = param->pchSptPntDir;
	m_rguiSpriteUsage = param->rguiSpriteUsage; 
	m_rguiWarpingAccuracy = param->rguiWarpingAccuracy; 
	m_rgNumOfPnts = param->rgNumOfPnts; 
	m_rgiTemporalScalabilityType = param->rgiTemporalScalabilityType;
#define PARAM(abc) abc = param->abc
	  UInt PARAM(uiFrmWidth);
	UInt PARAM(uiFrmHeight);
	Bool PARAM(bNot8Bit);
	UInt PARAM(uiQuantPrecision);
	UInt PARAM(nBits);
	const Int* PARAM(rgiEnhancementType);

	const AlphaUsage* PARAM(rgfAlphaUsage);
	const Bool* PARAM(rgbShapeOnly);
	const Int* PARAM(rgiBinaryAlphaTH);
	const Int* PARAM(rgiBinaryAlphaRR);
	const Bool* PARAM(rgbNoCrChange);
	UInt** PARAM(rguiSearchRange);
	Bool** PARAM(rgbOriginalForME);
	Bool** PARAM(rgbAdvPredDisable);
	Bool ** PARAM(rgbComplexityEstimationDisable);
	Bool ** PARAM(rgbOpaque);
	Bool ** PARAM(rgbTransparent);
	Bool ** PARAM(rgbIntraCAE);
	Bool ** PARAM(rgbInterCAE);
	Bool ** PARAM(rgbNoUpdate);
	Bool ** PARAM(rgbUpsampling);
	Bool ** PARAM(rgbIntraBlocks);
	Bool ** PARAM(rgbInterBlocks);
	Bool ** PARAM(rgbInter4vBlocks);
	Bool ** PARAM(rgbNotCodedBlocks);
	Bool ** PARAM(rgbDCTCoefs);
	Bool ** PARAM(rgbDCTLines);
	Bool ** PARAM(rgbVLCSymbols);
	Bool ** PARAM(rgbVLCBits);
	Bool ** PARAM(rgbAPM);
	Bool ** PARAM(rgbNPM);
	Bool ** PARAM(rgbInterpolateMCQ);
	Bool ** PARAM(rgbForwBackMCQ);
	Bool ** PARAM(rgbHalfpel2);
	Bool ** PARAM(rgbHalfpel4);
	UInt ** PARAM(rguiVolControlParameters);
	UInt ** PARAM(rguiChromaFormat);
	UInt ** PARAM(rguiLowDelay);
	UInt ** PARAM(rguiVBVParams);
	UInt ** PARAM(rguiBitRate);
	UInt ** PARAM(rguiVbvBufferSize);
	UInt ** PARAM(rguiVbvBufferOccupany);
	Double** PARAM(rgdFrameFrequency);
	Bool** PARAM(rgbInterlacedCoding);
	Bool** PARAM(rgbTopFieldFirst);
	Bool** PARAM(rgbAlternateScan);
	Int** PARAM(rgiDirectModeRadius);
	Int** PARAM(rgiMVFileUsage);
	Char*** PARAM(pchMVFileName);
	Int**	PARAM(rgbVPBitTh);
	Bool**	PARAM(rgbDataPartitioning);
	Bool**	PARAM(rgbReversibleVlc);
	Quantizer** PARAM(rgfQuant);
	Bool** PARAM(rgbLoadIntraMatrix);
	Int*** PARAM(rgppiIntraQuantizerMatrix);
	Bool** PARAM(rgbLoadInterMatrix);
	Int*** PARAM(rgppiInterQuantizerMatrix);
	Int** PARAM(rgiIntraDCSwitchingThr);
	Int** PARAM(rgiStepI);
	Int** PARAM(rgiStepP);
	Bool**	PARAM(rgbLoadIntraMatrixAlpha);
	Int*** PARAM(rgppiIntraQuantizerMatrixAlpha);
	Bool**	PARAM(rgbLoadInterMatrixAlpha);
	Int*** PARAM(rgppiInterQuantizerMatrixAlpha);
	Int** PARAM(rgiStepIAlpha);
	Int** PARAM(rgiStepPAlpha);
	Int** PARAM(rgiStepBAlpha);
	Int** PARAM(rgbNoAlphaQuantUpdate);
	Int** PARAM(rgiStepB);
	const Int* PARAM(rgiNumOfBbetweenPVOP);
	const Int* PARAM(rgiNumOfPbetweenIVOP);
	const Int* PARAM(rgiGOVperiod);
	const Bool* PARAM(rgbDeblockFilterDisable);
	const Bool *PARAM(rgbAllowSkippedPMBs);
	const Int* PARAM(rgiTemporalRate);
	const Int* PARAM(rgiEnhnTemporalRate);
	const Bool* PARAM(rgbDumpMB);
	const Bool* PARAM(rgbTrace);
	const Bool* PARAM(rgbRoundingControlDisable); 
	const Int* PARAM(rgiInitialRoundingType); 
	SptMode *PARAM(pSpriteMode);
	Int PARAM(iSpatialOption);
	UInt PARAM(uiFrmWidth_SS);
	UInt PARAM(uiFrmHeight_SS);
	UInt PARAM(uiHor_sampling_n);
	UInt PARAM(uiHor_sampling_m);
	UInt PARAM(uiVer_sampling_n);
	UInt PARAM(uiVer_sampling_m);
#undef PARAM
	// data preparation
	m_iNumFrame = m_iLastFrame - m_iFirstFrame + 1;
	assert (m_iNumFrame > 0);
	m_rctOrg = CRct (0, 0, uiFrmWidth, uiFrmHeight);
	if( uiFrmWidth_SS !=0 && uiFrmHeight_SS!=0)
		m_rctOrgSpatialEnhn = CRct(0, 0, uiFrmWidth_SS, uiFrmHeight_SS);
	assert (uiFrmWidth <= 8192 && uiFrmHeight <= 8192); //2^13 maximum size
	m_iNumVO = m_iLastVO - m_iFirstVO + 1;
	assert (m_iNumVO > 0);
	m_rgvolmd [BASE_LAYER] = new VOLMode [m_iNumVO];
	m_rgvolmd [ENHN_LAYER] = new VOLMode [m_iNumVO];
	m_rgvopmd [BASE_LAYER] = new VOPMode [m_iNumVO];
	m_rgvopmd [ENHN_LAYER] = new VOPMode [m_iNumVO];
	Int iVO;
	for (iVO = 0; iVO < m_iNumVO; iVO++) {
		// set VOL and VOP mode values
		for (Int iLayer = BASE_LAYER; iLayer <= m_rgbSpatialScalability [iVO] * ENHN_LAYER; iLayer++)	{
			// NBIT
			m_rgvolmd [iLayer][iVO].bNot8Bit 		= bNot8Bit;
			m_rgvolmd [iLayer][iVO].uiQuantPrecision 	= uiQuantPrecision;
			m_rgvolmd [iLayer][iVO].nBits 			= nBits;

			m_rgvolmd [iLayer][iVO].volType			= (VOLtype) iLayer;
			m_rgvolmd [iLayer][iVO].fAUsage			= rgfAlphaUsage [iVO];