Context navigation

TEncGOP.cpp @ 892

Visit:

Last change on this file since 892 was 91, checked in by qualcomm, 13 years ago
M24937 with macro QC_MULTI_DIS_CAN
Property svn:eol-style set to `native`
File size: 93.7 KB

Rev	Line
[5]	1	/* The copyright in this software is being made available under the BSD
	2	* License, included below. This software may be subject to other third party
	3	* and contributor rights, including patent rights, and no such rights are
[56]	4	* granted under this license.
[5]	5	*
[56]	6	* Copyright (c) 2010-2012, ITU/ISO/IEC
[5]	7	* All rights reserved.
	8	*
	9	* Redistribution and use in source and binary forms, with or without
	10	* modification, are permitted provided that the following conditions are met:
	11	*
	12	* * Redistributions of source code must retain the above copyright notice,
	13	* this list of conditions and the following disclaimer.
	14	* * Redistributions in binary form must reproduce the above copyright notice,
	15	* this list of conditions and the following disclaimer in the documentation
	16	* and/or other materials provided with the distribution.
[56]	17	* * Neither the name of the ITU/ISO/IEC nor the names of its contributors may
[5]	18	* be used to endorse or promote products derived from this software without
	19	* specific prior written permission.
	20	*
	21	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
	22	* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	23	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	24	* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
	25	* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
	26	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
	27	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
	28	* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
	29	* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
	30	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
	31	* THE POSSIBILITY OF SUCH DAMAGE.
	32	*/
[2]	33
[56]	34	/** \file TEncGOP.cpp
[2]	35	\brief GOP encoder class
	36	*/
	37
[56]	38	#include <list>
	39	#include <algorithm>
	40
[2]	41	#include "TEncTop.h"
	42	#include "TEncGOP.h"
	43	#include "TEncAnalyze.h"
[56]	44	#include "libmd5/MD5.h"
	45	#include "TLibCommon/SEI.h"
	46	#include "TLibCommon/NAL.h"
	47	#include "NALwrite.h"
	48	#include "../../App/TAppEncoder/TAppEncTop.h"
[2]	49
	50	#include <time.h>
[56]	51	#include <math.h>
[2]	52
[56]	53	using namespace std;
[2]	54
[56]	55	//! \ingroup TLibEncoder
	56	//! \{
	57
[2]	58	// ====================================================================================================================
	59	// Constructor / destructor / initialization / destroy
	60	// ====================================================================================================================
	61
[56]	62	TEncGOP::TEncGOP()
[2]	63	{
[56]	64	m_iLastIDR = 0;
	65	m_iGopSize = 0;
	66	m_iNumPicCoded = 0; //Niko
	67	m_bFirst = true;
	68
[2]	69	m_pcCfg = NULL;
	70	m_pcSliceEncoder = NULL;
	71	m_pcListPic = NULL;
[56]	72
[2]	73	m_pcEntropyCoder = NULL;
	74	m_pcCavlcCoder = NULL;
	75	m_pcSbacCoder = NULL;
	76	m_pcBinCABAC = NULL;
[5]	77	#if DEPTH_MAP_GENERATION
[2]	78	m_pcDepthMapGenerator = NULL;
[5]	79	#endif
	80	#if HHI_INTER_VIEW_RESIDUAL_PRED
[2]	81	m_pcResidualGenerator = NULL;
[5]	82	#endif
[56]	83
	84	m_bSeqFirst = true;
	85
[2]	86	m_bRefreshPending = 0;
[56]	87	m_pocCRA = 0;
[2]	88
	89	return;
	90	}
	91
[56]	92	TEncGOP::~TEncGOP()
[2]	93	{
	94	}
	95
	96	/** Create list to contain pointers to LCU start addresses of slice.
	97	* \param iWidth, iHeight are picture width, height. iMaxCUWidth, iMaxCUHeight are LCU width, height.
	98	*/
[56]	99	Void TEncGOP::create( Int iWidth, Int iHeight, UInt iMaxCUWidth, UInt iMaxCUHeight )
[2]	100	{
	101	UInt uiWidthInCU = ( iWidth %iMaxCUWidth ) ? iWidth /iMaxCUWidth + 1 : iWidth /iMaxCUWidth;
	102	UInt uiHeightInCU = ( iHeight%iMaxCUHeight ) ? iHeight/iMaxCUHeight + 1 : iHeight/iMaxCUHeight;
	103	UInt uiNumCUsInFrame = uiWidthInCU * uiHeightInCU;
[56]	104	m_uiStoredStartCUAddrForEncodingSlice = new UInt [uiNumCUsInFrame*(1<<(g_uiMaxCUDepth<<1))+1];
	105	m_uiStoredStartCUAddrForEncodingEntropySlice = new UInt [uiNumCUsInFrame*(1<<(g_uiMaxCUDepth<<1))+1];
	106	m_bLongtermTestPictureHasBeenCoded = 0;
	107	m_bLongtermTestPictureHasBeenCoded2 = 0;
[2]	108	}
	109
[56]	110	Void TEncGOP::destroy()
[2]	111	{
	112	delete [] m_uiStoredStartCUAddrForEncodingSlice; m_uiStoredStartCUAddrForEncodingSlice = NULL;
	113	delete [] m_uiStoredStartCUAddrForEncodingEntropySlice; m_uiStoredStartCUAddrForEncodingEntropySlice = NULL;
	114	}
	115
[56]	116	Void TEncGOP::init ( TEncTop* pcTEncTop )
[2]	117	{
	118	m_pcEncTop = pcTEncTop;
	119	m_pcCfg = pcTEncTop;
	120	m_pcSliceEncoder = pcTEncTop->getSliceEncoder();
	121	m_pcListPic = pcTEncTop->getListPic();
[56]	122
[2]	123	m_pcEntropyCoder = pcTEncTop->getEntropyCoder();
	124	m_pcCavlcCoder = pcTEncTop->getCavlcCoder();
	125	m_pcSbacCoder = pcTEncTop->getSbacCoder();
	126	m_pcBinCABAC = pcTEncTop->getBinCABAC();
	127	m_pcLoopFilter = pcTEncTop->getLoopFilter();
	128	m_pcBitCounter = pcTEncTop->getBitCounter();
[56]	129
[5]	130	#if DEPTH_MAP_GENERATION
[2]	131	m_pcDepthMapGenerator = pcTEncTop->getDepthMapGenerator();
[5]	132	#endif
	133	#if HHI_INTER_VIEW_RESIDUAL_PRED
[2]	134	m_pcResidualGenerator = pcTEncTop->getResidualGenerator();
[5]	135	#endif
[56]	136
[2]	137	// Adaptive Loop filter
	138	m_pcAdaptiveLoopFilter = pcTEncTop->getAdaptiveLoopFilter();
	139	//--Adaptive Loop filter
	140	m_pcSAO = pcTEncTop->getSAO();
	141	m_pcRdCost = pcTEncTop->getRdCost();
	142	}
	143
	144	// ====================================================================================================================
	145	// Public member functions
	146	// ====================================================================================================================
	147
[56]	148	Void TEncGOP::initGOP( Int iPOCLast, Int iNumPicRcvd, TComList<TComPic>& rcListPic, TComList<TComPicYuv>& rcListPicYuvRecOut, std::list<AccessUnit>& accessUnitsInGOP)
[2]	149	{
[56]	150	xInitGOP( iPOCLast, iNumPicRcvd, rcListPic, rcListPicYuvRecOut );
	151	m_iNumPicCoded = 0;
	152	}
	153
	154	Void TEncGOP::compressPicInGOP( Int iPOCLast, Int iNumPicRcvd, TComList<TComPic>& rcListPic, TComList<TComPicYuv>& rcListPicYuvRecOut, std::list<AccessUnit>& accessUnitsInGOP, Int iGOPid)
	155	{
	156	TComPic* pcPic;
	157	TComPicYuv* pcPicYuvRecOut;
[2]	158	TComSlice* pcSlice;
[56]	159	TComOutputBitstream *pcBitstreamRedirect;
	160	pcBitstreamRedirect = new TComOutputBitstream;
	161	#if !REMOVE_TILE_DEPENDENCE
	162	OutputNALUnit *naluBuffered = NULL;
	163	Bool bIteratorAtListStart = false;
	164	#endif
	165	AccessUnit::iterator itLocationToPushSliceHeaderNALU; // used to store location where NALU containing slice header is to be inserted
	166	UInt uiOneBitstreamPerSliceLength = 0;
	167	TEncSbac* pcSbacCoders = NULL;
	168	TComOutputBitstream* pcSubstreamsOut = NULL;
[5]	169
[56]	170	{
	171	UInt uiColDir = 1;
[2]	172	//-- For time output for each slice
	173	long iBeforeTime = clock();
[56]	174
	175	//select uiColDir
	176	Int iCloseLeft=1, iCloseRight=-1;
	177	for(Int i = 0; i<m_pcCfg->getGOPEntry(iGOPid).m_numRefPics; i++)
	178	{
	179	Int iRef = m_pcCfg->getGOPEntry(iGOPid).m_referencePics[i];
	180	if(iRef>0&&(iRef<iCloseRight\|\|iCloseRight==-1))
	181	{
	182	iCloseRight=iRef;
	183	}
	184	else if(iRef<0&&(iRef>iCloseLeft\|\|iCloseLeft==1))
	185	{
	186	iCloseLeft=iRef;
	187	}
	188	}
	189	if(iCloseRight>-1)
	190	{
	191	iCloseRight=iCloseRight+m_pcCfg->getGOPEntry(iGOPid).m_POC-1;
	192	}
	193	if(iCloseLeft<1)
	194	{
	195	iCloseLeft=iCloseLeft+m_pcCfg->getGOPEntry(iGOPid).m_POC-1;
	196	while(iCloseLeft<0)
	197	{
	198	iCloseLeft+=m_iGopSize;
	199	}
	200	}
	201	Int iLeftQP=0, iRightQP=0;
	202	for(Int i=0; i<m_iGopSize; i++)
	203	{
	204	if(m_pcCfg->getGOPEntry(i).m_POC==(iCloseLeft%m_iGopSize)+1)
	205	{
	206	iLeftQP= m_pcCfg->getGOPEntry(i).m_QPOffset;
	207	}
	208	if (m_pcCfg->getGOPEntry(i).m_POC==(iCloseRight%m_iGopSize)+1)
	209	{
	210	iRightQP=m_pcCfg->getGOPEntry(i).m_QPOffset;
	211	}
	212	}
	213	if(iCloseRight>-1&&iRightQP<iLeftQP)
	214	{
	215	uiColDir=0;
	216	}
[2]	217
[56]	218	/////////////////////////////////////////////////////////////////////////////////////////////////// Initial to start encoding
	219	UInt uiPOCCurr = iPOCLast -iNumPicRcvd+ m_pcCfg->getGOPEntry(iGOPid).m_POC;
	220	Int iTimeOffset = m_pcCfg->getGOPEntry(iGOPid).m_POC;
	221	if(iPOCLast == 0)
	222	{
	223	uiPOCCurr=0;
	224	iTimeOffset = 1;
	225	}
	226	if(uiPOCCurr>=m_pcCfg->getFrameToBeEncoded())
	227	{
	228	return;
	229	}
	230	if( getNalUnitTypeBaseViewMvc( uiPOCCurr ) == NAL_UNIT_CODED_SLICE_IDR )
	231	{
	232	m_iLastIDR = uiPOCCurr;
	233	}
[5]	234
[56]	235	/* start a new access unit: create an entry in the list of output
	236	* access units */
	237	accessUnitsInGOP.push_back(AccessUnit());
	238	AccessUnit& accessUnit = accessUnitsInGOP.back();
	239	xGetBuffer( rcListPic, rcListPicYuvRecOut, iNumPicRcvd, iTimeOffset, pcPic, pcPicYuvRecOut, uiPOCCurr );
	240
[2]	241	// Slice data initialization
	242	pcPic->clearSliceBuffer();
	243	assert(pcPic->getNumAllocatedSlice() == 1);
	244	m_pcSliceEncoder->setSliceIdx(0);
	245	pcPic->setCurrSliceIdx(0);
[56]	246
	247	std::vector<TComAPS>& vAPS = m_pcEncTop->getAPS();
[77]	248	#if VIDYO_VPS_INTEGRATION
	249	m_pcSliceEncoder->initEncSlice ( pcPic, iPOCLast, uiPOCCurr, iNumPicRcvd, iGOPid, pcSlice, m_pcEncTop->getEncTop()->getVPS(), m_pcEncTop->getSPS(), m_pcEncTop->getPPS() );
	250	#else
[56]	251	m_pcSliceEncoder->initEncSlice ( pcPic, iPOCLast, uiPOCCurr, iNumPicRcvd, iGOPid, pcSlice, m_pcEncTop->getSPS(), m_pcEncTop->getPPS() );
[77]	252	#endif
[56]	253	pcSlice->setLastIDR(m_iLastIDR);
[2]	254	pcSlice->setSliceIdx(0);
[56]	255	pcSlice->setViewId( m_pcEncTop->getViewId() );
	256	pcSlice->setIsDepth( m_pcEncTop->getIsDepth() );
[5]	257
[56]	258	m_pcEncTop->getSPS()->setDisInter4x4(m_pcEncTop->getDisInter4x4());
	259	pcSlice->setScalingList ( m_pcEncTop->getScalingList() );
	260	if(m_pcEncTop->getUseScalingListId() == SCALING_LIST_OFF)
	261	{
	262	m_pcEncTop->getTrQuant()->setFlatScalingList();
	263	m_pcEncTop->getTrQuant()->setUseScalingList(false);
	264	}
	265	else if(m_pcEncTop->getUseScalingListId() == SCALING_LIST_DEFAULT)
	266	{
	267	pcSlice->setDefaultScalingList ();
	268	pcSlice->getScalingList()->setScalingListPresentFlag(true);
	269	m_pcEncTop->getTrQuant()->setScalingList(pcSlice->getScalingList());
	270	m_pcEncTop->getTrQuant()->setUseScalingList(true);
	271	}
	272	else if(m_pcEncTop->getUseScalingListId() == SCALING_LIST_FILE_READ)
	273	{
	274	if(pcSlice->getScalingList()->xParseScalingList(m_pcCfg->getScalingListFile()))
	275	{
	276	pcSlice->setDefaultScalingList ();
	277	}
	278	#if SCALING_LIST
	279	pcSlice->getScalingList()->checkDcOfMatrix();
	280	#endif
	281	pcSlice->getScalingList()->setScalingListPresentFlag(pcSlice->checkDefaultScalingList());
	282	m_pcEncTop->getTrQuant()->setScalingList(pcSlice->getScalingList());
	283	m_pcEncTop->getTrQuant()->setUseScalingList(true);
	284	}
	285	else
	286	{
	287	printf("error : ScalingList == %d no support\n",m_pcEncTop->getUseScalingListId());
	288	assert(0);
	289	}
[2]	290
[56]	291	#if HHI_INTERVIEW_SKIP
	292	if ( m_pcEncTop->getInterViewSkip() )
	293	{
	294	m_pcEncTop->getEncTop()->getUsedPelsMap( pcPic->getViewId(), pcPic->getPOC(), pcPic->getUsedPelsMap() );
	295	}
	296	#endif
	297	// Slice info. refinement
	298	if( pcSlice->getSliceType() == B_SLICE )
	299	{
	300	if( m_pcCfg->getGOPEntry( (getNalUnitType(uiPOCCurr) == NAL_UNIT_CODED_SLICE_IDV) ? MAX_GOP : iGOPid ).m_sliceType == 'P' ) { pcSlice->setSliceType( P_SLICE ); }
	301	}
[5]	302
[2]	303	// Set the nal unit type
[56]	304	pcSlice->setNalUnitType( getNalUnitType(uiPOCCurr) );
	305	pcSlice->setNalUnitTypeBaseViewMvc( getNalUnitTypeBaseViewMvc(uiPOCCurr) );
[2]	306
[56]	307	// Do decoding refresh marking if any
	308	pcSlice->decodingRefreshMarking(m_pocCRA, m_bRefreshPending, rcListPic);
	309
	310	if ( !pcSlice->getPPS()->getEnableTMVPFlag() && pcPic->getTLayer() == 0 )
	311	{
	312	pcSlice->decodingMarkingForNoTMVP( rcListPic, pcSlice->getPOC() );
	313	}
	314
	315	m_pcEncTop->selectReferencePictureSet(pcSlice, uiPOCCurr, iGOPid,rcListPic);
	316	pcSlice->getRPS()->setNumberOfLongtermPictures(0);
	317
	318	if(pcSlice->checkThatAllRefPicsAreAvailable(rcListPic, pcSlice->getRPS(), false) != 0)
	319	{
	320	pcSlice->createExplicitReferencePictureSetFromReference(rcListPic, pcSlice->getRPS());
	321	}
	322	pcSlice->applyReferencePictureSet(rcListPic, pcSlice->getRPS());
	323
	324	#if H0566_TLA && H0566_TLA_SET_FOR_SWITCHING_POINTS
	325	if(pcSlice->getTLayer() > 0)
	326	{
	327	if(pcSlice->isTemporalLayerSwitchingPoint(rcListPic, pcSlice->getRPS()))
	328	{
	329	pcSlice->setNalUnitType(NAL_UNIT_CODED_SLICE_TLA);
	330	}
	331	}
[2]	332	#endif
	333
[56]	334	pcSlice->setNumRefIdx( REF_PIC_LIST_0, min( m_pcCfg->getGOPEntry( (getNalUnitType(uiPOCCurr) == NAL_UNIT_CODED_SLICE_IDV) ? MAX_GOP : iGOPid ).m_numRefPicsActive, (pcSlice->getRPS()->getNumberOfPictures() + pcSlice->getSPS()->getNumberOfUsableInterViewRefs()) ) );
	335	pcSlice->setNumRefIdx( REF_PIC_LIST_1, min( m_pcCfg->getGOPEntry( (getNalUnitType(uiPOCCurr) == NAL_UNIT_CODED_SLICE_IDV) ? MAX_GOP : iGOPid ).m_numRefPicsActive, (pcSlice->getRPS()->getNumberOfPictures() + pcSlice->getSPS()->getNumberOfUsableInterViewRefs()) ) );
[2]	336
[56]	337	TComRefPicListModification* refPicListModification = pcSlice->getRefPicListModification();
	338	refPicListModification->setRefPicListModificationFlagL0( false );
	339	#if !H0137_0138_LIST_MODIFICATION
	340	refPicListModification->setNumberOfRefPicListModificationsL0(0);
	341	#endif
	342	refPicListModification->setRefPicListModificationFlagL1( false );
	343	#if !H0137_0138_LIST_MODIFICATION
	344	refPicListModification->setNumberOfRefPicListModificationsL1(0);
	345	#endif
	346	xSetRefPicListModificationsMvc( pcSlice, uiPOCCurr, iGOPid );
[5]	347
[56]	348	#if ADAPTIVE_QP_SELECTION
	349	pcSlice->setTrQuant( m_pcEncTop->getTrQuant() );
	350	#endif
	351	// Set reference list
	352	TAppEncTop* tAppEncTop = m_pcEncTop->getEncTop();
	353	assert( tAppEncTop != NULL );
[2]	354
[56]	355	TComPic * const pcTexturePic = m_pcEncTop->getIsDepth() ? tAppEncTop->getPicFromView( m_pcEncTop->getViewId(), pcSlice->getPOC(), false ) : NULL;
	356	assert( !m_pcEncTop->getIsDepth() \|\| pcTexturePic != NULL );
	357	pcSlice->setTexturePic( pcTexturePic );
[5]	358
[56]	359	std::vector<TComPic*> apcInterViewRefPics = tAppEncTop->getInterViewRefPics( m_pcEncTop->getViewId(), pcSlice->getPOC(), m_pcEncTop->getIsDepth(), pcSlice->getSPS() );
	360	pcSlice->setRefPicListMvc( rcListPic, apcInterViewRefPics );
	361
	362	// Slice info. refinement
	363	if( pcSlice->getSliceType() == B_SLICE )
	364	{
	365	if( m_pcCfg->getGOPEntry( (getNalUnitType(uiPOCCurr) == NAL_UNIT_CODED_SLICE_IDV) ? MAX_GOP : iGOPid ).m_sliceType == 'P' ) { pcSlice->setSliceType( P_SLICE ); }
	366	}
	367
	368	if (pcSlice->getSliceType() != B_SLICE \|\| !pcSlice->getSPS()->getUseLComb())
	369	{
	370	pcSlice->setNumRefIdx(REF_PIC_LIST_C, 0);
	371	pcSlice->setRefPicListCombinationFlag(false);
	372	pcSlice->setRefPicListModificationFlagLC(false);
	373	}
	374	else
	375	{
	376	pcSlice->setRefPicListCombinationFlag(pcSlice->getSPS()->getUseLComb());
	377	pcSlice->setRefPicListModificationFlagLC(pcSlice->getSPS()->getLCMod());
	378	pcSlice->setNumRefIdx(REF_PIC_LIST_C, pcSlice->getNumRefIdx(REF_PIC_LIST_0));
	379	}
	380
	381	if (pcSlice->getSliceType() == B_SLICE)
	382	{
	383	pcSlice->setColDir(uiColDir);
	384	Bool bLowDelay = true;
	385	Int iCurrPOC = pcSlice->getPOC();
	386	Int iRefIdx = 0;
	387
	388	for (iRefIdx = 0; iRefIdx < pcSlice->getNumRefIdx(REF_PIC_LIST_0) && bLowDelay; iRefIdx++)
	389	{
	390	if ( pcSlice->getRefPic(REF_PIC_LIST_0, iRefIdx)->getPOC() > iCurrPOC )
	391	{
	392	bLowDelay = false;
	393	}
	394	}
	395	for (iRefIdx = 0; iRefIdx < pcSlice->getNumRefIdx(REF_PIC_LIST_1) && bLowDelay; iRefIdx++)
	396	{
	397	if ( pcSlice->getRefPic(REF_PIC_LIST_1, iRefIdx)->getPOC() > iCurrPOC )
	398	{
	399	bLowDelay = false;
	400	}
	401	}
	402
	403	pcSlice->setCheckLDC(bLowDelay);
	404	}
	405
	406	uiColDir = 1-uiColDir;
	407
	408	//-------------------------------------------------------------
	409	pcSlice->setRefPOCnViewListsMvc();
	410
	411	pcSlice->setNoBackPredFlag( false );
	412	if ( pcSlice->getSliceType() == B_SLICE && !pcSlice->getRefPicListCombinationFlag())
	413	{
	414	if ( pcSlice->getNumRefIdx(RefPicList( 0 ) ) == pcSlice->getNumRefIdx(RefPicList( 1 ) ) )
	415	{
	416	pcSlice->setNoBackPredFlag( true );
	417	int i;
	418	for ( i=0; i < pcSlice->getNumRefIdx(RefPicList( 1 ) ); i++ )
	419	{
	420	if ( pcSlice->getRefPOC(RefPicList(1), i) != pcSlice->getRefPOC(RefPicList(0), i) )
	421	{
	422	pcSlice->setNoBackPredFlag( false );
	423	break;
	424	}
	425	}
	426	}
	427	}
	428
	429	if(pcSlice->getNoBackPredFlag())
	430	{
	431	pcSlice->setNumRefIdx(REF_PIC_LIST_C, 0);
	432	}
	433	pcSlice->generateCombinedList();
	434
	435	#if HHI_VSO
[5]	436	Bool bUseVSO = m_pcEncTop->getUseVSO();
[2]	437	m_pcRdCost->setUseVSO( bUseVSO );
	438
	439	if ( bUseVSO )
[5]	440	{
[2]	441	Int iVSOMode = m_pcEncTop->getVSOMode();
[5]	442	m_pcRdCost->setVSOMode( iVSOMode );
	443	#if HHI_VSO_DIST_INT
	444	m_pcRdCost->setAllowNegDist( m_pcEncTop->getAllowNegDist() );
[2]	445	#endif
	446
	447	if ( iVSOMode == 4 )
	448	{
[56]	449	m_pcEncTop->getEncTop()->setupRenModel( pcSlice->getPOC(), pcSlice->getViewId(), m_pcEncTop->isDepthCoder() ? 1 : 0 );
[2]	450	}
	451	else
[56]	452	{
	453	AOT(true);
	454	}
[2]	455	}
[5]	456	#endif
[56]	457	/////////////////////////////////////////////////////////////////////////////////////////////////// Compress a slice
	458	// Slice compression
	459	if (m_pcCfg->getUseASR())
	460	{
	461	m_pcSliceEncoder->setSearchRange(pcSlice);
	462	}
[2]	463
[56]	464	#if H0111_MVD_L1_ZERO
	465	Bool bGPBcheck=false;
	466	if ( pcSlice->getSliceType() == B_SLICE)
[2]	467	{
	468	if ( pcSlice->getNumRefIdx(RefPicList( 0 ) ) == pcSlice->getNumRefIdx(RefPicList( 1 ) ) )
	469	{
[56]	470	bGPBcheck=true;
[2]	471	int i;
	472	for ( i=0; i < pcSlice->getNumRefIdx(RefPicList( 1 ) ); i++ )
	473	{
[56]	474	if ( pcSlice->getRefPOC(RefPicList(1), i) != pcSlice->getRefPOC(RefPicList(0), i) )
[2]	475	{
[56]	476	bGPBcheck=false;
[2]	477	break;
	478	}
	479	}
	480	}
	481	}
[56]	482	if(bGPBcheck)
[2]	483	{
[56]	484	pcSlice->setMvdL1ZeroFlag(true);
[2]	485	}
[56]	486	else
	487	{
	488	pcSlice->setMvdL1ZeroFlag(false);
	489	}
	490	pcPic->getSlice(pcSlice->getSliceIdx())->setMvdL1ZeroFlag(pcSlice->getMvdL1ZeroFlag());
[2]	491	#endif
[5]	492
[56]	493	UInt uiNumSlices = 1;
	494
	495	UInt uiInternalAddress = pcPic->getNumPartInCU()-4;
	496	UInt uiExternalAddress = pcPic->getPicSym()->getNumberOfCUsInFrame()-1;
	497	UInt uiPosX = ( uiExternalAddress % pcPic->getFrameWidthInCU() ) * g_uiMaxCUWidth+ g_auiRasterToPelX[ g_auiZscanToRaster[uiInternalAddress] ];
	498	UInt uiPosY = ( uiExternalAddress / pcPic->getFrameWidthInCU() ) * g_uiMaxCUHeight+ g_auiRasterToPelY[ g_auiZscanToRaster[uiInternalAddress] ];
	499	UInt uiWidth = pcSlice->getSPS()->getPicWidthInLumaSamples();
	500	UInt uiHeight = pcSlice->getSPS()->getPicHeightInLumaSamples();
	501	while(uiPosX>=uiWidth\|\|uiPosY>=uiHeight)
[2]	502	{
[56]	503	uiInternalAddress--;
	504	uiPosX = ( uiExternalAddress % pcPic->getFrameWidthInCU() ) * g_uiMaxCUWidth+ g_auiRasterToPelX[ g_auiZscanToRaster[uiInternalAddress] ];
	505	uiPosY = ( uiExternalAddress / pcPic->getFrameWidthInCU() ) * g_uiMaxCUHeight+ g_auiRasterToPelY[ g_auiZscanToRaster[uiInternalAddress] ];
[2]	506	}
[56]	507	uiInternalAddress++;
	508	if(uiInternalAddress==pcPic->getNumPartInCU())
[2]	509	{
[56]	510	uiInternalAddress = 0;
	511	uiExternalAddress++;
[2]	512	}
[56]	513	UInt uiRealEndAddress = uiExternalAddress*pcPic->getNumPartInCU()+uiInternalAddress;
[2]	514
[56]	515	UInt uiCummulativeTileWidth;
	516	UInt uiCummulativeTileHeight;
	517	Int p, j;
	518	UInt uiEncCUAddr;
	519
	520	#if !REMOVE_TILE_DEPENDENCE
	521	if(pcSlice->getPPS()->getTileBehaviorControlPresentFlag() == 1)
	522	{
	523	pcPic->getPicSym()->setTileBoundaryIndependenceIdr( pcSlice->getPPS()->getTileBoundaryIndependenceIdr() );
	524	}
	525	else
	526	{
	527	pcPic->getPicSym()->setTileBoundaryIndependenceIdr( pcSlice->getPPS()->getSPS()->getTileBoundaryIndependenceIdr() );
	528
	529	}
[2]	530	#endif
	531
[56]	532	if( pcSlice->getPPS()->getColumnRowInfoPresent() == 1 ) //derive the tile parameters from PPS
	533	{
	534	//set NumColumnsMinus1 and NumRowsMinus1
	535	pcPic->getPicSym()->setNumColumnsMinus1( pcSlice->getPPS()->getNumColumnsMinus1() );
	536	pcPic->getPicSym()->setNumRowsMinus1( pcSlice->getPPS()->getNumRowsMinus1() );
	537
	538	//create the TComTileArray
	539	pcPic->getPicSym()->xCreateTComTileArray();
	540
	541	if( pcSlice->getPPS()->getUniformSpacingIdr() == 1 )
	542	{
	543	//set the width for each tile
	544	for(j=0; j < pcPic->getPicSym()->getNumRowsMinus1()+1; j++)
	545	{
	546	for(p=0; p < pcPic->getPicSym()->getNumColumnsMinus1()+1; p++)
	547	{
	548	pcPic->getPicSym()->getTComTile( j * (pcPic->getPicSym()->getNumColumnsMinus1()+1) + p )->
	549	setTileWidth( (p+1)*pcPic->getPicSym()->getFrameWidthInCU()/(pcPic->getPicSym()->getNumColumnsMinus1()+1)
	550	- (p*pcPic->getPicSym()->getFrameWidthInCU())/(pcPic->getPicSym()->getNumColumnsMinus1()+1) );
	551	}
	552	}
	553
	554	//set the height for each tile
	555	for(j=0; j < pcPic->getPicSym()->getNumColumnsMinus1()+1; j++)
	556	{
	557	for(p=0; p < pcPic->getPicSym()->getNumRowsMinus1()+1; p++)
	558	{
	559	pcPic->getPicSym()->getTComTile( p * (pcPic->getPicSym()->getNumColumnsMinus1()+1) + j )->
	560	setTileHeight( (p+1)*pcPic->getPicSym()->getFrameHeightInCU()/(pcPic->getPicSym()->getNumRowsMinus1()+1)
	561	- (p*pcPic->getPicSym()->getFrameHeightInCU())/(pcPic->getPicSym()->getNumRowsMinus1()+1) );
	562	}
	563	}
	564	}
	565	else
	566	{
	567	//set the width for each tile
	568	for(j=0; j < pcPic->getPicSym()->getNumRowsMinus1()+1; j++)
	569	{
	570	uiCummulativeTileWidth = 0;
	571	for(p=0; p < pcPic->getPicSym()->getNumColumnsMinus1(); p++)
	572	{
	573	pcPic->getPicSym()->getTComTile( j * (pcPic->getPicSym()->getNumColumnsMinus1()+1) + p )->setTileWidth( pcSlice->getPPS()->getColumnWidth(p) );
	574	uiCummulativeTileWidth += pcSlice->getPPS()->getColumnWidth(p);
	575	}
	576	pcPic->getPicSym()->getTComTile(j * (pcPic->getPicSym()->getNumColumnsMinus1()+1) + p)->setTileWidth( pcPic->getPicSym()->getFrameWidthInCU()-uiCummulativeTileWidth );
	577	}
	578
	579	//set the height for each tile
	580	for(j=0; j < pcPic->getPicSym()->getNumColumnsMinus1()+1; j++)
	581	{
	582	uiCummulativeTileHeight = 0;
	583	for(p=0; p < pcPic->getPicSym()->getNumRowsMinus1(); p++)
	584	{
	585	pcPic->getPicSym()->getTComTile( p * (pcPic->getPicSym()->getNumColumnsMinus1()+1) + j )->setTileHeight( pcSlice->getPPS()->getRowHeight(p) );
	586	uiCummulativeTileHeight += pcSlice->getPPS()->getRowHeight(p);
	587	}
	588	pcPic->getPicSym()->getTComTile(p * (pcPic->getPicSym()->getNumColumnsMinus1()+1) + j)->setTileHeight( pcPic->getPicSym()->getFrameHeightInCU()-uiCummulativeTileHeight );
	589	}
	590	}
	591	}
	592	else //derive the tile parameters from SPS
	593	{
	594	//set NumColumnsMins1 and NumRowsMinus1
	595	pcPic->getPicSym()->setNumColumnsMinus1( pcSlice->getSPS()->getNumColumnsMinus1() );
	596	pcPic->getPicSym()->setNumRowsMinus1( pcSlice->getSPS()->getNumRowsMinus1() );
	597
	598	//create the TComTileArray
	599	pcPic->getPicSym()->xCreateTComTileArray();
	600
	601	if( pcSlice->getSPS()->getUniformSpacingIdr() == 1 )
	602	{
	603	//set the width for each tile
	604	for(j=0; j < pcPic->getPicSym()->getNumRowsMinus1()+1; j++)
	605	{
	606	for(p=0; p < pcPic->getPicSym()->getNumColumnsMinus1()+1; p++)
	607	{
	608	pcPic->getPicSym()->getTComTile( j * (pcPic->getPicSym()->getNumColumnsMinus1()+1) + p )->
	609	setTileWidth( (p+1)*pcPic->getPicSym()->getFrameWidthInCU()/(pcPic->getPicSym()->getNumColumnsMinus1()+1)
	610	- (p*pcPic->getPicSym()->getFrameWidthInCU())/(pcPic->getPicSym()->getNumColumnsMinus1()+1) );
	611	}
	612	}
	613
	614	//set the height for each tile
	615	for(j=0; j < pcPic->getPicSym()->getNumColumnsMinus1()+1; j++)
	616	{
	617	for(p=0; p < pcPic->getPicSym()->getNumRowsMinus1()+1; p++)
	618	{
	619	pcPic->getPicSym()->getTComTile( p * (pcPic->getPicSym()->getNumColumnsMinus1()+1) + j )->
	620	setTileHeight( (p+1)*pcPic->getPicSym()->getFrameHeightInCU()/(pcPic->getPicSym()->getNumRowsMinus1()+1)
	621	- (p*pcPic->getPicSym()->getFrameHeightInCU())/(pcPic->getPicSym()->getNumRowsMinus1()+1) );
	622	}
	623	}
	624	}
	625
	626	else
	627	{
	628	//set the width for each tile
	629	for(j=0; j < pcPic->getPicSym()->getNumRowsMinus1()+1; j++)
	630	{
	631	uiCummulativeTileWidth = 0;
	632	for(p=0; p < pcPic->getPicSym()->getNumColumnsMinus1(); p++)
	633	{
	634	pcPic->getPicSym()->getTComTile( j * (pcPic->getPicSym()->getNumColumnsMinus1()+1) + p )->setTileWidth( pcSlice->getSPS()->getColumnWidth(p) );
	635	uiCummulativeTileWidth += pcSlice->getSPS()->getColumnWidth(p);
	636	}
	637	pcPic->getPicSym()->getTComTile(j * (pcPic->getPicSym()->getNumColumnsMinus1()+1) + p)->setTileWidth( pcPic->getPicSym()->getFrameWidthInCU()-uiCummulativeTileWidth );
	638	}
	639
	640	//set the height for each tile
	641	for(j=0; j < pcPic->getPicSym()->getNumColumnsMinus1()+1; j++)
	642	{
	643	uiCummulativeTileHeight = 0;
	644	for(p=0; p < pcPic->getPicSym()->getNumRowsMinus1(); p++)
	645	{
	646	pcPic->getPicSym()->getTComTile( p * (pcPic->getPicSym()->getNumColumnsMinus1()+1) + j )->setTileHeight( pcSlice->getSPS()->getRowHeight(p) );
	647	uiCummulativeTileHeight += pcSlice->getSPS()->getRowHeight(p);
	648	}
	649	pcPic->getPicSym()->getTComTile(p * (pcPic->getPicSym()->getNumColumnsMinus1()+1) + j)->setTileHeight( pcPic->getPicSym()->getFrameHeightInCU()-uiCummulativeTileHeight );
	650	}
	651	}
	652	}
	653
	654	//initialize each tile of the current picture
	655	pcPic->getPicSym()->xInitTiles();
	656
	657	// Allocate some coders, now we know how many tiles there are.
	658	Int iNumSubstreams = pcSlice->getPPS()->getNumSubstreams();
	659
	660	//generate the Coding Order Map and Inverse Coding Order Map
	661	for(p=0, uiEncCUAddr=0; p<pcPic->getPicSym()->getNumberOfCUsInFrame(); p++, uiEncCUAddr = pcPic->getPicSym()->xCalculateNxtCUAddr(uiEncCUAddr))
	662	{
	663	pcPic->getPicSym()->setCUOrderMap(p, uiEncCUAddr);
	664	pcPic->getPicSym()->setInverseCUOrderMap(uiEncCUAddr, p);
	665	}
	666	pcPic->getPicSym()->setCUOrderMap(pcPic->getPicSym()->getNumberOfCUsInFrame(), pcPic->getPicSym()->getNumberOfCUsInFrame());
	667	pcPic->getPicSym()->setInverseCUOrderMap(pcPic->getPicSym()->getNumberOfCUsInFrame(), pcPic->getPicSym()->getNumberOfCUsInFrame());
	668	if (pcSlice->getPPS()->getEntropyCodingMode())
	669	{
	670	// Allocate some coders, now we know how many tiles there are.
	671	m_pcEncTop->createWPPCoders(iNumSubstreams);
	672	pcSbacCoders = m_pcEncTop->getSbacCoders();
	673	pcSubstreamsOut = new TComOutputBitstream[iNumSubstreams];
	674	}
	675
[2]	676	UInt uiStartCUAddrSliceIdx = 0; // used to index "m_uiStoredStartCUAddrForEncodingSlice" containing locations of slice boundaries
	677	UInt uiStartCUAddrSlice = 0; // used to keep track of current slice's starting CU addr.
	678	pcSlice->setSliceCurStartCUAddr( uiStartCUAddrSlice ); // Setting "start CU addr" for current slice
[56]	679	memset(m_uiStoredStartCUAddrForEncodingSlice, 0, sizeof(UInt) * (pcPic->getPicSym()->getNumberOfCUsInFrame()*pcPic->getNumPartInCU()+1));
[2]	680
	681	UInt uiStartCUAddrEntropySliceIdx = 0; // used to index "m_uiStoredStartCUAddrForEntropyEncodingSlice" containing locations of slice boundaries
	682	UInt uiStartCUAddrEntropySlice = 0; // used to keep track of current Entropy slice's starting CU addr.
	683	pcSlice->setEntropySliceCurStartCUAddr( uiStartCUAddrEntropySlice ); // Setting "start CU addr" for current Entropy slice
[56]	684
	685	memset(m_uiStoredStartCUAddrForEncodingEntropySlice, 0, sizeof(UInt) * (pcPic->getPicSym()->getNumberOfCUsInFrame()*pcPic->getNumPartInCU()+1));
[2]	686	UInt uiNextCUAddr = 0;
	687	m_uiStoredStartCUAddrForEncodingSlice[uiStartCUAddrSliceIdx++] = uiNextCUAddr;
	688	m_uiStoredStartCUAddrForEncodingEntropySlice[uiStartCUAddrEntropySliceIdx++] = uiNextCUAddr;
	689
[5]	690	#if DEPTH_MAP_GENERATION
[2]	691	// init view component and predict virtual depth map
	692	m_pcDepthMapGenerator->initViewComponent( pcPic );
[91]	693	#if !QC_MULTI_DIS_CAN
[2]	694	m_pcDepthMapGenerator->predictDepthMap ( pcPic );
[56]	695	#endif
[91]	696	#endif
[5]	697	#if HHI_INTER_VIEW_MOTION_PRED
[91]	698	//#if !QC_MULTI_DIS_CAN
[2]	699	m_pcDepthMapGenerator->covertOrgDepthMap( pcPic );
[91]	700	//#endif
[5]	701	#endif
	702	#if HHI_INTER_VIEW_RESIDUAL_PRED
[2]	703	m_pcResidualGenerator->initViewComponent( pcPic );
[5]	704	#endif
[2]	705
[56]	706	while(uiNextCUAddr<uiRealEndAddress) // determine slice boundaries
[2]	707	{
	708	pcSlice->setNextSlice ( false );
	709	pcSlice->setNextEntropySlice( false );
	710	assert(pcPic->getNumAllocatedSlice() == uiStartCUAddrSliceIdx);
	711	m_pcSliceEncoder->precompressSlice( pcPic );
	712	m_pcSliceEncoder->compressSlice ( pcPic );
	713
	714	Bool bNoBinBitConstraintViolated = (!pcSlice->isNextSlice() && !pcSlice->isNextEntropySlice());
	715	if (pcSlice->isNextSlice() \|\| (bNoBinBitConstraintViolated && m_pcCfg->getSliceMode()==AD_HOC_SLICES_FIXED_NUMBER_OF_LCU_IN_SLICE))
	716	{
	717	uiStartCUAddrSlice = pcSlice->getSliceCurEndCUAddr();
	718	// Reconstruction slice
	719	m_uiStoredStartCUAddrForEncodingSlice[uiStartCUAddrSliceIdx++] = uiStartCUAddrSlice;
	720	// Entropy slice
	721	if (uiStartCUAddrEntropySliceIdx>0 && m_uiStoredStartCUAddrForEncodingEntropySlice[uiStartCUAddrEntropySliceIdx-1] != uiStartCUAddrSlice)
	722	{
	723	m_uiStoredStartCUAddrForEncodingEntropySlice[uiStartCUAddrEntropySliceIdx++] = uiStartCUAddrSlice;
	724	}
[56]	725
	726	if (uiStartCUAddrSlice < uiRealEndAddress)
[2]	727	{
[56]	728	pcPic->allocateNewSlice();
[2]	729	pcPic->setCurrSliceIdx ( uiStartCUAddrSliceIdx-1 );
	730	m_pcSliceEncoder->setSliceIdx ( uiStartCUAddrSliceIdx-1 );
	731	pcSlice = pcPic->getSlice ( uiStartCUAddrSliceIdx-1 );
	732	pcSlice->copySliceInfo ( pcPic->getSlice(0) );
	733	pcSlice->setSliceIdx ( uiStartCUAddrSliceIdx-1 );
	734	pcSlice->setSliceCurStartCUAddr ( uiStartCUAddrSlice );
	735	pcSlice->setEntropySliceCurStartCUAddr ( uiStartCUAddrSlice );
	736	pcSlice->setSliceBits(0);
[56]	737	uiNumSlices ++;
[2]	738	}
	739	}
	740	else if (pcSlice->isNextEntropySlice() \|\| (bNoBinBitConstraintViolated && m_pcCfg->getEntropySliceMode()==SHARP_FIXED_NUMBER_OF_LCU_IN_ENTROPY_SLICE))
	741	{
	742	uiStartCUAddrEntropySlice = pcSlice->getEntropySliceCurEndCUAddr();
	743	m_uiStoredStartCUAddrForEncodingEntropySlice[uiStartCUAddrEntropySliceIdx++] = uiStartCUAddrEntropySlice;
	744	pcSlice->setEntropySliceCurStartCUAddr( uiStartCUAddrEntropySlice );
	745	}
	746	else
	747	{
	748	uiStartCUAddrSlice = pcSlice->getSliceCurEndCUAddr();
	749	uiStartCUAddrEntropySlice = pcSlice->getEntropySliceCurEndCUAddr();
[56]	750	}
[2]	751
	752	uiNextCUAddr = (uiStartCUAddrSlice > uiStartCUAddrEntropySlice) ? uiStartCUAddrSlice : uiStartCUAddrEntropySlice;
	753	}
	754	m_uiStoredStartCUAddrForEncodingSlice[uiStartCUAddrSliceIdx++] = pcSlice->getSliceCurEndCUAddr();
	755	m_uiStoredStartCUAddrForEncodingEntropySlice[uiStartCUAddrEntropySliceIdx++] = pcSlice->getSliceCurEndCUAddr();
[56]	756
[2]	757	pcSlice = pcPic->getSlice(0);
	758
[5]	759	#if HHI_INTER_VIEW_RESIDUAL_PRED
[2]	760	// set residual picture
	761	m_pcResidualGenerator->setRecResidualPic( pcPic );
[5]	762	#endif
	763	#if DEPTH_MAP_GENERATION
[91]	764	#if !QC_MULTI_DIS_CAN
[2]	765	// update virtual depth map
	766	m_pcDepthMapGenerator->updateDepthMap( pcPic );
[5]	767	#endif
[91]	768	#endif
[2]	769
	770	//-- Loop filter
[56]	771	Bool bLFCrossTileBoundary = (pcSlice->getPPS()->getTileBehaviorControlPresentFlag() == 1)?
	772	(pcSlice->getPPS()->getLFCrossTileBoundaryFlag()):(pcSlice->getPPS()->getSPS()->getLFCrossTileBoundaryFlag());
	773	#if DBL_CONTROL
	774	m_pcLoopFilter->setCfg(pcSlice->getPPS()->getDeblockingFilterControlPresent(), pcSlice->getLoopFilterDisable(), pcSlice->getLoopFilterBetaOffset(), pcSlice->getLoopFilterTcOffset(), bLFCrossTileBoundary);
	775	#else
	776	m_pcLoopFilter->setCfg(pcSlice->getLoopFilterDisable(), pcSlice->getLoopFilterBetaOffset(), pcSlice->getLoopFilterTcOffset(), bLFCrossTileBoundary);
	777	#endif
[2]	778	m_pcLoopFilter->loopFilterPic( pcPic );
	779
	780	pcSlice = pcPic->getSlice(0);
[56]	781	if(pcSlice->getSPS()->getUseSAO() \|\| pcSlice->getSPS()->getUseALF())
	782	{
	783	Int sliceGranularity = pcSlice->getPPS()->getSliceGranularity();
	784	pcPic->createNonDBFilterInfo(m_uiStoredStartCUAddrForEncodingSlice, uiNumSlices, sliceGranularity, pcSlice->getSPS()->getLFCrossSliceBoundaryFlag(),pcPic->getPicSym()->getNumTiles() ,bLFCrossTileBoundary);
	785	}
[2]	786
[56]	787
	788	pcSlice = pcPic->getSlice(0);
	789
	790	if(pcSlice->getSPS()->getUseSAO())
[2]	791	{
[56]	792	m_pcSAO->createPicSaoInfo(pcPic, uiNumSlices);
	793	}
[2]	794
[56]	795	#if LCU_SYNTAX_ALF
	796	AlfParamSet* alfSliceParams = NULL;
	797	std::vector<AlfCUCtrlInfo>* alfCUCtrlParam = NULL;
	798	#else
	799	std::vector<AlfCUCtrlInfo> vAlfCUCtrlParam;
	800	#endif
	801	pcSlice = pcPic->getSlice(0);
[2]	802
[56]	803	if(pcSlice->getSPS()->getUseALF())
	804	{
	805	#if LCU_SYNTAX_ALF
	806	m_pcAdaptiveLoopFilter->createPicAlfInfo(pcPic, uiNumSlices, pcSlice->getSliceQp());
	807	m_pcAdaptiveLoopFilter->initALFEnc(m_pcCfg->getALFParamInSlice(), m_pcCfg->getALFPicBasedEncode(), uiNumSlices, alfSliceParams, alfCUCtrlParam);
	808	#else
	809	vAlfCUCtrlParam.resize(uiNumSlices);
	810	m_pcAdaptiveLoopFilter->createPicAlfInfo(pcPic, uiNumSlices);
	811	#endif
[2]	812	}
[56]	813
[2]	814	/////////////////////////////////////////////////////////////////////////////////////////////////// File writing
	815	// Set entropy coder
	816	m_pcEntropyCoder->setEntropyCoder ( m_pcCavlcCoder, pcSlice );
	817
[56]	818	/* write various header sets. */
	819	if ( m_bSeqFirst )
[2]	820	{
[77]	821	#if VIDYO_VPS_INTEGRATION
	822	{
	823	OutputNALUnit nalu(NAL_UNIT_VPS, true, m_pcEncTop->getLayerId());
	824	m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
	825	m_pcEntropyCoder->encodeVPS(m_pcEncTop->getEncTop()->getVPS());
	826	writeRBSPTrailingBits(nalu.m_Bitstream);
	827	accessUnit.push_back(new NALUnitEBSP(nalu));
	828	}
	829	#endif
[56]	830	#if NAL_REF_FLAG
[77]	831	#if VIDYO_VPS_INTEGRATION
	832	OutputNALUnit nalu(NAL_UNIT_SPS, true, m_pcEncTop->getLayerId());
	833	#else
[56]	834	OutputNALUnit nalu(NAL_UNIT_SPS, true, m_pcEncTop->getViewId(), m_pcEncTop->getIsDepth());
[77]	835	#endif
[56]	836	#else
	837	OutputNALUnit nalu(NAL_UNIT_SPS, NAL_REF_IDC_PRIORITY_HIGHEST, m_pcEncTop->getViewId(), m_pcEncTop->getIsDepth());
	838	#endif
	839	m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
	840	#if TILES_WPP_ENTRY_POINT_SIGNALLING
	841	pcSlice->getSPS()->setNumSubstreams( pcSlice->getPPS()->getNumSubstreams() );
	842	#endif
	843	#if HHI_MPI
	844	m_pcEntropyCoder->encodeSPS(pcSlice->getSPS(), m_pcEncTop->getIsDepth());
	845	#else
	846	m_pcEntropyCoder->encodeSPS(pcSlice->getSPS());
	847	#endif
	848	writeRBSPTrailingBits(nalu.m_Bitstream);
	849	accessUnit.push_back(new NALUnitEBSP(nalu));
[2]	850
[56]	851	#if NAL_REF_FLAG
[77]	852	#if VIDYO_VPS_INTEGRATION
	853	nalu = NALUnit(NAL_UNIT_PPS, true, m_pcEncTop->getLayerId());
	854	#else
[56]	855	nalu = NALUnit(NAL_UNIT_PPS, true, m_pcEncTop->getViewId(), m_pcEncTop->getIsDepth());
[77]	856	#endif
[56]	857	#else
	858	nalu = NALUnit(NAL_UNIT_PPS, NAL_REF_IDC_PRIORITY_HIGHEST, m_pcEncTop->getViewId(), m_pcEncTop->getIsDepth());
	859	#endif
	860	m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
	861	m_pcEntropyCoder->encodePPS(pcSlice->getPPS());
	862	writeRBSPTrailingBits(nalu.m_Bitstream);
	863	accessUnit.push_back(new NALUnitEBSP(nalu));
[5]	864
[56]	865	m_bSeqFirst = false;
[2]	866	}
[5]	867
[2]	868	/* use the main bitstream buffer for storing the marshalled picture */
[56]	869	m_pcEntropyCoder->setBitstream(NULL);
[2]	870
	871	uiStartCUAddrSliceIdx = 0;
[56]	872	uiStartCUAddrSlice = 0;
[2]	873
	874	uiStartCUAddrEntropySliceIdx = 0;
[56]	875	uiStartCUAddrEntropySlice = 0;
[2]	876	uiNextCUAddr = 0;
	877	pcSlice = pcPic->getSlice(uiStartCUAddrSliceIdx);
[56]	878
	879	Int processingState = (pcSlice->getSPS()->getUseALF() \|\| pcSlice->getSPS()->getUseSAO() \|\| pcSlice->getSPS()->getScalingListFlag() \|\| pcSlice->getSPS()->getUseDF())?(EXECUTE_INLOOPFILTER):(ENCODE_SLICE);
	880
	881	static Int iCurrAPSIdx = 0;
	882	Int iCodedAPSIdx = 0;
	883	TComSlice* pcSliceForAPS = NULL;
	884
	885	bool skippedSlice=false;
	886	while (uiNextCUAddr < uiRealEndAddress) // Iterate over all slices
[2]	887	{
[56]	888	switch(processingState)
	889	{
	890	case ENCODE_SLICE:
	891	{
[2]	892	pcSlice->setNextSlice ( false );
	893	pcSlice->setNextEntropySlice( false );
	894	if (uiNextCUAddr == m_uiStoredStartCUAddrForEncodingSlice[uiStartCUAddrSliceIdx])
	895	{
	896	pcSlice = pcPic->getSlice(uiStartCUAddrSliceIdx);
[56]	897	#if COLLOCATED_REF_IDX
	898	if(uiStartCUAddrSliceIdx > 0 && pcSlice->getSliceType()!= I_SLICE)
	899	{
	900	pcSlice->checkColRefIdx(uiStartCUAddrSliceIdx, pcPic);
	901	}
	902	#endif
[2]	903	pcPic->setCurrSliceIdx(uiStartCUAddrSliceIdx);
	904	m_pcSliceEncoder->setSliceIdx(uiStartCUAddrSliceIdx);
	905	assert(uiStartCUAddrSliceIdx == pcSlice->getSliceIdx());
	906	// Reconstruction slice
	907	pcSlice->setSliceCurStartCUAddr( uiNextCUAddr ); // to be used in encodeSlice() + context restriction
	908	pcSlice->setSliceCurEndCUAddr ( m_uiStoredStartCUAddrForEncodingSlice[uiStartCUAddrSliceIdx+1 ] );
	909	// Entropy slice
	910	pcSlice->setEntropySliceCurStartCUAddr( uiNextCUAddr ); // to be used in encodeSlice() + context restriction
	911	pcSlice->setEntropySliceCurEndCUAddr ( m_uiStoredStartCUAddrForEncodingEntropySlice[uiStartCUAddrEntropySliceIdx+1 ] );
	912
	913	pcSlice->setNextSlice ( true );
	914
	915	uiStartCUAddrSliceIdx++;
	916	uiStartCUAddrEntropySliceIdx++;
[56]	917	}
[2]	918	else if (uiNextCUAddr == m_uiStoredStartCUAddrForEncodingEntropySlice[uiStartCUAddrEntropySliceIdx])
	919	{
	920	// Entropy slice
	921	pcSlice->setEntropySliceCurStartCUAddr( uiNextCUAddr ); // to be used in encodeSlice() + context restriction
	922	pcSlice->setEntropySliceCurEndCUAddr ( m_uiStoredStartCUAddrForEncodingEntropySlice[uiStartCUAddrEntropySliceIdx+1 ] );
	923
	924	pcSlice->setNextEntropySlice( true );
	925
	926	uiStartCUAddrEntropySliceIdx++;
	927	}
	928
[56]	929	pcSlice->setRPS(pcPic->getSlice(0)->getRPS());
	930	pcSlice->setRPSidx(pcPic->getSlice(0)->getRPSidx());
	931	UInt uiDummyStartCUAddr;
	932	UInt uiDummyBoundingCUAddr;
	933	m_pcSliceEncoder->xDetermineStartAndBoundingCUAddr(uiDummyStartCUAddr,uiDummyBoundingCUAddr,pcPic,true);
	934
	935	uiInternalAddress = pcPic->getPicSym()->getPicSCUAddr(pcSlice->getEntropySliceCurEndCUAddr()-1) % pcPic->getNumPartInCU();
	936	uiExternalAddress = pcPic->getPicSym()->getPicSCUAddr(pcSlice->getEntropySliceCurEndCUAddr()-1) / pcPic->getNumPartInCU();
	937	uiPosX = ( uiExternalAddress % pcPic->getFrameWidthInCU() ) * g_uiMaxCUWidth+ g_auiRasterToPelX[ g_auiZscanToRaster[uiInternalAddress] ];
	938	uiPosY = ( uiExternalAddress / pcPic->getFrameWidthInCU() ) * g_uiMaxCUHeight+ g_auiRasterToPelY[ g_auiZscanToRaster[uiInternalAddress] ];
	939	uiWidth = pcSlice->getSPS()->getPicWidthInLumaSamples();
	940	uiHeight = pcSlice->getSPS()->getPicHeightInLumaSamples();
	941	while(uiPosX>=uiWidth\|\|uiPosY>=uiHeight)
[2]	942	{
[56]	943	uiInternalAddress--;
	944	uiPosX = ( uiExternalAddress % pcPic->getFrameWidthInCU() ) * g_uiMaxCUWidth+ g_auiRasterToPelX[ g_auiZscanToRaster[uiInternalAddress] ];
	945	uiPosY = ( uiExternalAddress / pcPic->getFrameWidthInCU() ) * g_uiMaxCUHeight+ g_auiRasterToPelY[ g_auiZscanToRaster[uiInternalAddress] ];
[2]	946	}
[56]	947	uiInternalAddress++;
	948	if(uiInternalAddress==pcPic->getNumPartInCU())
	949	{
	950	uiInternalAddress = 0;
	951	uiExternalAddress = pcPic->getPicSym()->getCUOrderMap(pcPic->getPicSym()->getInverseCUOrderMap(uiExternalAddress)+1);
	952	}
	953	UInt uiEndAddress = pcPic->getPicSym()->getPicSCUEncOrder(uiExternalAddress*pcPic->getNumPartInCU()+uiInternalAddress);
	954	if(uiEndAddress<=pcSlice->getEntropySliceCurStartCUAddr()) {
	955	UInt uiBoundingAddrSlice, uiBoundingAddrEntropySlice;
	956	uiBoundingAddrSlice = m_uiStoredStartCUAddrForEncodingSlice[uiStartCUAddrSliceIdx];
	957	uiBoundingAddrEntropySlice = m_uiStoredStartCUAddrForEncodingEntropySlice[uiStartCUAddrEntropySliceIdx];
	958	uiNextCUAddr = min(uiBoundingAddrSlice, uiBoundingAddrEntropySlice);
	959	if(pcSlice->isNextSlice())
	960	{
	961	skippedSlice=true;
	962	}
	963	continue;
	964	}
	965	if(skippedSlice)
	966	{
	967	pcSlice->setNextSlice ( true );
	968	pcSlice->setNextEntropySlice( false );
	969	}
	970	skippedSlice=false;
	971	if (pcSlice->getPPS()->getEntropyCodingMode())
	972	{
	973	pcSlice->allocSubstreamSizes( iNumSubstreams );
	974	for ( UInt ui = 0 ; ui < iNumSubstreams; ui++ )
	975	pcSubstreamsOut[ui].clear();
	976	}
[2]	977
[56]	978	m_pcEntropyCoder->setEntropyCoder ( m_pcCavlcCoder, pcSlice );
	979	m_pcEntropyCoder->resetEntropy ();
	980	/* start slice NALunit */
	981	#if H0388
	982	#if NAL_REF_FLAG
[77]	983	OutputNALUnit nalu( pcSlice->getNalUnitType(), pcSlice->isReferenced(),
	984	#if !VIDYO_VPS_INTEGRATION
	985	m_pcEncTop->getViewId(), m_pcEncTop->getIsDepth(), pcSlice->getTLayer() );
[56]	986	#else
[77]	987	m_pcEncTop->getLayerId(), pcSlice->getTLayer() );
[56]	988	#endif
	989	#else
[77]	990	OutputNALUnit nalu( pcSlice->getNalUnitType(), pcSlice->isReferenced() ? NAL_REF_IDC_PRIORITY_HIGHEST: NAL_REF_IDC_PRIORITY_LOWEST,
	991	#if !VIDYO_VPS_INTEGRATION
	992	m_pcEncTop->getViewId(), m_pcEncTop->getIsDepth(), pcSlice->getTLayer() );
	993	#else
	994	m_pcEncTop->getLayerId(), pcSlice->getTLayer() );
[56]	995	#endif
[77]	996	#endif
	997	#else
	998	OutputNALUnit nalu( pcSlice->getNalUnitType(), pcSlice->isReferenced() ? NAL_REF_IDC_PRIORITY_HIGHEST: NAL_REF_IDC_PRIORITY_LOWEST,
	999	#if !VIDYO_VPS_INTEGRATION
	1000	m_pcEncTop->getViewId(), m_pcEncTop->getIsDepth(), pcSlice->getTLayer(), true );
	1001	#else
	1002	m_pcEncTop->getLayerId(), pcSlice->getTLayer(), true );
	1003	#endif
	1004
	1005	#endif
	1006
[56]	1007	Bool bEntropySlice = (!pcSlice->isNextSlice());
	1008	if (!bEntropySlice)
	1009	{
	1010	uiOneBitstreamPerSliceLength = 0; // start of a new slice
	1011	}
[5]	1012
[56]	1013	// used while writing slice header
	1014	Int iTransmitLWHeader = (m_pcCfg->getTileMarkerFlag()==0) ? 0 : 1;
	1015	pcSlice->setTileMarkerFlag ( iTransmitLWHeader );
	1016	m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
	1017	#if !CABAC_INIT_FLAG
	1018	pcSlice->setCABACinitIDC(pcSlice->getSliceType());
	1019	#endif
[5]	1020
[56]	1021	m_pcEntropyCoder->encodeSliceHeader(pcSlice);
	1022
	1023	if(pcSlice->isNextSlice())
[2]	1024	{
[56]	1025	if (pcSlice->getSPS()->getUseALF())
	1026	{
	1027	#if LCU_SYNTAX_ALF
	1028	if(pcSlice->getAlfEnabledFlag())
[2]	1029	#else
[56]	1030	if(pcSlice->getAPS()->getAlfEnabled())
[2]	1031	#endif
[56]	1032	{
	1033
	1034	#if LCU_SYNTAX_ALF
	1035	if( pcSlice->getSPS()->getUseALFCoefInSlice())
	1036	{
	1037	Int iNumSUinLCU = 1<< (g_uiMaxCUDepth << 1);
	1038	Int firstLCUAddr = pcSlice->getSliceCurStartCUAddr() / iNumSUinLCU;
	1039	Bool isAcrossSlice = pcSlice->getSPS()->getLFCrossSliceBoundaryFlag();
	1040	m_pcEntropyCoder->encodeAlfParam( &(alfSliceParams[pcSlice->getSliceIdx()]), false, firstLCUAddr, isAcrossSlice);
	1041	}
	1042
	1043	if( !pcSlice->getSPS()->getUseALFCoefInSlice())
	1044	{
	1045	AlfCUCtrlInfo& cAlfCUCtrlParam = (*alfCUCtrlParam)[pcSlice->getSliceIdx()];
	1046	#else
	1047	AlfCUCtrlInfo& cAlfCUCtrlParam = vAlfCUCtrlParam[pcSlice->getSliceIdx()];
[2]	1048	#endif
[56]	1049	if(cAlfCUCtrlParam.cu_control_flag)
	1050	{
	1051	m_pcEntropyCoder->setAlfCtrl( true );
	1052	m_pcEntropyCoder->setMaxAlfCtrlDepth(cAlfCUCtrlParam.alf_max_depth);
	1053	m_pcCavlcCoder->setAlfCtrl(true);
	1054	m_pcCavlcCoder->setMaxAlfCtrlDepth(cAlfCUCtrlParam.alf_max_depth);
	1055	}
	1056	else
	1057	{
	1058	m_pcEntropyCoder->setAlfCtrl(false);
	1059	}
	1060	m_pcEntropyCoder->encodeAlfCtrlParam(cAlfCUCtrlParam, m_pcAdaptiveLoopFilter->getNumCUsInPic());
	1061
	1062	#if LCU_SYNTAX_ALF
	1063	}
	1064	#endif
	1065	}
	1066	}
	1067	}
	1068	m_pcEntropyCoder->encodeTileMarkerFlag(pcSlice);
[5]	1069
[56]	1070	// is it needed?
	1071	{
	1072	if (!bEntropySlice)
	1073	{
	1074	pcBitstreamRedirect->writeAlignOne();
	1075	}
	1076	else
	1077	{
	1078	// We've not completed our slice header info yet, do the alignment later.
	1079	}
	1080	m_pcSbacCoder->init( (TEncBinIf*)m_pcBinCABAC );
	1081	m_pcEntropyCoder->setEntropyCoder ( m_pcSbacCoder, pcSlice );
	1082	m_pcEntropyCoder->resetEntropy ();
	1083	for ( UInt ui = 0 ; ui < pcSlice->getPPS()->getNumSubstreams() ; ui++ )
	1084	{
	1085	m_pcEntropyCoder->setEntropyCoder ( &pcSbacCoders[ui], pcSlice );
	1086	m_pcEntropyCoder->resetEntropy ();
	1087	}
	1088	}
	1089
	1090	if(pcSlice->isNextSlice())
	1091	{
	1092	// set entropy coder for writing
	1093	m_pcSbacCoder->init( (TEncBinIf*)m_pcBinCABAC );
	1094	{
	1095	for ( UInt ui = 0 ; ui < pcSlice->getPPS()->getNumSubstreams() ; ui++ )
[2]	1096	{
[56]	1097	m_pcEntropyCoder->setEntropyCoder ( &pcSbacCoders[ui], pcSlice );
	1098	m_pcEntropyCoder->resetEntropy ();
[2]	1099	}
[56]	1100	pcSbacCoders[0].load(m_pcSbacCoder);
	1101	m_pcEntropyCoder->setEntropyCoder ( &pcSbacCoders[0], pcSlice ); //ALF is written in substream #0 with CABAC coder #0 (see ALF param encoding below)
	1102	}
	1103	m_pcEntropyCoder->resetEntropy ();
	1104	// File writing
	1105	if (!bEntropySlice)
	1106	{
	1107	m_pcEntropyCoder->setBitstream(pcBitstreamRedirect);
	1108	}
	1109	else
	1110	{
	1111	m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
	1112	}
	1113	// for now, override the TILES_DECODER setting in order to write substreams.
	1114	m_pcEntropyCoder->setBitstream ( &pcSubstreamsOut[0] );
[5]	1115
[56]	1116	}
	1117	pcSlice->setFinalized(true);
	1118
	1119	m_pcSbacCoder->load( &pcSbacCoders[0] );
	1120
	1121	pcSlice->setTileOffstForMultES( uiOneBitstreamPerSliceLength );
	1122	if (!bEntropySlice)
	1123	{
	1124	pcSlice->setTileLocationCount ( 0 );
	1125	m_pcSliceEncoder->encodeSlice(pcPic, pcBitstreamRedirect, pcSubstreamsOut); // redirect is only used for CAVLC tile position info.
	1126	}
	1127	else
	1128	{
	1129	m_pcSliceEncoder->encodeSlice(pcPic, &nalu.m_Bitstream, pcSubstreamsOut); // nalu.m_Bitstream is only used for CAVLC tile position info.
	1130	}
	1131
	1132	{
	1133	// Construct the final bitstream by flushing and concatenating substreams.
	1134	// The final bitstream is either nalu.m_Bitstream or pcBitstreamRedirect;
	1135	UInt* puiSubstreamSizes = pcSlice->getSubstreamSizes();
	1136	UInt uiTotalCodedSize = 0; // for padding calcs.
	1137	UInt uiNumSubstreamsPerTile = iNumSubstreams;
	1138	#if !REMOVE_TILE_DEPENDENCE
	1139	#if WPP_SIMPLIFICATION
	1140	if (pcPic->getPicSym()->getTileBoundaryIndependenceIdr() && iNumSubstreams > 1)
	1141	#else
	1142	if (pcPic->getPicSym()->getTileBoundaryIndependenceIdr() && pcSlice->getPPS()->getEntropyCodingSynchro())
	1143	#endif
	1144	uiNumSubstreamsPerTile /= pcPic->getPicSym()->getNumTiles();
	1145	#else
	1146	#if WPP_SIMPLIFICATION
	1147	if (iNumSubstreams > 1)
	1148	#else
	1149	if (pcSlice->getPPS()->getEntropyCodingSynchro())
	1150	#endif
	1151	{
	1152	uiNumSubstreamsPerTile /= pcPic->getPicSym()->getNumTiles();
	1153	}
	1154	#endif
	1155	for ( UInt ui = 0 ; ui < iNumSubstreams; ui++ )
	1156	{
	1157	// Flush all substreams -- this includes empty ones.
	1158	// Terminating bit and flush.
	1159	m_pcEntropyCoder->setEntropyCoder ( &pcSbacCoders[ui], pcSlice );
	1160	m_pcEntropyCoder->setBitstream ( &pcSubstreamsOut[ui] );
	1161	m_pcEntropyCoder->encodeTerminatingBit( 1 );
	1162	m_pcEntropyCoder->encodeSliceFinish();
	1163	pcSubstreamsOut[ui].write( 1, 1 ); // stop bit.
	1164	#if TILES_WPP_ENTRY_POINT_SIGNALLING
	1165	pcSubstreamsOut[ui].writeAlignZero();
	1166	#endif
	1167	// Byte alignment is necessary between tiles when tiles are independent.
	1168	uiTotalCodedSize += pcSubstreamsOut[ui].getNumberOfWrittenBits();
	1169
[2]	1170	{
[56]	1171	Bool bNextSubstreamInNewTile = ((ui+1) < iNumSubstreams)
	1172	&& ((ui+1)%uiNumSubstreamsPerTile == 0);
	1173	if (bNextSubstreamInNewTile)
[2]	1174	{
[56]	1175	// byte align.
	1176	while (uiTotalCodedSize&0x7)
	1177	{
	1178	pcSubstreamsOut[ui].write(0, 1);
	1179	uiTotalCodedSize++;
	1180	}
[2]	1181	}
[56]	1182	Bool bRecordOffsetNext = m_pcCfg->getTileLocationInSliceHeaderFlag()
	1183	&& bNextSubstreamInNewTile;
	1184	if (bRecordOffsetNext)
	1185	pcSlice->setTileLocation(ui/uiNumSubstreamsPerTile, pcSlice->getTileOffstForMultES()+(uiTotalCodedSize>>3));
[2]	1186	}
[56]	1187	if (ui+1 < pcSlice->getPPS()->getNumSubstreams())
	1188	puiSubstreamSizes[ui] = pcSubstreamsOut[ui].getNumberOfWrittenBits();
	1189	}
	1190	// Complete the slice header info.
	1191	m_pcEntropyCoder->setEntropyCoder ( m_pcCavlcCoder, pcSlice );
	1192	m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
	1193	#if TILES_WPP_ENTRY_POINT_SIGNALLING
	1194	if (m_pcCfg->getTileLocationInSliceHeaderFlag()==0)
	1195	{
	1196	pcSlice->setTileLocationCount( 0 );
	1197	}
	1198	m_pcEntropyCoder->encodeTilesWPPEntryPoint( pcSlice );
	1199	#else
	1200	m_pcEntropyCoder->encodeSliceHeaderSubstreamTable(pcSlice);
[2]	1201	#endif
[56]	1202	// Substreams...
	1203	TComOutputBitstream *pcOut = pcBitstreamRedirect;
	1204	// xWriteTileLocation will perform byte-alignment...
	1205	{
	1206	if (bEntropySlice)
	1207	{
	1208	// In these cases, padding is necessary here.
	1209	pcOut = &nalu.m_Bitstream;
	1210	pcOut->writeAlignOne();
	1211	}
	1212	}
	1213	UInt uiAccumulatedLength = 0;
	1214	for ( UInt ui = 0 ; ui < pcSlice->getPPS()->getNumSubstreams(); ui++ )
	1215	{
	1216	pcOut->addSubstream(&pcSubstreamsOut[ui]);
[5]	1217
[56]	1218	// Update tile marker location information
	1219	for (Int uiMrkIdx = 0; uiMrkIdx < pcSubstreamsOut[ui].getTileMarkerLocationCount(); uiMrkIdx++)
	1220	{
	1221	UInt uiBottom = pcOut->getTileMarkerLocationCount();
	1222	pcOut->setTileMarkerLocation ( uiBottom, uiAccumulatedLength + pcSubstreamsOut[ui].getTileMarkerLocation( uiMrkIdx ) );
	1223	pcOut->setTileMarkerLocationCount ( uiBottom + 1 );
	1224	}
	1225	uiAccumulatedLength = (pcOut->getNumberOfWrittenBits() >> 3);
	1226	}
	1227	}
	1228
	1229	UInt uiBoundingAddrSlice, uiBoundingAddrEntropySlice;
	1230	uiBoundingAddrSlice = m_uiStoredStartCUAddrForEncodingSlice[uiStartCUAddrSliceIdx];
	1231	uiBoundingAddrEntropySlice = m_uiStoredStartCUAddrForEncodingEntropySlice[uiStartCUAddrEntropySliceIdx];
	1232	uiNextCUAddr = min(uiBoundingAddrSlice, uiBoundingAddrEntropySlice);
	1233	#if !REMOVE_TILE_DEPENDENCE
	1234	Bool bNextCUInNewSlice = (uiNextCUAddr >= uiRealEndAddress) \|\| (uiNextCUAddr == m_uiStoredStartCUAddrForEncodingSlice[uiStartCUAddrSliceIdx]);
[2]	1235	#endif
[56]	1236	// If current NALU is the first NALU of slice (containing slice header) and more NALUs exist (due to multiple entropy slices) then buffer it.
	1237	// If current NALU is the last NALU of slice and a NALU was buffered, then (a) Write current NALU (b) Update an write buffered NALU at approproate location in NALU list.
	1238	Bool bNALUAlignedWrittenToList = false; // used to ensure current NALU is not written more than once to the NALU list.
	1239	#if !REMOVE_TILE_DEPENDENCE
	1240	if (pcSlice->getSPS()->getTileBoundaryIndependenceIdr() && !pcSlice->getSPS()->getTileBoundaryIndependenceIdr())
	1241	{
	1242	if (bNextCUInNewSlice)
	1243	{
	1244	if (!bEntropySlice) // there were no entropy slices
[2]	1245	{
[56]	1246	xWriteTileLocationToSliceHeader(nalu, pcBitstreamRedirect, pcSlice);
[2]	1247	}
[56]	1248	// (a) writing current NALU
	1249	writeRBSPTrailingBits(nalu.m_Bitstream);
	1250	accessUnit.push_back(new NALUnitEBSP(nalu));
	1251	bNALUAlignedWrittenToList = true;
	1252
	1253	// (b) update and write buffered NALU
	1254	if (bEntropySlice) // if entropy slices existed in the slice then perform concatenation for the buffered nalu-bitstream and buffered payload bitstream
[2]	1255	{
[56]	1256	// Perform bitstream concatenation of slice header and partial slice payload
	1257	xWriteTileLocationToSliceHeader((*naluBuffered), pcBitstreamRedirect, pcSlice);
	1258	if (bIteratorAtListStart)
	1259	{
	1260	itLocationToPushSliceHeaderNALU = accessUnit.begin();
	1261	}
	1262	else
	1263	{
	1264	itLocationToPushSliceHeaderNALU++;
	1265	}
	1266	accessUnit.insert(itLocationToPushSliceHeaderNALU, (new NALUnitEBSP((*naluBuffered))) );
	1267
	1268	// free buffered nalu
	1269	delete naluBuffered;
	1270	naluBuffered = NULL;
[2]	1271	}
[56]	1272	}
	1273	else // another entropy slice exists
	1274	{
	1275	// Is this start-of-slice NALU? i.e. the one containing slice header. If Yes, then buffer it.
	1276	if (!bEntropySlice)
[2]	1277	{
[56]	1278	// store a pointer to where NALU for slice header is to be written in NALU list
	1279	itLocationToPushSliceHeaderNALU = accessUnit.end();
	1280	if (accessUnit.begin() == accessUnit.end())
[2]	1281	{
[56]	1282	bIteratorAtListStart = true;
[2]	1283	}
[56]	1284	else
	1285	{
	1286	bIteratorAtListStart = false;
	1287	itLocationToPushSliceHeaderNALU--;
	1288	}
	1289
	1290	// buffer nalu for later writing
	1291	#if H0388
	1292	naluBuffered = new OutputNALUnit( pcSlice->getNalUnitType(), pcSlice->isReferenced() ? NAL_REF_IDC_PRIORITY_HIGHEST: NAL_REF_IDC_PRIORITY_LOWEST, m_pcEncTop->getViewId(), m_pcEncTop->getIsDepth(), pcSlice->getTLayer() );
	1293	#else
	1294	naluBuffered = new OutputNALUnit(pcSlice->getNalUnitType(), pcSlice->isReferenced() ? NAL_REF_IDC_PRIORITY_HIGHEST: NAL_REF_IDC_PRIORITY_LOWEST, m_pcEncTop->getViewId(), m_pcEncTop->getIsDepth(), pcSlice->getTLayer(), true);
	1295	#endif
	1296	copyNaluData( (*naluBuffered), nalu );
	1297
	1298	// perform byte-alignment to get appropriate bitstream length (used for explicit tile location signaling in slice header)
	1299	writeRBSPTrailingBits((*pcBitstreamRedirect));
	1300	bNALUAlignedWrittenToList = true; // This is not really a write to bitsream but buffered for later. The flag is set to prevent writing of current NALU to list.
	1301	uiOneBitstreamPerSliceLength += pcBitstreamRedirect->getNumberOfWrittenBits(); // length of bitstream after byte-alignment
[2]	1302	}
[56]	1303	else // write out entropy slice
[2]	1304	{
[56]	1305	writeRBSPTrailingBits(nalu.m_Bitstream);
	1306	accessUnit.push_back(new NALUnitEBSP(nalu));
	1307	bNALUAlignedWrittenToList = true;
	1308	uiOneBitstreamPerSliceLength += nalu.m_Bitstream.getNumberOfWrittenBits(); // length of bitstream after byte-alignment
[2]	1309	}
[56]	1310	}
	1311	}
	1312	else
	1313	{
	1314	#endif
	1315	xWriteTileLocationToSliceHeader(nalu, pcBitstreamRedirect, pcSlice);
	1316	writeRBSPTrailingBits(nalu.m_Bitstream);
	1317	accessUnit.push_back(new NALUnitEBSP(nalu));
	1318	bNALUAlignedWrittenToList = true;
	1319	uiOneBitstreamPerSliceLength += nalu.m_Bitstream.getNumberOfWrittenBits(); // length of bitstream after byte-alignment
	1320	#if !REMOVE_TILE_DEPENDENCE
	1321	}
	1322	#endif
	1323
	1324	if (!bNALUAlignedWrittenToList)
	1325	{
	1326	{
	1327	nalu.m_Bitstream.writeAlignZero();
	1328	}
	1329	accessUnit.push_back(new NALUnitEBSP(nalu));
	1330	uiOneBitstreamPerSliceLength += nalu.m_Bitstream.getNumberOfWrittenBits() + 24; // length of bitstream after byte-alignment + 3 byte startcode 0x000001
	1331	}
	1332
	1333
	1334	processingState = ENCODE_SLICE;
	1335	}
	1336	break;
	1337	case EXECUTE_INLOOPFILTER:
	1338	{
	1339	TComAPS cAPS;
	1340	allocAPS(&cAPS, pcSlice->getSPS());
	1341	#if SAO_UNIT_INTERLEAVING
	1342	cAPS.setSaoInterleavingFlag(m_pcCfg->getSaoInterleavingFlag());
	1343	#endif
	1344	// set entropy coder for RD
	1345	m_pcEntropyCoder->setEntropyCoder ( m_pcCavlcCoder, pcSlice );
	1346
	1347	if ( pcSlice->getSPS()->getUseSAO() )
[2]	1348	{
[56]	1349	m_pcEntropyCoder->resetEntropy();
	1350	m_pcEntropyCoder->setBitstream( m_pcBitCounter );
	1351	m_pcSAO->startSaoEnc(pcPic, m_pcEntropyCoder, m_pcEncTop->getRDSbacCoder(), NULL);
	1352	SAOParam& cSaoParam = *(cAPS.getSaoParam());
	1353
	1354	#if SAO_CHROMA_LAMBDA
	1355	m_pcSAO->SAOProcess(&cSaoParam, pcPic->getSlice(0)->getLambdaLuma(), pcPic->getSlice(0)->getLambdaChroma());
	1356	#else
	1357	#if ALF_CHROMA_LAMBDA
	1358	m_pcSAO->SAOProcess(&cSaoParam, pcPic->getSlice(0)->getLambdaLuma());
	1359	#else
	1360	m_pcSAO->SAOProcess(&cSaoParam, pcPic->getSlice(0)->getLambda());
	1361	#endif
	1362	#endif
	1363	m_pcSAO->endSaoEnc();
	1364
	1365	m_pcAdaptiveLoopFilter->PCMLFDisableProcess(pcPic);
[2]	1366	}
[56]	1367
	1368	// adaptive loop filter
	1369	#if !LCU_SYNTAX_ALF
	1370	UInt64 uiDist, uiBits;
[2]	1371	#endif
[56]	1372	if ( pcSlice->getSPS()->getUseALF())
	1373	{
	1374	m_pcEntropyCoder->resetEntropy ();
	1375	m_pcEntropyCoder->setBitstream ( m_pcBitCounter );
	1376	m_pcAdaptiveLoopFilter->startALFEnc(pcPic, m_pcEntropyCoder );
	1377	#if LCU_SYNTAX_ALF
	1378	AlfParamSet* pAlfEncParam = (pcSlice->getSPS()->getUseALFCoefInSlice())?( alfSliceParams ):( cAPS.getAlfParam());
	1379	#if ALF_CHROMA_LAMBDA
	1380	#if HHI_INTERVIEW_SKIP
	1381	m_pcAdaptiveLoopFilter->ALFProcess(pAlfEncParam, alfCUCtrlParam, pcPic->getSlice(0)->getLambdaLuma(), pcPic->getSlice(0)->getLambdaChroma(), m_pcEncTop->getInterViewSkip() );
	1382	#else
	1383	m_pcAdaptiveLoopFilter->ALFProcess(pAlfEncParam, alfCUCtrlParam, pcPic->getSlice(0)->getLambdaLuma(), pcPic->getSlice(0)->getLambdaChroma() );
	1384	#endif
	1385	#else
	1386	#if SAO_CHROMA_LAMBDA
	1387	#if HHI_INTERVIEW_SKIP
	1388	m_pcAdaptiveLoopFilter->ALFProcess(pAlfEncParam, alfCUCtrlParam, pcPic->getSlice(0)->getLambdaLuma(), m_pcEncTop->getInterViewSkip());
	1389	#else
	1390	m_pcAdaptiveLoopFilter->ALFProcess(pAlfEncParam, alfCUCtrlParam, pcPic->getSlice(0)->getLambdaLuma());
	1391	#endif
	1392	#else
	1393	#if HHI_INTERVIEW_SKIP
	1394	m_pcAdaptiveLoopFilter->ALFProcess(pAlfEncParam, alfCUCtrlParam, pcPic->getSlice(0)->getLambda(), m_pcEncTop->getInterViewSkip() );
	1395	#else
	1396	m_pcAdaptiveLoopFilter->ALFProcess(pAlfEncParam, alfCUCtrlParam, pcPic->getSlice(0)->getLambda());
	1397	#endif
	1398	#endif
	1399	#endif
[5]	1400
[56]	1401	#else
	1402	ALFParam& cAlfParam = *( cAPS.getAlfParam());
	1403
	1404	#if ALF_CHROMA_LAMBDA
	1405	#if HHI_INTERVIEW_SKIP
	1406	m_pcAdaptiveLoopFilter->ALFProcess( &cAlfParam, &vAlfCUCtrlParam, pcPic->getSlice(0)->getLambdaLuma(), pcPic->getSlice(0)->getLambdaChroma(), uiDist, uiBits, m_pcEncTop->getInterViewSkip());
	1407	#else
	1408	m_pcAdaptiveLoopFilter->ALFProcess( &cAlfParam, &vAlfCUCtrlParam, pcPic->getSlice(0)->getLambdaLuma(), pcPic->getSlice(0)->getLambdaChroma(), uiDist, uiBits);
	1409	#endif
	1410	#else
	1411	#if SAO_CHROMA_LAMBDA
	1412	#if HHI_INTERVIEW_SKIP
	1413	m_pcAdaptiveLoopFilter->ALFProcess( &cAlfParam, &vAlfCUCtrlParam, pcPic->getSlice(0)->getLambdaLuma(), uiDist, uiBits, m_pcEncTop->getInterViewSkip());
	1414	#else
	1415	m_pcAdaptiveLoopFilter->ALFProcess( &cAlfParam, &vAlfCUCtrlParam, pcPic->getSlice(0)->getLambdaLuma(), uiDist, uiBits);
	1416	#endif
	1417	#else
	1418	#if HHI_INTERVIEW_SKIP
	1419	m_pcAdaptiveLoopFilter->ALFProcess( &cAlfParam, &vAlfCUCtrlParam, pcPic->getSlice(0)->getLambdaLuma(), uiDist, uiBits, m_pcEncTop->getInterViewSkip());
	1420	#else
	1421	m_pcAdaptiveLoopFilter->ALFProcess( &cAlfParam, &vAlfCUCtrlParam, pcPic->getSlice(0)->getLambda(), uiDist, uiBits);
	1422	#endif
	1423	#endif
	1424	#endif
	1425	#endif
	1426	m_pcAdaptiveLoopFilter->endALFEnc();
	1427
	1428	m_pcAdaptiveLoopFilter->PCMLFDisableProcess(pcPic);
	1429	}
	1430	iCodedAPSIdx = iCurrAPSIdx;
	1431	pcSliceForAPS = pcSlice;
	1432
	1433	assignNewAPS(cAPS, iCodedAPSIdx, vAPS, pcSliceForAPS);
	1434	iCurrAPSIdx = (iCurrAPSIdx +1)%MAX_NUM_SUPPORTED_APS;
	1435	processingState = ENCODE_APS;
	1436
	1437	//set APS link to the slices
	1438	for(Int s=0; s< uiNumSlices; s++)
[2]	1439	{
[56]	1440	if (pcSlice->getSPS()->getUseALF())
	1441	{
	1442	#if LCU_SYNTAX_ALF
	1443	pcPic->getSlice(s)->setAlfEnabledFlag( (pcSlice->getSPS()->getUseALFCoefInSlice())?(alfSliceParams[s].isEnabled[ALF_Y]):(cAPS.getAlfEnabled()) );
	1444	#else
	1445	pcPic->getSlice(s)->setAlfEnabledFlag((cAPS.getAlfParam()->alf_flag==1)?true:false);
	1446	#endif
	1447	}
	1448	if (pcSlice->getSPS()->getUseSAO())
	1449	{
	1450	pcPic->getSlice(s)->setSaoEnabledFlag((cAPS.getSaoParam()->bSaoFlag[0]==1)?true:false);
	1451	}
	1452	pcPic->getSlice(s)->setAPS(&(vAPS[iCodedAPSIdx]));
	1453	pcPic->getSlice(s)->setAPSId(iCodedAPSIdx);
[2]	1454	}
[56]	1455	}
	1456	break;
	1457	case ENCODE_APS:
	1458	{
	1459	#if NAL_REF_FLAG
[77]	1460	#if VIDYO_VPS_INTEGRATION
	1461	OutputNALUnit nalu(NAL_UNIT_APS, true, m_pcEncTop->getLayerId());
	1462	#else
[56]	1463	OutputNALUnit nalu(NAL_UNIT_APS, true, m_pcEncTop->getViewId(), m_pcEncTop->getIsDepth());
[77]	1464	#endif
[56]	1465	#else
	1466	OutputNALUnit nalu(NAL_UNIT_APS, NAL_REF_IDC_PRIORITY_HIGHEST, m_pcEncTop->getViewId(), m_pcEncTop->getIsDepth());
[2]	1467	#endif
[56]	1468	encodeAPS(&(vAPS[iCodedAPSIdx]), nalu.m_Bitstream, pcSliceForAPS);
	1469	accessUnit.push_back(new NALUnitEBSP(nalu));
	1470
	1471	processingState = ENCODE_SLICE;
[2]	1472	}
[56]	1473	break;
	1474	default:
	1475	{
	1476	printf("Not a supported encoding state\n");
	1477	assert(0);
	1478	exit(-1);
	1479	}
[2]	1480	}
[56]	1481	} // end iteration over slices
[5]	1482
	1483
[56]	1484	if(pcSlice->getSPS()->getUseSAO() \|\| pcSlice->getSPS()->getUseALF())
	1485	{
	1486	if(pcSlice->getSPS()->getUseSAO())
	1487	{
	1488	m_pcSAO->destroyPicSaoInfo();
	1489	}
[5]	1490
[56]	1491	if(pcSlice->getSPS()->getUseALF())
[2]	1492	{
[56]	1493	#if LCU_SYNTAX_ALF
	1494	m_pcAdaptiveLoopFilter->uninitALFEnc(alfSliceParams, alfCUCtrlParam);
	1495	#endif
	1496	m_pcAdaptiveLoopFilter->destroyPicAlfInfo();
[2]	1497	}
[5]	1498
[56]	1499	pcPic->destroyNonDBFilterInfo();
	1500	}
[5]	1501
[56]	1502	#if HHI_INTERVIEW_SKIP
	1503	if (pcPic->getUsedPelsMap())
	1504	pcPic->removeUsedPelsMapBuffer() ;
[5]	1505	#endif
[56]	1506	#if HHI_INTER_VIEW_MOTION_PRED
	1507	pcPic->removeOrgDepthMapBuffer();
	1508	#endif
	1509
	1510	// pcPic->compressMotion();
	1511	m_pocLastCoded = pcPic->getPOC();
	1512
[2]	1513	//-- For time output for each slice
	1514	Double dEncTime = (double)(clock()-iBeforeTime) / CLOCKS_PER_SEC;
[5]	1515
[56]	1516	const char* digestStr = NULL;
	1517	if (m_pcCfg->getPictureDigestEnabled())
	1518	{
[2]	1519	/* calculate MD5sum for entire reconstructed picture */
	1520	SEIpictureDigest sei_recon_picture_digest;
	1521	sei_recon_picture_digest.method = SEIpictureDigest::MD5;
	1522	calcMD5(*pcPic->getPicYuvRec(), sei_recon_picture_digest.digest);
[56]	1523	digestStr = digestToString(sei_recon_picture_digest.digest);
[2]	1524
[56]	1525	#if NAL_REF_FLAG
[77]	1526	#if VIDYO_VPS_INTEGRATION
	1527	OutputNALUnit nalu(NAL_UNIT_SEI, false, m_pcEncTop->getLayerId());
	1528	#else
[56]	1529	OutputNALUnit nalu(NAL_UNIT_SEI, false, m_pcEncTop->getViewId(), m_pcEncTop->getIsDepth());
[77]	1530	#endif
[56]	1531	#else
	1532	OutputNALUnit nalu(NAL_UNIT_SEI, NAL_REF_IDC_PRIORITY_LOWEST, m_pcEncTop->getViewId(), m_pcEncTop->getIsDepth());
	1533	#endif
	1534
[2]	1535	/* write the SEI messages */
	1536	m_pcEntropyCoder->setEntropyCoder(m_pcCavlcCoder, pcSlice);
[56]	1537	m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
[2]	1538	m_pcEntropyCoder->encodeSEI(sei_recon_picture_digest);
[56]	1539	writeRBSPTrailingBits(nalu.m_Bitstream);
[2]	1540
[56]	1541	/* insert the SEI message NALUnit before any Slice NALUnits */
	1542	AccessUnit::iterator it = find_if(accessUnit.begin(), accessUnit.end(), mem_fun(&NALUnit::isSlice));
	1543	accessUnit.insert(it, new NALUnitEBSP(nalu));
[2]	1544	}
	1545
[56]	1546	xCalculateAddPSNR( pcPic, pcPic->getPicYuvRec(), accessUnit, dEncTime );
	1547	if (digestStr)
	1548	printf(" [MD5:%s]", digestStr);
[2]	1549
[56]	1550	#if FIXED_ROUNDING_FRAME_MEMORY
	1551	/* TODO: this should happen after copyToPic(pcPicYuvRecOut) */
	1552	pcPic->getPicYuvRec()->xFixedRoundingPic();
	1553	#endif
[2]	1554	pcPic->getPicYuvRec()->copyToPic(pcPicYuvRecOut);
[56]	1555
[2]	1556	pcPic->setReconMark ( true );
[5]	1557
[56]	1558	pcPic->setUsedForTMVP ( true );
	1559
	1560	m_bFirst = false;
	1561	m_iNumPicCoded++;
	1562
	1563	/* logging: insert a newline at end of picture period */
	1564	printf("\n");
	1565	fflush(stdout);
	1566	}
	1567
	1568	delete[] pcSubstreamsOut;
	1569	delete pcBitstreamRedirect;
	1570
[2]	1571	}
	1572
[56]	1573	/** Memory allocation for APS
	1574	* \param [out] pAPS APS pointer
	1575	* \param [in] pSPS SPS pointer
	1576	*/
	1577	Void TEncGOP::allocAPS (TComAPS* pAPS, TComSPS* pSPS)
[2]	1578	{
[56]	1579	if(pSPS->getUseSAO())
	1580	{
	1581	pAPS->createSaoParam();
	1582	m_pcSAO->allocSaoParam(pAPS->getSaoParam());
	1583	}
	1584	if(pSPS->getUseALF())
	1585	{
	1586	pAPS->createAlfParam();
	1587	#if LCU_SYNTAX_ALF
	1588	//alf Enabled flag in APS is false after pAPS->createAlfParam();
	1589	if(!pSPS->getUseALFCoefInSlice())
	1590	{
	1591	pAPS->getAlfParam()->create(m_pcAdaptiveLoopFilter->getNumLCUInPicWidth(), m_pcAdaptiveLoopFilter->getNumLCUInPicHeight(), m_pcAdaptiveLoopFilter->getNumCUsInPic());
	1592	pAPS->getAlfParam()->createALFParam();
	1593	}
	1594	#else
	1595	m_pcAdaptiveLoopFilter->allocALFParam(pAPS->getAlfParam());
	1596	#endif
	1597	}
	1598	}
	1599
	1600	/** Memory deallocation for APS
	1601	* \param [out] pAPS APS pointer
	1602	* \param [in] pSPS SPS pointer
	1603	*/
	1604	Void TEncGOP::freeAPS (TComAPS* pAPS, TComSPS* pSPS)
	1605	{
	1606	if(pSPS->getUseSAO())
	1607	{
	1608	if(pAPS->getSaoParam() != NULL)
	1609	{
	1610	m_pcSAO->freeSaoParam(pAPS->getSaoParam());
	1611	pAPS->destroySaoParam();
	1612
	1613	}
	1614	}
	1615	if(pSPS->getUseALF())
	1616	{
	1617	if(pAPS->getAlfParam() != NULL)
	1618	{
	1619	#if LCU_SYNTAX_ALF
	1620	if(!pSPS->getUseALFCoefInSlice())
	1621	{
	1622	pAPS->getAlfParam()->releaseALFParam();
	1623	}
	1624	#else
	1625	m_pcAdaptiveLoopFilter->freeALFParam(pAPS->getAlfParam());
	1626	#endif
	1627	pAPS->destroyAlfParam();
	1628	}
	1629	}
	1630	}
	1631
	1632	/** Assign APS object into APS container according to APS ID
	1633	* \param [in] cAPS APS object
	1634	* \param [in] apsID APS ID
	1635	* \param [in,out] vAPS APS container
	1636	* \param [in] pcSlice pointer to slice
	1637	*/
	1638	Void TEncGOP::assignNewAPS(TComAPS& cAPS, Int apsID, std::vector<TComAPS>& vAPS, TComSlice* pcSlice)
	1639	{
	1640
	1641	cAPS.setAPSID(apsID);
	1642	if(pcSlice->getPOC() == 0)
	1643	{
	1644	cAPS.setScalingListEnabled(pcSlice->getSPS()->getScalingListFlag());
	1645	}
	1646	else
	1647	{
	1648	cAPS.setScalingListEnabled(false);
	1649	}
	1650
	1651	cAPS.setSaoEnabled(pcSlice->getSPS()->getUseSAO() ? (cAPS.getSaoParam()->bSaoFlag[0] ):(false));
	1652	#if LCU_SYNTAX_ALF
	1653	cAPS.setAlfEnabled(pcSlice->getSPS()->getUseALF() ? (cAPS.getAlfParam()->isEnabled[0]):(false));
	1654	#else
	1655	cAPS.setAlfEnabled(pcSlice->getSPS()->getUseALF() ? (cAPS.getAlfParam()->alf_flag ==1):(false));
	1656	#endif
	1657	cAPS.setLoopFilterOffsetInAPS(m_pcCfg->getLoopFilterOffsetInAPS());
	1658	cAPS.setLoopFilterDisable(m_pcCfg->getLoopFilterDisable());
	1659	cAPS.setLoopFilterBetaOffset(m_pcCfg->getLoopFilterBetaOffset());
	1660	cAPS.setLoopFilterTcOffset(m_pcCfg->getLoopFilterTcOffset());
	1661
	1662	//assign new APS into APS container
	1663	Int apsBufSize= (Int)vAPS.size();
	1664
	1665	if(apsID >= apsBufSize)
	1666	{
	1667	vAPS.resize(apsID +1);
	1668	}
	1669
	1670	freeAPS(&(vAPS[apsID]), pcSlice->getSPS());
	1671	vAPS[apsID] = cAPS;
	1672	}
	1673
	1674
	1675	/** encode APS syntax elements
	1676	* \param [in] pcAPS APS pointer
	1677	* \param [in, out] APSbs bitstream
	1678	* \param [in] pointer to slice (just used for entropy coder initialization)
	1679	*/
	1680	Void TEncGOP::encodeAPS(TComAPS* pcAPS, TComOutputBitstream& APSbs, TComSlice* pcSlice)
	1681	{
	1682	m_pcEntropyCoder->setEntropyCoder ( m_pcCavlcCoder, pcSlice);
	1683	m_pcEntropyCoder->resetEntropy ();
	1684	m_pcEntropyCoder->setBitstream(&APSbs);
	1685
	1686	m_pcEntropyCoder->encodeAPSInitInfo(pcAPS);
	1687	if(pcAPS->getScalingListEnabled())
	1688	{
	1689	m_pcEntropyCoder->encodeScalingList( pcSlice->getScalingList() );
	1690	}
	1691	if(pcAPS->getLoopFilterOffsetInAPS())
	1692	{
	1693	m_pcEntropyCoder->encodeDFParams(pcAPS);
	1694	}
	1695	#if SAO_UNIT_INTERLEAVING
	1696	m_pcEntropyCoder->encodeSaoParam(pcAPS);
	1697	#else
	1698	if(pcAPS->getSaoEnabled())
	1699	{
	1700	m_pcEntropyCoder->encodeSaoParam(pcAPS->getSaoParam());
	1701	}
	1702	#endif
	1703	#if LCU_SYNTAX_ALF
	1704	m_pcEntropyCoder->encodeAPSAlfFlag( pcAPS->getAlfEnabled()?1:0);
	1705	#endif
	1706	if(pcAPS->getAlfEnabled())
	1707	{
	1708	m_pcEntropyCoder->encodeAlfParam(pcAPS->getAlfParam());
	1709	}
	1710
	1711	m_pcEntropyCoder->encodeApsExtensionFlag();
	1712	//neither SAO and ALF is enabled
	1713	writeRBSPTrailingBits(APSbs);
	1714	}
	1715
	1716	Void TEncGOP::preLoopFilterPicAll( TComPic* pcPic, UInt64& ruiDist, UInt64& ruiBits )
	1717	{
[2]	1718	TComSlice* pcSlice = pcPic->getSlice(pcPic->getCurrSliceIdx());
	1719	Bool bCalcDist = false;
[56]	1720	#if DBL_CONTROL
	1721	m_pcLoopFilter->setCfg(pcSlice->getPPS()->getDeblockingFilterControlPresent(), pcSlice->getLoopFilterDisable(), m_pcCfg->getLoopFilterBetaOffset(), m_pcCfg->getLoopFilterTcOffset(), m_pcCfg->getLFCrossTileBoundaryFlag());
	1722	#else
	1723	m_pcLoopFilter->setCfg(pcSlice->getLoopFilterDisable(), m_pcCfg->getLoopFilterBetaOffset(), m_pcCfg->getLoopFilterTcOffset(), m_pcCfg->getLFCrossTileBoundaryFlag());
	1724	#endif
[2]	1725	m_pcLoopFilter->loopFilterPic( pcPic );
[56]	1726
[2]	1727	m_pcEntropyCoder->setEntropyCoder ( m_pcEncTop->getRDGoOnSbacCoder(), pcSlice );
	1728	m_pcEntropyCoder->resetEntropy ();
	1729	m_pcEntropyCoder->setBitstream ( m_pcBitCounter );
[56]	1730	pcSlice = pcPic->getSlice(0);
	1731	if(pcSlice->getSPS()->getUseSAO() \|\| pcSlice->getSPS()->getUseALF())
	1732	{
	1733	pcPic->createNonDBFilterInfo();
	1734	}
	1735
[2]	1736	// Adaptive Loop filter
	1737	if( pcSlice->getSPS()->getUseALF() )
	1738	{
[56]	1739	m_pcAdaptiveLoopFilter->createPicAlfInfo(pcPic);
	1740
	1741	#if LCU_SYNTAX_ALF
	1742	AlfParamSet* alfParamSet;
	1743	std::vector<AlfCUCtrlInfo>* alfCUCtrlParam = NULL;
	1744	alfParamSet= new AlfParamSet;
	1745	alfParamSet->create( m_pcAdaptiveLoopFilter->getNumLCUInPicWidth(), m_pcAdaptiveLoopFilter->getNumLCUInPicHeight(), m_pcAdaptiveLoopFilter->getNumCUsInPic());
	1746	alfParamSet->createALFParam();
	1747	m_pcAdaptiveLoopFilter->initALFEnc(false, true, 1, alfParamSet, alfCUCtrlParam);
	1748	#else
[2]	1749	ALFParam cAlfParam;
	1750	m_pcAdaptiveLoopFilter->allocALFParam(&cAlfParam);
[56]	1751	#endif
[2]	1752	m_pcAdaptiveLoopFilter->startALFEnc(pcPic, m_pcEntropyCoder);
[56]	1753
[5]	1754
[56]	1755	#if LCU_SYNTAX_ALF
	1756
	1757	#if ALF_CHROMA_LAMBDA
	1758	#if HHI_INTERVIEW_SKIP
	1759	m_pcAdaptiveLoopFilter->ALFProcess(alfParamSet, NULL, pcPic->getSlice(0)->getLambdaLuma(), pcPic->getSlice(0)->getLambdaChroma(), m_pcEncTop->getInterViewSkip() );
	1760	#else
	1761	m_pcAdaptiveLoopFilter->ALFProcess(alfParamSet, NULL, pcPic->getSlice(0)->getLambdaLuma(), pcPic->getSlice(0)->getLambdaChroma() );
	1762	#endif
	1763	#else
	1764	#if SAO_CHROMA_LAMBDA
	1765	m_pcAdaptiveLoopFilter->ALFProcess(alfParamSet, NULL, pcPic->getSlice(0)->getLambdaLuma(), m_pcEncTop->getInterViewSkip());
	1766	#if HHI_INTERVIEW_SKIP
	1767	#else
	1768	m_pcAdaptiveLoopFilter->ALFProcess(alfParamSet, NULL, pcPic->getSlice(0)->getLambdaLuma());
	1769	#endif
	1770	#else
	1771	#if HHI_INTERVIEW_SKIP
	1772	m_pcAdaptiveLoopFilter->ALFProcess(alfParamSet, NULL, pcPic->getSlice(0)->getLambda(), m_pcEncTop->getInterViewSkip());
	1773	#else
	1774	m_pcAdaptiveLoopFilter->ALFProcess(alfParamSet, NULL, pcPic->getSlice(0)->getLambda());
	1775	#endif
	1776	#endif
	1777	#endif
	1778
	1779	#else
	1780	#if ALF_CHROMA_LAMBDA
	1781	m_pcAdaptiveLoopFilter->ALFProcess(&cAlfParam, NULL, pcSlice->getLambdaLuma(), pcSlice->getLambdaChroma(), ruiDist, ruiBits, m_pcEncTop->getInterViewSkip());
	1782	#if HHI_INTERVIEW_SKIP
	1783	#else
	1784	m_pcAdaptiveLoopFilter->ALFProcess(&cAlfParam, NULL, pcSlice->getLambdaLuma(), pcSlice->getLambdaChroma(), ruiDist, ruiBits);
	1785	#endif
	1786	#else
	1787	#if SAO_CHROMA_LAMBDA
	1788	#if HHI_INTERVIEW_SKIP
	1789	m_pcAdaptiveLoopFilter->ALFProcess(&cAlfParam, NULL, pcSlice->getLambdaLuma(), ruiDist, ruiBits, m_pcEncTop->getInterViewSkip());
	1790	#else
	1791	m_pcAdaptiveLoopFilter->ALFProcess(&cAlfParam, NULL, pcSlice->getLambdaLuma(), ruiDist, ruiBits);
	1792	#endif
	1793	#else
	1794	#if HHI_INTERVIEW_SKIP
	1795	m_pcAdaptiveLoopFilter->ALFProcess(&cAlfParam, NULL, pcSlice->getLambda(), ruiDist, ruiBits, m_pcEncTop->getInterViewSkip());
	1796	#else
	1797	m_pcAdaptiveLoopFilter->ALFProcess(&cAlfParam, NULL, pcSlice->getLambda(), ruiDist, ruiBits);
	1798	#endif
	1799	#endif
	1800
	1801	#endif
	1802	#endif
[2]	1803	m_pcAdaptiveLoopFilter->endALFEnc();
[56]	1804
	1805	#if LCU_SYNTAX_ALF
	1806	alfParamSet->releaseALFParam();
	1807	delete alfParamSet;
	1808	delete alfCUCtrlParam;
	1809	#else
[2]	1810	m_pcAdaptiveLoopFilter->freeALFParam(&cAlfParam);
[56]	1811	#endif
	1812	m_pcAdaptiveLoopFilter->PCMLFDisableProcess(pcPic);
	1813	m_pcAdaptiveLoopFilter->destroyPicAlfInfo();
[2]	1814	}
[56]	1815	if( pcSlice->getSPS()->getUseSAO() \|\| pcSlice->getSPS()->getUseALF())
	1816	{
	1817	pcPic->destroyNonDBFilterInfo();
	1818	}
	1819
[2]	1820	m_pcEntropyCoder->resetEntropy ();
	1821	ruiBits += m_pcEntropyCoder->getNumberOfWrittenBits();
[56]	1822
[2]	1823	if (!bCalcDist)
	1824	ruiDist = xFindDistortionFrame(pcPic->getPicYuvOrg(), pcPic->getPicYuvRec());
	1825	}
	1826
	1827	// ====================================================================================================================
	1828	// Protected member functions
	1829	// ====================================================================================================================
	1830
[56]	1831	Void TEncGOP::xInitGOP( Int iPOCLast, Int iNumPicRcvd, TComList<TComPic>& rcListPic, TComList<TComPicYuv>& rcListPicYuvRecOut )
[2]	1832	{
[56]	1833	assert( iNumPicRcvd > 0 );
	1834	// Exception for the first frame
	1835	if ( iPOCLast == 0 )
	1836	{
	1837	m_iGopSize = 1;
	1838	}
	1839	else
	1840	m_iGopSize = m_pcCfg->getGOPSize();
	1841
	1842	assert (m_iGopSize > 0);
	1843
	1844	return;
	1845	}
	1846
	1847	Void TEncGOP::xGetBuffer( TComList<TComPic*>& rcListPic,
	1848	TComList<TComPicYuv*>& rcListPicYuvRecOut,
	1849	Int iNumPicRcvd,
	1850	Int iTimeOffset,
	1851	TComPic*& rpcPic,
	1852	TComPicYuv*& rpcPicYuvRecOut,
	1853	UInt uiPOCCurr )
	1854	{
	1855	Int i;
	1856	// Rec. output
	1857	TComList<TComPicYuv*>::iterator iterPicYuvRec = rcListPicYuvRecOut.end();
	1858	for ( i = 0; i < iNumPicRcvd - iTimeOffset + 1; i++ )
	1859	{
	1860	iterPicYuvRec--;
	1861	}
	1862
	1863	rpcPicYuvRecOut = *(iterPicYuvRec);
	1864
	1865	// Current pic.
	1866	TComList<TComPic*>::iterator iterPic = rcListPic.begin();
	1867	while (iterPic != rcListPic.end())
	1868	{
	1869	rpcPic = *(iterPic);
	1870	rpcPic->setCurrSliceIdx(0);
	1871	if (rpcPic->getPOC() == (Int)uiPOCCurr)
	1872	{
	1873	break;
	1874	}
	1875	iterPic++;
	1876	}
	1877
	1878	assert (rpcPic->getPOC() == (Int)uiPOCCurr);
	1879
	1880	return;
	1881	}
	1882
	1883	UInt64 TEncGOP::xFindDistortionFrame (TComPicYuv* pcPic0, TComPicYuv* pcPic1)
	1884	{
[2]	1885	Int x, y;
	1886	Pel* pSrc0 = pcPic0 ->getLumaAddr();
	1887	Pel* pSrc1 = pcPic1 ->getLumaAddr();
	1888	#if IBDI_DISTORTION
	1889	Int iShift = g_uiBitIncrement;
	1890	Int iOffset = 1<<(g_uiBitIncrement-1);
	1891	#else
	1892	UInt uiShift = g_uiBitIncrement<<1;
	1893	#endif
	1894	Int iTemp;
[56]	1895
[2]	1896	Int iStride = pcPic0->getStride();
	1897	Int iWidth = pcPic0->getWidth();
	1898	Int iHeight = pcPic0->getHeight();
[56]	1899
[2]	1900	UInt64 uiTotalDiff = 0;
[56]	1901
[2]	1902	for( y = 0; y < iHeight; y++ )
	1903	{
	1904	for( x = 0; x < iWidth; x++ )
	1905	{
	1906	#if IBDI_DISTORTION
	1907	iTemp = ((pSrc0[x]+iOffset)>>iShift) - ((pSrc1[x]+iOffset)>>iShift); uiTotalDiff += iTemp * iTemp;
	1908	#else
	1909	iTemp = pSrc0[x] - pSrc1[x]; uiTotalDiff += (iTemp*iTemp) >> uiShift;
	1910	#endif
	1911	}
	1912	pSrc0 += iStride;
	1913	pSrc1 += iStride;
	1914	}
[56]	1915
[2]	1916	iHeight >>= 1;
	1917	iWidth >>= 1;
	1918	iStride >>= 1;
[56]	1919
[2]	1920	pSrc0 = pcPic0->getCbAddr();
	1921	pSrc1 = pcPic1->getCbAddr();
[56]	1922
[2]	1923	for( y = 0; y < iHeight; y++ )
	1924	{
	1925	for( x = 0; x < iWidth; x++ )
	1926	{
	1927	#if IBDI_DISTORTION
	1928	iTemp = ((pSrc0[x]+iOffset)>>iShift) - ((pSrc1[x]+iOffset)>>iShift); uiTotalDiff += iTemp * iTemp;
	1929	#else
	1930	iTemp = pSrc0[x] - pSrc1[x]; uiTotalDiff += (iTemp*iTemp) >> uiShift;
	1931	#endif
	1932	}
	1933	pSrc0 += iStride;
	1934	pSrc1 += iStride;
	1935	}
[56]	1936
[2]	1937	pSrc0 = pcPic0->getCrAddr();
	1938	pSrc1 = pcPic1->getCrAddr();
[56]	1939
[2]	1940	for( y = 0; y < iHeight; y++ )
	1941	{
	1942	for( x = 0; x < iWidth; x++ )
	1943	{
	1944	#if IBDI_DISTORTION
	1945	iTemp = ((pSrc0[x]+iOffset)>>iShift) - ((pSrc1[x]+iOffset)>>iShift); uiTotalDiff += iTemp * iTemp;
	1946	#else
	1947	iTemp = pSrc0[x] - pSrc1[x]; uiTotalDiff += (iTemp*iTemp) >> uiShift;
	1948	#endif
	1949	}
	1950	pSrc0 += iStride;
	1951	pSrc1 += iStride;
	1952	}
[56]	1953
[2]	1954	return uiTotalDiff;
	1955	}
	1956
[56]	1957	#if VERBOSE_RATE
	1958	static const char* nalUnitTypeToString(NalUnitType type)
[2]	1959	{
[56]	1960	switch (type)
	1961	{
	1962	case NAL_UNIT_CODED_SLICE: return "SLICE";
	1963	#if H0566_TLA
	1964	case NAL_UNIT_CODED_SLICE_IDV: return "IDV";
	1965	case NAL_UNIT_CODED_SLICE_CRA: return "CRA";
	1966	case NAL_UNIT_CODED_SLICE_TLA: return "TLA";
	1967	#else
	1968	case NAL_UNIT_CODED_SLICE_CDR: return "CDR";
	1969	#endif
	1970	case NAL_UNIT_CODED_SLICE_IDR: return "IDR";
	1971	case NAL_UNIT_SEI: return "SEI";
	1972	case NAL_UNIT_SPS: return "SPS";
	1973	case NAL_UNIT_PPS: return "PPS";
	1974	case NAL_UNIT_FILLER_DATA: return "FILLER";
	1975	default: return "UNK";
	1976	}
	1977	}
	1978	#endif
	1979
	1980	Void TEncGOP::xCalculateAddPSNR( TComPic* pcPic, TComPicYuv* pcPicD, const AccessUnit& accessUnit, Double dEncTime )
	1981	{
[2]	1982	Int x, y;
	1983	UInt64 uiSSDY = 0;
	1984	UInt64 uiSSDU = 0;
	1985	UInt64 uiSSDV = 0;
[56]	1986
[2]	1987	Double dYPSNR = 0.0;
	1988	Double dUPSNR = 0.0;
	1989	Double dVPSNR = 0.0;
[56]	1990
[2]	1991	//===== calculate PSNR =====
	1992	Pel* pOrg = pcPic ->getPicYuvOrg()->getLumaAddr();
	1993	Pel* pRec = pcPicD->getLumaAddr();
	1994	Int iStride = pcPicD->getStride();
[56]	1995
[2]	1996	Int iWidth;
	1997	Int iHeight;
[56]	1998
[2]	1999	iWidth = pcPicD->getWidth () - m_pcEncTop->getPad(0);
	2000	iHeight = pcPicD->getHeight() - m_pcEncTop->getPad(1);
[56]	2001
[2]	2002	Int iSize = iWidth*iHeight;
[56]	2003
[2]	2004	for( y = 0; y < iHeight; y++ )
	2005	{
	2006	for( x = 0; x < iWidth; x++ )
	2007	{
	2008	Int iDiff = (Int)( pOrg[x] - pRec[x] );
	2009	uiSSDY += iDiff * iDiff;
	2010	}
	2011	pOrg += iStride;
	2012	pRec += iStride;
	2013	}
[56]	2014
	2015	#if HHI_VSO
[77]	2016	#if HHI_VSO_SYNTH_DIST_OUT
[2]	2017	if ( m_pcRdCost->getUseRenModel() )
	2018	{
[56]	2019	unsigned int maxval = 255 * (1<<(g_uiBitDepth + g_uiBitIncrement -8));
	2020	Double fRefValueY = (double) maxval * maxval * iSize;
	2021	Double fRefValueC = fRefValueY / 4.0;
[5]	2022	TRenModel* pcRenModel = m_pcEncTop->getEncTop()->getRenModel();
	2023	Int64 iDistVSOY, iDistVSOU, iDistVSOV;
	2024	pcRenModel->getTotalSSE( iDistVSOY, iDistVSOU, iDistVSOV );
[2]	2025	dYPSNR = ( iDistVSOY ? 10.0 * log10( fRefValueY / (Double) iDistVSOY ) : 99.99 );
	2026	dUPSNR = ( iDistVSOU ? 10.0 * log10( fRefValueC / (Double) iDistVSOU ) : 99.99 );
	2027	dVPSNR = ( iDistVSOV ? 10.0 * log10( fRefValueC / (Double) iDistVSOV ) : 99.99 );
	2028	}
	2029	else
[5]	2030	#endif
[77]	2031	#endif
[5]	2032	{
[2]	2033	iHeight >>= 1;
	2034	iWidth >>= 1;
	2035	iStride >>= 1;
	2036	pOrg = pcPic ->getPicYuvOrg()->getCbAddr();
	2037	pRec = pcPicD->getCbAddr();
[56]	2038
[2]	2039	for( y = 0; y < iHeight; y++ )
	2040	{
	2041	for( x = 0; x < iWidth; x++ )
	2042	{
	2043	Int iDiff = (Int)( pOrg[x] - pRec[x] );
	2044	uiSSDU += iDiff * iDiff;
	2045	}
	2046	pOrg += iStride;
	2047	pRec += iStride;
	2048	}
[56]	2049
[2]	2050	pOrg = pcPic ->getPicYuvOrg()->getCrAddr();
	2051	pRec = pcPicD->getCrAddr();
[56]	2052
[2]	2053	for( y = 0; y < iHeight; y++ )
	2054	{
	2055	for( x = 0; x < iWidth; x++ )
	2056	{
	2057	Int iDiff = (Int)( pOrg[x] - pRec[x] );
	2058	uiSSDV += iDiff * iDiff;
	2059	}
	2060	pOrg += iStride;
	2061	pRec += iStride;
	2062	}
[56]	2063
	2064	unsigned int maxval = 255 * (1<<(g_uiBitDepth + g_uiBitIncrement -8));
	2065	Double fRefValueY = (double) maxval * maxval * iSize;
	2066	Double fRefValueC = fRefValueY / 4.0;
[2]	2067	dYPSNR = ( uiSSDY ? 10.0 * log10( fRefValueY / (Double)uiSSDY ) : 99.99 );
	2068	dUPSNR = ( uiSSDU ? 10.0 * log10( fRefValueC / (Double)uiSSDU ) : 99.99 );
	2069	dVPSNR = ( uiSSDV ? 10.0 * log10( fRefValueC / (Double)uiSSDV ) : 99.99 );
	2070	}
[56]	2071	/* calculate the size of the access unit, excluding:
	2072	* - any AnnexB contributions (start_code_prefix, zero_byte, etc.,)
	2073	* - SEI NAL units
	2074	*/
	2075	unsigned numRBSPBytes = 0;
	2076	for (AccessUnit::const_iterator it = accessUnit.begin(); it != accessUnit.end(); it++)
	2077	{
	2078	unsigned numRBSPBytes_nal = unsigned((*it)->m_nalUnitData.str().size());
	2079	#if VERBOSE_RATE
	2080	printf("*** %6s numBytesInNALunit: %u\n", nalUnitTypeToString((*it)->m_nalUnitType), numRBSPBytes_nal);
	2081	#endif
	2082	if ((*it)->m_nalUnitType != NAL_UNIT_SEI)
	2083	numRBSPBytes += numRBSPBytes_nal;
	2084	}
[5]	2085
[56]	2086	unsigned uibits = numRBSPBytes * 8;
[2]	2087	m_vRVM_RP.push_back( uibits );
	2088
	2089	//===== add PSNR =====
[56]	2090	m_pcEncTop->getAnalyzeAll()->addResult (dYPSNR, dUPSNR, dVPSNR, (Double)uibits);
[2]	2091	TComSlice* pcSlice = pcPic->getSlice(0);
	2092	if (pcSlice->isIntra())
	2093	{
[56]	2094	m_pcEncTop->getAnalyzeI()->addResult (dYPSNR, dUPSNR, dVPSNR, (Double)uibits);
[2]	2095	}
	2096	if (pcSlice->isInterP())
	2097	{
[56]	2098	m_pcEncTop->getAnalyzeP()->addResult (dYPSNR, dUPSNR, dVPSNR, (Double)uibits);
[2]	2099	}
	2100	if (pcSlice->isInterB())
	2101	{
[56]	2102	m_pcEncTop->getAnalyzeB()->addResult (dYPSNR, dUPSNR, dVPSNR, (Double)uibits);
[2]	2103	}
	2104
[56]	2105	Char c = (pcSlice->isIntra() ? 'I' : pcSlice->isInterP() ? 'P' : 'B');
	2106	if (!pcSlice->isReferenced()) c += 32;
[5]	2107
[56]	2108	#if ADAPTIVE_QP_SELECTION
	2109	printf("%s View %3d POC %4d TId: %1d ( %c-SLICE, nQP %d QP %d ) %10d bits",
	2110	pcSlice->getIsDepth() ? "Depth " : "Texture",
	2111	pcSlice->getViewId(),
	2112	pcSlice->getPOC(),
	2113	pcSlice->getTLayer(),
	2114	c,
	2115	pcSlice->getSliceQpBase(),
	2116	pcSlice->getSliceQp(),
	2117	uibits );
	2118	#else
	2119	printf("%s View %3d POC %4d TId: %1d ( %c-SLICE, QP %d ) %10d bits",
	2120	pcSlice->getIsDepth() ? "Depth " : "Texture",
	2121	pcSlice->getViewId(),
	2122	pcSlice->getPOC()-pcSlice->getLastIDR(),
	2123	pcSlice->getTLayer(),
	2124	c,
	2125	pcSlice->getSliceQp(),
	2126	uibits );
	2127	#endif
	2128
	2129	printf(" [Y %6.4lf dB U %6.4lf dB V %6.4lf dB]", dYPSNR, dUPSNR, dVPSNR );
	2130	printf(" [ET %5.0f ]", dEncTime );
	2131
[2]	2132	for (Int iRefList = 0; iRefList < 2; iRefList++)
	2133	{
[56]	2134	printf(" [L%d ", iRefList);
[2]	2135	for (Int iRefIndex = 0; iRefIndex < pcSlice->getNumRefIdx(RefPicList(iRefList)); iRefIndex++)
	2136	{
[56]	2137	if( pcSlice->getViewId() != pcSlice->getRefViewId( RefPicList(iRefList), iRefIndex ) )
[2]	2138	{
[56]	2139	printf( "V%d ", pcSlice->getRefViewId( RefPicList(iRefList), iRefIndex ) );
[2]	2140	}
	2141	else
[56]	2142	{
	2143	printf ("%d ", pcSlice->getRefPOC(RefPicList(iRefList), iRefIndex)-pcSlice->getLastIDR());
	2144	}
[2]	2145	}
[56]	2146	printf("]");
[2]	2147	}
	2148	if(pcSlice->getNumRefIdx(REF_PIC_LIST_C)>0 && !pcSlice->getNoBackPredFlag())
	2149	{
[56]	2150	printf(" [LC ");
[2]	2151	for (Int iRefIndex = 0; iRefIndex < pcSlice->getNumRefIdx(REF_PIC_LIST_C); iRefIndex++)
	2152	{
[56]	2153	if( pcSlice->getViewId() != pcSlice->getRefViewId( (RefPicList)pcSlice->getListIdFromIdxOfLC(iRefIndex), pcSlice->getRefIdxFromIdxOfLC(iRefIndex) ) )
	2154	{
	2155	printf( "V%d ", pcSlice->getRefViewId( (RefPicList)pcSlice->getListIdFromIdxOfLC(iRefIndex), pcSlice->getRefIdxFromIdxOfLC(iRefIndex) ) );
	2156	}
	2157	else
	2158	{
	2159	printf ("%d ", pcSlice->getRefPOC((RefPicList)pcSlice->getListIdFromIdxOfLC(iRefIndex), pcSlice->getRefIdxFromIdxOfLC(iRefIndex))-pcSlice->getLastIDR());
	2160	}
[2]	2161	}
[56]	2162	printf("]");
[2]	2163	}
	2164	}
	2165
	2166	/** Function for deciding the nal_unit_type.
	2167	* \param uiPOCCurr POC of the current picture
	2168	* \returns the nal_unit type of the picture
	2169	* This function checks the configuration and returns the appropriate nal_unit_type for the picture.
	2170	*/
[56]	2171	NalUnitType TEncGOP::getNalUnitType(UInt uiPOCCurr)
[2]	2172	{
[56]	2173	Bool bInterViewOnlySlice = ( m_pcCfg->getGOPEntry(MAX_GOP).m_POC == 0 && (m_pcCfg->getGOPEntry(MAX_GOP).m_sliceType == 'P' \|\| m_pcCfg->getGOPEntry(MAX_GOP).m_sliceType == 'B') );
	2174
[2]	2175	if (uiPOCCurr == 0)
	2176	{
[56]	2177	if( bInterViewOnlySlice )
	2178	{
	2179	return NAL_UNIT_CODED_SLICE_IDV;
	2180	}
	2181	else
	2182	{
	2183	return NAL_UNIT_CODED_SLICE_IDR;
	2184	}
[2]	2185	}
	2186	if (uiPOCCurr % m_pcCfg->getIntraPeriod() == 0)
	2187	{
	2188	if (m_pcCfg->getDecodingRefreshType() == 1)
	2189	{
[56]	2190	if( bInterViewOnlySlice )
	2191	{
	2192	return NAL_UNIT_CODED_SLICE_IDV;
	2193	}
	2194	else
	2195	{
	2196	#if H0566_TLA
	2197	return NAL_UNIT_CODED_SLICE_CRA;
	2198	#else
[2]	2199	return NAL_UNIT_CODED_SLICE_CDR;
[56]	2200	#endif
	2201	}
[2]	2202	}
	2203	else if (m_pcCfg->getDecodingRefreshType() == 2)
	2204	{
[56]	2205	if( bInterViewOnlySlice )
	2206	{
	2207	return NAL_UNIT_CODED_SLICE_IDV;
	2208	}
	2209	else
	2210	{
	2211	return NAL_UNIT_CODED_SLICE_IDR;
	2212	}
	2213	}
	2214	}
	2215	return NAL_UNIT_CODED_SLICE;
	2216	}
	2217
	2218	NalUnitType TEncGOP::getNalUnitTypeBaseViewMvc(UInt uiPOCCurr)
	2219	{
	2220	if( uiPOCCurr == 0 )
	2221	{
	2222	return NAL_UNIT_CODED_SLICE_IDR;
	2223	}
	2224	if( uiPOCCurr % m_pcCfg->getIntraPeriod() == 0 )
	2225	{
	2226	if( m_pcCfg->getDecodingRefreshType() == 1 )
	2227	{
	2228	#if H0566_TLA
	2229	return NAL_UNIT_CODED_SLICE_CRA;
	2230	#else
	2231	return NAL_UNIT_CODED_SLICE_CDR;
	2232	#endif
	2233	}
	2234	else if( m_pcCfg->getDecodingRefreshType() == 2 )
	2235	{
[2]	2236	return NAL_UNIT_CODED_SLICE_IDR;
	2237	}
	2238	}
	2239	return NAL_UNIT_CODED_SLICE;
	2240	}
	2241
[56]	2242	Double TEncGOP::xCalculateRVM()
[2]	2243	{
	2244	Double dRVM = 0;
[56]	2245
	2246	if( m_pcCfg->getGOPSize() == 1 && m_pcCfg->getIntraPeriod() != 1 && m_pcCfg->getFrameToBeEncoded() > RVM_VCEGAM10_M * 2 )
[2]	2247	{
	2248	// calculate RVM only for lowdelay configurations
	2249	std::vector<Double> vRL , vB;
	2250	size_t N = m_vRVM_RP.size();
	2251	vRL.resize( N );
	2252	vB.resize( N );
[56]	2253
[2]	2254	Int i;
	2255	Double dRavg = 0 , dBavg = 0;
	2256	vB[RVM_VCEGAM10_M] = 0;
	2257	for( i = RVM_VCEGAM10_M + 1 ; i < N - RVM_VCEGAM10_M + 1 ; i++ )
	2258	{
	2259	vRL[i] = 0;
	2260	for( Int j = i - RVM_VCEGAM10_M ; j <= i + RVM_VCEGAM10_M - 1 ; j++ )
	2261	vRL[i] += m_vRVM_RP[j];
	2262	vRL[i] /= ( 2 * RVM_VCEGAM10_M );
	2263	vB[i] = vB[i-1] + m_vRVM_RP[i] - vRL[i];
	2264	dRavg += m_vRVM_RP[i];
	2265	dBavg += vB[i];
	2266	}
[56]	2267
[2]	2268	dRavg /= ( N - 2 * RVM_VCEGAM10_M );
	2269	dBavg /= ( N - 2 * RVM_VCEGAM10_M );
[56]	2270
[2]	2271	double dSigamB = 0;
	2272	for( i = RVM_VCEGAM10_M + 1 ; i < N - RVM_VCEGAM10_M + 1 ; i++ )
	2273	{
	2274	Double tmp = vB[i] - dBavg;
	2275	dSigamB += tmp * tmp;
	2276	}
	2277	dSigamB = sqrt( dSigamB / ( N - 2 * RVM_VCEGAM10_M ) );
[56]	2278
[2]	2279	double f = sqrt( 12.0 * ( RVM_VCEGAM10_M - 1 ) / ( RVM_VCEGAM10_M + 1 ) );
[56]	2280
[2]	2281	dRVM = dSigamB / dRavg * f;
	2282	}
[56]	2283
[2]	2284	return( dRVM );
	2285	}
[56]	2286
	2287	/** Determine the difference between consecutive tile sizes (in bytes) and writes it to bistream rNalu [slice header]
	2288	* \param rpcBitstreamRedirect contains the bitstream to be concatenated to rNalu. rpcBitstreamRedirect contains slice payload. rpcSlice contains tile location information.
	2289	* \returns Updates rNalu to contain concatenated bitstream. rpcBitstreamRedirect is cleared at the end of this function call.
	2290	*/
	2291	Void TEncGOP::xWriteTileLocationToSliceHeader (OutputNALUnit& rNalu, TComOutputBitstream& rpcBitstreamRedirect, TComSlice& rpcSlice)
	2292	{
	2293	{
	2294	#if !TILES_WPP_ENTRY_POINT_SIGNALLING
	2295	Int iTransmitTileLocationInSliceHeader = (rpcSlice->getTileLocationCount()==0 \|\| m_pcCfg->getTileLocationInSliceHeaderFlag()==0) ? 0 : 1;
	2296	rNalu.m_Bitstream.write(iTransmitTileLocationInSliceHeader, 1); // write flag indicating whether tile location information communicated in slice header
	2297
	2298	if (iTransmitTileLocationInSliceHeader)
	2299	{
	2300	rNalu.m_Bitstream.write(rpcSlice->getTileLocationCount()-1, 5); // write number of tiles
	2301
	2302	Int *aiDiff;
	2303	aiDiff = new Int [rpcSlice->getTileLocationCount()];
	2304
	2305	// Find largest number of bits required by Diff
	2306	Int iLastSize = 0, iDiffMax = 0, iDiffMin = 0;
	2307	for (UInt uiIdx=0; uiIdx<rpcSlice->getTileLocationCount(); uiIdx++)
	2308	{
	2309	Int iCurDiff, iCurSize;
	2310	if (uiIdx==0)
	2311	{
	2312	iCurDiff = rpcSlice->getTileLocation( uiIdx );
	2313	iLastSize = rpcSlice->getTileLocation( uiIdx );
	2314	}
	2315	else
	2316	{
	2317	iCurSize = rpcSlice->getTileLocation( uiIdx ) - rpcSlice->getTileLocation( uiIdx-1 );
	2318	iCurDiff = iCurSize - iLastSize;
	2319	iLastSize = iCurSize;
	2320	}
	2321	// Store Diff so it may be written to slice header later without re-calculating.
	2322	aiDiff[uiIdx] = iCurDiff;
	2323
	2324	if (iCurDiff>iDiffMax)
	2325	{
	2326	iDiffMax = iCurDiff;
	2327	}
	2328	if (iCurDiff<iDiffMin)
	2329	{
	2330	iDiffMin = iCurDiff;
	2331	}
	2332	}
	2333
	2334	Int iDiffMinAbs, iDiffMaxAbs;
	2335	iDiffMinAbs = (iDiffMin<0) ? (-iDiffMin) : iDiffMin;
	2336	iDiffMaxAbs = (iDiffMax<0) ? (-iDiffMax) : iDiffMax;
	2337
	2338	Int iBitsUsedByDiff = 0, iDiffAbsLargest;
	2339	iDiffAbsLargest = (iDiffMinAbs < iDiffMaxAbs) ? iDiffMaxAbs : iDiffMinAbs;
	2340	while (1)
	2341	{
	2342	if (iDiffAbsLargest >= (1 << iBitsUsedByDiff) )
	2343	{
	2344	iBitsUsedByDiff++;
	2345	}
	2346	else
	2347	{
	2348	break;
	2349	}
	2350	}
	2351	iBitsUsedByDiff++;
	2352
	2353	if (iBitsUsedByDiff > 32)
	2354	{
	2355	printf("\nDiff magnitude uses more than 32-bits");
	2356	assert ( 0 );
	2357	exit ( 0 ); // trying to catch any problems with using fixed bits for Diff information
	2358	}
	2359
	2360	rNalu.m_Bitstream.write( iBitsUsedByDiff-1, 5 ); // write number of bits used by Diff
	2361
	2362	// Write diff to slice header (rNalu)
	2363	for (UInt uiIdx=0; uiIdx<rpcSlice->getTileLocationCount(); uiIdx++)
	2364	{
	2365	Int iCurDiff = aiDiff[uiIdx];
	2366
	2367	// write sign of diff
	2368	if (uiIdx!=0)
	2369	{
	2370	if (iCurDiff<0)
	2371	{
	2372	rNalu.m_Bitstream.write(1, 1);
	2373	}
	2374	else
	2375	{
	2376	rNalu.m_Bitstream.write(0, 1);
	2377	}
	2378	}
	2379
	2380	// write abs value of diff
	2381	Int iAbsDiff = (iCurDiff<0) ? (-iCurDiff) : iCurDiff;
	2382	if (iAbsDiff > ((((UInt64)1)<<32)-1))
	2383	{
	2384	printf("\niAbsDiff exceeds 32-bit limit");
	2385	exit(0);
	2386	}
	2387	rNalu.m_Bitstream.write( iAbsDiff, iBitsUsedByDiff-1 );
	2388	}
	2389
	2390	delete [] aiDiff;
	2391	}
[2]	2392	#endif
[56]	2393	}
[2]	2394
[56]	2395	// Byte-align
	2396	rNalu.m_Bitstream.writeAlignOne();
	2397
	2398	// Update tile marker locations
	2399	TComOutputBitstream *pcOut = &rNalu.m_Bitstream;
	2400	UInt uiAccumulatedLength = pcOut->getNumberOfWrittenBits() >> 3;
	2401	for (Int uiMrkIdx = 0; uiMrkIdx < rpcBitstreamRedirect->getTileMarkerLocationCount(); uiMrkIdx++)
	2402	{
	2403	UInt uiBottom = pcOut->getTileMarkerLocationCount();
	2404	pcOut->setTileMarkerLocation ( uiBottom, uiAccumulatedLength + rpcBitstreamRedirect->getTileMarkerLocation( uiMrkIdx ) );
	2405	pcOut->setTileMarkerLocationCount ( uiBottom + 1 );
	2406	}
	2407
	2408	// Perform bitstream concatenation
	2409	if (rpcBitstreamRedirect->getNumberOfWrittenBits() > 0)
	2410	{
	2411	UInt uiBitCount = rpcBitstreamRedirect->getNumberOfWrittenBits();
	2412	if (rpcBitstreamRedirect->getByteStreamLength()>0)
	2413	{
	2414	UChar pucStart = reinterpret_cast<UChar>(rpcBitstreamRedirect->getByteStream());
	2415	UInt uiWriteByteCount = 0;
	2416	while (uiWriteByteCount < (uiBitCount >> 3) )
	2417	{
	2418	UInt uiBits = (*pucStart);
	2419	rNalu.m_Bitstream.write(uiBits, 8);
	2420	pucStart++;
	2421	uiWriteByteCount++;
	2422	}
	2423	}
	2424	UInt uiBitsHeld = (uiBitCount & 0x07);
	2425	for (UInt uiIdx=0; uiIdx < uiBitsHeld; uiIdx++)
	2426	{
	2427	rNalu.m_Bitstream.write((rpcBitstreamRedirect->getHeldBits() & (1 << (7-uiIdx))) >> (7-uiIdx), 1);
	2428	}
	2429	}
	2430
	2431	m_pcEntropyCoder->setBitstream(&rNalu.m_Bitstream);
	2432
	2433	delete rpcBitstreamRedirect;
	2434	rpcBitstreamRedirect = new TComOutputBitstream;
	2435	}
	2436
	2437	Void TEncGOP::xSetRefPicListModificationsMvc( TComSlice* pcSlice, UInt uiPOCCurr, UInt iGOPid )
	2438	{
	2439	if( pcSlice->getSliceType() == I_SLICE \|\| !(pcSlice->getSPS()->getListsModificationPresentFlag()) \|\| pcSlice->getSPS()->getNumberOfUsableInterViewRefs() == 0 )
	2440	{
	2441	return;
	2442	}
	2443
	2444	// analyze inter-view modifications
	2445	GOPEntryMvc gem = m_pcCfg->getGOPEntry( (getNalUnitType(uiPOCCurr) == NAL_UNIT_CODED_SLICE_IDV) ? MAX_GOP : iGOPid );
	2446	Int numL0Modifications = 0;
	2447	Int numL1Modifications = 0;
	2448	for( Int k = 0; k < gem.m_numInterViewRefPics; k++ )
	2449	{
	2450	if( gem.m_interViewRefPosL0[k] > 0 ) { numL0Modifications++; }
	2451	if( gem.m_interViewRefPosL1[k] > 0 ) { numL1Modifications++; }
	2452	}
	2453
	2454	TComRefPicListModification* refPicListModification = pcSlice->getRefPicListModification();
	2455	Int maxRefListSize = pcSlice->getNumPocTotalCurrMvc();
	2456	Int numTemporalRefs = pcSlice->getNumPocTotalCurr();
	2457
	2458	// set L0 inter-view modifications
	2459	if( (maxRefListSize > 1) && (numL0Modifications > 0) )
	2460	{
	2461	refPicListModification->setRefPicListModificationFlagL0( true );
	2462	Int tempListEntryL0[16];
	2463	for( Int k = 0; k < 16; k++ ) { tempListEntryL0[k] = -1; }
	2464
	2465	Bool hasModification = false;
	2466	for( Int k = 0; k < gem.m_numInterViewRefPics; k++ )
	2467	{
	2468	if( gem.m_interViewRefPosL0[k] > 0 )
	2469	{
	2470	for( Int l = 0; l < pcSlice->getSPS()->getNumberOfUsableInterViewRefs(); l++ )
	2471	{
	2472	if( gem.m_interViewRefs[k] == pcSlice->getSPS()->getUsableInterViewRef( l ) && (gem.m_interViewRefPosL0[k] - 1) != (numTemporalRefs + l) )
	2473	{
	2474	tempListEntryL0[gem.m_interViewRefPosL0[k]-1] = numTemporalRefs + l;
	2475	hasModification = true;
	2476	}
	2477	}
	2478	}
	2479	}
	2480
	2481	if( hasModification )
	2482	{
	2483	Int temporalRefIdx = 0;
	2484	for( Int i = 0; i < pcSlice->getNumRefIdx( REF_PIC_LIST_0 ); i++ )
	2485	{
	2486	if( tempListEntryL0[i] >= 0 )
	2487	{
	2488	refPicListModification->setRefPicSetIdxL0( i, tempListEntryL0[i] );
	2489	}
	2490	else
	2491	{
	2492	refPicListModification->setRefPicSetIdxL0( i, temporalRefIdx );
	2493	temporalRefIdx++;
	2494	}
	2495	}
	2496	}
	2497	else
	2498	{
	2499	refPicListModification->setRefPicListModificationFlagL0( false );
	2500	}
	2501	}
	2502
	2503	// set L1 inter-view modifications
	2504	if( (maxRefListSize > 1) && (numL1Modifications > 0) )
	2505	{
	2506	refPicListModification->setRefPicListModificationFlagL1( true );
	2507	Int tempListEntryL1[16];
	2508	for( Int k = 0; k < 16; k++ ) { tempListEntryL1[k] = -1; }
	2509
	2510	Bool hasModification = false;
	2511	for( Int k = 0; k < gem.m_numInterViewRefPics; k++ )
	2512	{
	2513	if( gem.m_interViewRefPosL1[k] > 0 )
	2514	{
	2515	for( Int l = 0; l < pcSlice->getSPS()->getNumberOfUsableInterViewRefs(); l++ )
	2516	{
	2517	if( gem.m_interViewRefs[k] == pcSlice->getSPS()->getUsableInterViewRef( l ) && (gem.m_interViewRefPosL1[k] - 1) != (numTemporalRefs + l) )
	2518	{
	2519	tempListEntryL1[gem.m_interViewRefPosL1[k]-1] = numTemporalRefs + l;
	2520	hasModification = true;
	2521	}
	2522	}
	2523	}
	2524	}
	2525
	2526	if( hasModification )
	2527	{
	2528	Int temporalRefIdx = 0;
	2529	for( Int i = 0; i < pcSlice->getNumRefIdx( REF_PIC_LIST_1 ); i++ )
	2530	{
	2531	if( tempListEntryL1[i] >= 0 )
	2532	{
	2533	refPicListModification->setRefPicSetIdxL1( i, tempListEntryL1[i] );
	2534	}
	2535	else
	2536	{
	2537	refPicListModification->setRefPicSetIdxL1( i, temporalRefIdx );
	2538	temporalRefIdx++;
	2539	}
	2540	}
	2541	}
	2542	else
	2543	{
	2544	refPicListModification->setRefPicListModificationFlagL1( false );
	2545	}
	2546	}
	2547
	2548	return;
	2549	}
	2550	//! \}

Note: See TracBrowser for help on using the repository browser.

JCT-3V 3D-HEVC

Context navigation

source: 3DVCSoftware/branches/HTM-3.1-Qualcomm/source/Lib/TLibEncoder/TEncGOP.cpp @ 892

Download in other formats: