Context navigation

source: 3DVCSoftware/branches/0.3-poznan-univ/source/Lib/TLibEncoder/TEncGOP.cpp @ 34

Visit:

Last change on this file since 34 was 28, checked in by poznan-univ, 13 years ago

Poznan Tools

Encoding only disoccluded CUs in depended views
Depth based motion prediction
Texture QP adjustment based on depth data
Nonlinear depth representation

Property svn:eol-style set to native

File size: 38.9 KB

Line
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
4	* granted under this license.
5	*
6	* Copyright (c) 2010-2011, ISO/IEC
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.
17	* * Neither the name of the ISO/IEC nor the names of its contributors may
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	*/
33
34
35
36	/** \file TEncPic.cpp
37	\brief GOP encoder class
38	*/
39
40	#include "TEncTop.h"
41	#include "TEncGOP.h"
42	#include "TEncAnalyze.h"
43	#include "../libmd5/MD5.h"
44	#include "../TLibCommon/SEI.h"
45
46	#include <time.h>
47
48	#include "../../App/TAppEncoder/TAppEncTop.h"
49
50	// ====================================================================================================================
51	// Constructor / destructor / initialization / destroy
52	// ====================================================================================================================
53
54	TEncPic::TEncPic()
55	{
56	m_pcCfg = NULL;
57	m_pcSliceEncoder = NULL;
58	m_pcListPic = NULL;
59
60	m_pcEntropyCoder = NULL;
61	m_pcCavlcCoder = NULL;
62	m_pcSbacCoder = NULL;
63	m_pcBinCABAC = NULL;
64	#if DEPTH_MAP_GENERATION
65	m_pcDepthMapGenerator = NULL;
66	#endif
67	#if HHI_INTER_VIEW_RESIDUAL_PRED
68	m_pcResidualGenerator = NULL;
69	#endif
70
71	#if DCM_DECODING_REFRESH
72	m_bRefreshPending = 0;
73	m_uiPOCCDR = 0;
74	#endif
75
76	return;
77	}
78
79	TEncPic::~TEncPic()
80	{
81	}
82
83	/** Create list to contain pointers to LCU start addresses of slice.
84	* \param iWidth, iHeight are picture width, height. iMaxCUWidth, iMaxCUHeight are LCU width, height.
85	*/
86	Void TEncPic::create( Int iWidth, Int iHeight, UInt iMaxCUWidth, UInt iMaxCUHeight )
87	{
88	UInt uiWidthInCU = ( iWidth %iMaxCUWidth ) ? iWidth /iMaxCUWidth + 1 : iWidth /iMaxCUWidth;
89	UInt uiHeightInCU = ( iHeight%iMaxCUHeight ) ? iHeight/iMaxCUHeight + 1 : iHeight/iMaxCUHeight;
90	UInt uiNumCUsInFrame = uiWidthInCU * uiHeightInCU;
91	m_uiStoredStartCUAddrForEncodingSlice = new UInt [uiNumCUsInFrame+1];
92	m_uiStoredStartCUAddrForEncodingEntropySlice = new UInt [uiNumCUsInFrame+1];
93	}
94
95	Void TEncPic::destroy()
96	{
97	delete [] m_uiStoredStartCUAddrForEncodingSlice; m_uiStoredStartCUAddrForEncodingSlice = NULL;
98	delete [] m_uiStoredStartCUAddrForEncodingEntropySlice; m_uiStoredStartCUAddrForEncodingEntropySlice = NULL;
99	}
100
101	Void TEncPic::init ( TEncTop* pcTEncTop )
102	{
103	m_pcEncTop = pcTEncTop;
104	m_pcCfg = pcTEncTop;
105	m_pcSliceEncoder = pcTEncTop->getSliceEncoder();
106	m_pcListPic = pcTEncTop->getListPic();
107
108	m_pcEntropyCoder = pcTEncTop->getEntropyCoder();
109	m_pcCavlcCoder = pcTEncTop->getCavlcCoder();
110	m_pcSbacCoder = pcTEncTop->getSbacCoder();
111	m_pcBinCABAC = pcTEncTop->getBinCABAC();
112	m_pcLoopFilter = pcTEncTop->getLoopFilter();
113	m_pcBitCounter = pcTEncTop->getBitCounter();
114	#if DEPTH_MAP_GENERATION
115	m_pcDepthMapGenerator = pcTEncTop->getDepthMapGenerator();
116	#endif
117	#if HHI_INTER_VIEW_RESIDUAL_PRED
118	m_pcResidualGenerator = pcTEncTop->getResidualGenerator();
119	#endif
120
121	// Adaptive Loop filter
122	m_pcAdaptiveLoopFilter = pcTEncTop->getAdaptiveLoopFilter();
123	//--Adaptive Loop filter
124	#if MTK_SAO
125	m_pcSAO = pcTEncTop->getSAO();
126	#endif
127	m_pcRdCost = pcTEncTop->getRdCost();
128
129	}
130
131	// ====================================================================================================================
132	// Public member functions
133	// ====================================================================================================================
134
135	Void TEncPic::compressPic( TComBitstream* pcBitstreamOut, TComPicYuv cPicOrg, TComPic* pcPic, TComPicYuv* pcPicYuvRecOut,
136	TComPic* pcOrgRefList[2][MAX_REF_PIC_NUM], Bool& rbSeqFirst, TComList<TComPic*>& rcListPic )
137	{
138	TComSlice* pcSlice;
139
140	//-- For time output for each slice
141	long iBeforeTime = clock();
142
143	// Bitstream reset
144	pcBitstreamOut->resetBits();
145	pcBitstreamOut->rewindStreamPacket();
146
147	// Slice data initialization
148	pcPic->clearSliceBuffer();
149	assert(pcPic->getNumAllocatedSlice() == 1);
150	m_pcSliceEncoder->setSliceIdx(0);
151	pcPic->setCurrSliceIdx(0);
152	m_pcSliceEncoder->initEncSlice ( pcPic, pcSlice );
153	pcSlice->setSliceIdx(0);
154
155	// Set SPS
156	pcSlice->setSPS( m_pcEncTop->getSPS() );
157	pcSlice->setPPS( m_pcEncTop->getPPS() );
158	pcSlice->setPPSId( pcSlice->getPPS()->getPPSId() );
159
160	// set mutliview parameters
161	pcSlice->initMultiviewSlice( pcPic->getCodedScale(), pcPic->getCodedOffset() );
162
163	#if DCM_DECODING_REFRESH
164	// Set the nal unit type
165	if( pcSlice->getPOC() == 0 )
166	pcSlice->setNalUnitType( NAL_UNIT_CODED_SLICE_IDR );
167	else
168	pcSlice->setNalUnitType( NAL_UNIT_CODED_SLICE );
169
170	//pcSlice->setNalUnitType(getNalUnitType(uiPOCCurr));
171	// Do decoding refresh marking if any
172	pcSlice->decodingRefreshMarking(m_uiPOCCDR, m_bRefreshPending, rcListPic);
173	#endif
174
175	// GT FIX
176	std::vector<TComPic*> apcSpatRefPics = m_pcEncTop->getEncTop()->getSpatialRefPics( pcPic->getViewIdx(), pcSlice->getPOC(), m_pcEncTop->isDepthCoder() );
177	TComPic * const pcTexturePic = m_pcEncTop->isDepthCoder() ? m_pcEncTop->getEncTop()->getPicFromView( pcPic->getViewIdx(), pcSlice->getPOC(), false ) : NULL;
178	assert( ! m_pcEncTop->isDepthCoder() \|\| pcTexturePic != NULL );
179	pcSlice->setTexturePic( pcTexturePic );
180
181	pcSlice->setRefPicListFromGOPSTring( rcListPic, apcSpatRefPics );
182
183	#if HHI_VSO
184	m_pcEncTop->getEncTop()->setMVDPic(pcPic->getViewIdx(), pcSlice->getPOC(), pcPic->getMVDReferenceInfo() );
185
186
187	Bool bUseVSO = m_pcEncTop->getUseVSO();
188	m_pcRdCost->setUseVSO( bUseVSO );
189
190	if ( bUseVSO )
191	{
192	Int iVSOMode = m_pcEncTop->getVSOMode();
193	m_pcRdCost->setVSOMode( iVSOMode );
194	#if HHI_VSO_DIST_INT
195	m_pcRdCost->setAllowNegDist( m_pcEncTop->getAllowNegDist() );
196	#endif
197
198	if ( iVSOMode == 4 )
199	{
200	m_pcEncTop->getEncTop()->setupRenModel( pcSlice->getPOC(), pcPic->getViewIdx(), m_pcEncTop->isDepthCoder() ? 1 : 0 );
201	}
202	else
203	{
204	m_pcRdCost->setRefDataFromMVDInfo( pcPic->getMVDReferenceInfo() );
205	}
206	}
207	#endif
208
209	#if HHI_INTERVIEW_SKIP
210	if ( m_pcEncTop->getInterViewSkip() )
211	{
212	m_pcEncTop->getEncTop()->getUsedPelsMap( pcPic->getViewIdx(), pcPic->getPOC(), pcPic->getUsedPelsMap() );
213	}
214	#endif
215
216	pcSlice->setNoBackPredFlag( false );
217	#if DCM_COMB_LIST
218	if ( pcSlice->getSliceType() == B_SLICE && !pcSlice->getRefPicListCombinationFlag())
219	#else
220	if ( pcSlice->getSliceType() == B_SLICE )
221	#endif
222	{
223	if ( pcSlice->getNumRefIdx(RefPicList( 0 ) ) == pcSlice->getNumRefIdx(RefPicList( 1 ) ) )
224	{
225	pcSlice->setNoBackPredFlag( true );
226	int i;
227	for ( i=0; i < pcSlice->getNumRefIdx(RefPicList( 1 ) ); i++ )
228	{
229	if ( pcSlice->getRefPOC(RefPicList(1), i) != pcSlice->getRefPOC(RefPicList(0), i) )
230	{
231	pcSlice->setNoBackPredFlag( false );
232	break;
233	}
234	}
235	}
236	}
237
238	#if DCM_COMB_LIST
239	if(pcSlice->getNoBackPredFlag())
240	{
241	pcSlice->setNumRefIdx(REF_PIC_LIST_C, -1);
242	}
243	pcSlice->generateCombinedList();
244	#endif
245
246	/////////////////////////////////////////////////////////////////////////////////////////////////// Compress a slice
247	// Slice compression
248	if (m_pcCfg->getUseASR())
249	{
250	m_pcSliceEncoder->setSearchRange(pcSlice);
251	}
252	#ifdef ROUNDING_CONTROL_BIPRED
253	Bool b = true;
254	if (m_pcCfg->getUseRoundingControlBipred())
255	{
256	if (m_pcCfg->getCodedPictureBufferSize()==1)
257	b = ((pcSlice->getPOC()&1)==0);
258	else
259	b = (pcSlice->isReferenced() == 0);
260	}
261
262	#if HIGH_ACCURACY_BI
263	pcSlice->setRounding(false);
264	#else
265	pcSlice->setRounding(b);
266	#endif
267	#endif
268
269	UInt uiStartCUAddrSliceIdx = 0; // used to index "m_uiStoredStartCUAddrForEncodingSlice" containing locations of slice boundaries
270	UInt uiStartCUAddrSlice = 0; // used to keep track of current slice's starting CU addr.
271	pcSlice->setSliceCurStartCUAddr( uiStartCUAddrSlice ); // Setting "start CU addr" for current slice
272	memset(m_uiStoredStartCUAddrForEncodingSlice, 0, sizeof(UInt) * (pcPic->getPicSym()->getNumberOfCUsInFrame()+1));
273
274	UInt uiStartCUAddrEntropySliceIdx = 0; // used to index "m_uiStoredStartCUAddrForEntropyEncodingSlice" containing locations of slice boundaries
275	UInt uiStartCUAddrEntropySlice = 0; // used to keep track of current Entropy slice's starting CU addr.
276	pcSlice->setEntropySliceCurStartCUAddr( uiStartCUAddrEntropySlice ); // Setting "start CU addr" for current Entropy slice
277	memset(m_uiStoredStartCUAddrForEncodingEntropySlice, 0, sizeof(UInt) * (pcPic->getPicSym()->getNumberOfCUsInFrame()+1));
278
279	UInt uiNextCUAddr = 0;
280	m_uiStoredStartCUAddrForEncodingSlice[uiStartCUAddrSliceIdx++] = uiNextCUAddr;
281	m_uiStoredStartCUAddrForEncodingEntropySlice[uiStartCUAddrEntropySliceIdx++] = uiNextCUAddr;
282
283	#if DEPTH_MAP_GENERATION
284	// init view component and predict virtual depth map
285	m_pcDepthMapGenerator->initViewComponent( pcPic );
286	m_pcDepthMapGenerator->predictDepthMap ( pcPic );
287	#if HHI_INTER_VIEW_MOTION_PRED
288	m_pcDepthMapGenerator->covertOrgDepthMap( pcPic );
289	#endif
290	#if HHI_INTER_VIEW_RESIDUAL_PRED
291	m_pcResidualGenerator->initViewComponent( pcPic );
292	#endif
293	#endif
294
295	#if POZNAN_MP
296	#if POZNAN_MP_USE_DEPTH_MAP_GENERATION
297	pcSlice->getMP()->setDepthMapGenerator(m_pcDepthMapGenerator);
298	#else
299	std::vector<TComPic*> apcSpatDepthRefPics = m_pcEncTop->getEncTop()->getSpatialRefPics( pcPic->getViewIdx(), pcSlice->getPOC(), true );
300	pcSlice->getMP()->setDepthRefPicsList(&apcSpatDepthRefPics);
301	#endif
302	std::vector<TComPic*> apcSpatDataRefPics = m_pcEncTop->getEncTop()->getSpatialRefPics( pcPic->getViewIdx(), pcSlice->getPOC(), m_pcEncTop->isDepthCoder() );
303	pcSlice->getMP()->setRefPicsList(&apcSpatDataRefPics);
304	pcSlice->getMP()->pairMultiview(pcPic);
305	#endif
306
307	while(uiNextCUAddr<pcPic->getPicSym()->getNumberOfCUsInFrame()) // determine slice boundaries
308	{
309	pcSlice->setNextSlice ( false );
310	pcSlice->setNextEntropySlice( false );
311	assert(pcPic->getNumAllocatedSlice() == uiStartCUAddrSliceIdx);
312	m_pcSliceEncoder->precompressSlice( pcPic );
313	m_pcSliceEncoder->compressSlice ( pcPic );
314
315	Bool bNoBinBitConstraintViolated = (!pcSlice->isNextSlice() && !pcSlice->isNextEntropySlice());
316	if (pcSlice->isNextSlice() \|\| (bNoBinBitConstraintViolated && m_pcCfg->getSliceMode()==AD_HOC_SLICES_FIXED_NUMBER_OF_LCU_IN_SLICE))
317	{
318	uiStartCUAddrSlice = pcSlice->getSliceCurEndCUAddr();
319	// Reconstruction slice
320	m_uiStoredStartCUAddrForEncodingSlice[uiStartCUAddrSliceIdx++] = uiStartCUAddrSlice;
321	// Entropy slice
322	if (uiStartCUAddrEntropySliceIdx>0 && m_uiStoredStartCUAddrForEncodingEntropySlice[uiStartCUAddrEntropySliceIdx-1] != uiStartCUAddrSlice)
323	{
324	m_uiStoredStartCUAddrForEncodingEntropySlice[uiStartCUAddrEntropySliceIdx++] = uiStartCUAddrSlice;
325	}
326
327	if (uiStartCUAddrSlice < pcPic->getPicSym()->getNumberOfCUsInFrame())
328	{
329	pcPic->allocateNewSlice();
330	pcPic->setCurrSliceIdx ( uiStartCUAddrSliceIdx-1 );
331	m_pcSliceEncoder->setSliceIdx ( uiStartCUAddrSliceIdx-1 );
332	pcSlice = pcPic->getSlice ( uiStartCUAddrSliceIdx-1 );
333	pcSlice->copySliceInfo ( pcPic->getSlice(0) );
334	pcSlice->setSliceIdx ( uiStartCUAddrSliceIdx-1 );
335	pcSlice->setSliceCurStartCUAddr ( uiStartCUAddrSlice );
336	pcSlice->setEntropySliceCurStartCUAddr ( uiStartCUAddrSlice );
337	pcSlice->setSliceBits(0);
338	}
339	}
340	else if (pcSlice->isNextEntropySlice() \|\| (bNoBinBitConstraintViolated && m_pcCfg->getEntropySliceMode()==SHARP_FIXED_NUMBER_OF_LCU_IN_ENTROPY_SLICE))
341	{
342	uiStartCUAddrEntropySlice = pcSlice->getEntropySliceCurEndCUAddr();
343	m_uiStoredStartCUAddrForEncodingEntropySlice[uiStartCUAddrEntropySliceIdx++] = uiStartCUAddrEntropySlice;
344	pcSlice->setEntropySliceCurStartCUAddr( uiStartCUAddrEntropySlice );
345	}
346	else
347	{
348	uiStartCUAddrSlice = pcSlice->getSliceCurEndCUAddr();
349	uiStartCUAddrEntropySlice = pcSlice->getEntropySliceCurEndCUAddr();
350	}
351
352	uiNextCUAddr = (uiStartCUAddrSlice > uiStartCUAddrEntropySlice) ? uiStartCUAddrSlice : uiStartCUAddrEntropySlice;
353	}
354	m_uiStoredStartCUAddrForEncodingSlice[uiStartCUAddrSliceIdx++] = pcSlice->getSliceCurEndCUAddr();
355	m_uiStoredStartCUAddrForEncodingEntropySlice[uiStartCUAddrEntropySliceIdx++] = pcSlice->getSliceCurEndCUAddr();
356
357	pcSlice = pcPic->getSlice(0);
358	#if MTK_SAO // PRE_DF
359	SAOParam cSaoParam;
360	#endif
361
362	#if HHI_INTER_VIEW_RESIDUAL_PRED
363	// set residual picture
364	m_pcResidualGenerator->setRecResidualPic( pcPic );
365	#endif
366	#if DEPTH_MAP_GENERATION
367	// update virtual depth map
368	m_pcDepthMapGenerator->updateDepthMap( pcPic );
369	#endif
370
371	//-- Loop filter
372	m_pcLoopFilter->setCfg(pcSlice->getLoopFilterDisable(), m_pcCfg->getLoopFilterAlphaC0Offget(), m_pcCfg->getLoopFilterBetaOffget());
373	m_pcLoopFilter->loopFilterPic( pcPic );
374
375	#if MTK_NONCROSS_INLOOP_FILTER
376	pcSlice = pcPic->getSlice(0);
377
378	if(pcSlice->getSPS()->getUseALF())
379	{
380	if(pcSlice->getSPS()->getLFCrossSliceBoundaryFlag())
381	{
382	m_pcAdaptiveLoopFilter->setUseNonCrossAlf(false);
383	}
384	else
385	{
386	UInt uiNumSlices = uiStartCUAddrSliceIdx-1;
387	m_pcAdaptiveLoopFilter->setUseNonCrossAlf( (uiNumSlices > 1) );
388	if(m_pcAdaptiveLoopFilter->getUseNonCrossAlf())
389	{
390	m_pcAdaptiveLoopFilter->setNumSlicesInPic( uiNumSlices );
391	m_pcAdaptiveLoopFilter->createSlice();
392
393	//set the startLCU and endLCU addr. to ALF slices
394	for(UInt i=0; i< uiNumSlices ; i++)
395	{
396	(*m_pcAdaptiveLoopFilter)[i].create(pcPic, i,
397	m_uiStoredStartCUAddrForEncodingSlice[i],
398	m_uiStoredStartCUAddrForEncodingSlice[i+1]-1
399	);
400
401	}
402	}
403	}
404	}
405	#endif
406	/////////////////////////////////////////////////////////////////////////////////////////////////// File writing
407	// Set entropy coder
408	m_pcEntropyCoder->setEntropyCoder ( m_pcCavlcCoder, pcSlice );
409
410	/* write various header sets.
411	* The header sets are written into a separate bitstream buffer to
412	* allow SEI messages that are calculated after the picture has been
413	* encoded to be sent before the picture.
414	*/
415	TComBitstream bs_SPS_PPS_SEI;
416	bs_SPS_PPS_SEI.create(512); /* TODO: this should dynamically resize */
417	if ( rbSeqFirst )
418	{
419	m_pcEntropyCoder->setBitstream(&bs_SPS_PPS_SEI);
420
421	m_pcEntropyCoder->encodeSPS( pcSlice->getSPS() );
422	bs_SPS_PPS_SEI.write( 1, 1 );
423	bs_SPS_PPS_SEI.writeAlignZero();
424	// generate start code
425	bs_SPS_PPS_SEI.write( 1, 32);
426
427	m_pcEntropyCoder->encodePPS( pcSlice->getPPS() );
428	bs_SPS_PPS_SEI.write( 1, 1 );
429	bs_SPS_PPS_SEI.writeAlignZero();
430	// generate start code
431	bs_SPS_PPS_SEI.write( 1, 32);
432	rbSeqFirst = false;
433	}
434
435	/* use the main bitstream buffer for storing the marshalled picture */
436	m_pcEntropyCoder->setBitstream(pcBitstreamOut);
437
438	uiStartCUAddrSliceIdx = 0;
439	uiStartCUAddrSlice = 0;
440	pcBitstreamOut->allocateMemoryForSliceLocations( pcPic->getPicSym()->getNumberOfCUsInFrame() ); // Assuming number of slices <= number of LCU. Needs to be changed for sub-LCU slice coding.
441	pcBitstreamOut->setSliceCount( 0 ); // intialize number of slices to zero, used while converting RBSP to NALU
442
443	uiStartCUAddrEntropySliceIdx = 0;
444	uiStartCUAddrEntropySlice = 0;
445	uiNextCUAddr = 0;
446	pcSlice = pcPic->getSlice(uiStartCUAddrSliceIdx);
447	while (uiNextCUAddr < pcPic->getPicSym()->getNumberOfCUsInFrame()) // Iterate over all slices
448	{
449	pcSlice->setNextSlice ( false );
450	pcSlice->setNextEntropySlice( false );
451	if (uiNextCUAddr == m_uiStoredStartCUAddrForEncodingSlice[uiStartCUAddrSliceIdx])
452	{
453	pcSlice = pcPic->getSlice(uiStartCUAddrSliceIdx);
454	pcPic->setCurrSliceIdx(uiStartCUAddrSliceIdx);
455	m_pcSliceEncoder->setSliceIdx(uiStartCUAddrSliceIdx);
456	assert(uiStartCUAddrSliceIdx == pcSlice->getSliceIdx());
457	// Reconstruction slice
458	pcSlice->setSliceCurStartCUAddr( uiNextCUAddr ); // to be used in encodeSlice() + context restriction
459	pcSlice->setSliceCurEndCUAddr ( m_uiStoredStartCUAddrForEncodingSlice[uiStartCUAddrSliceIdx+1 ] );
460	// Entropy slice
461	pcSlice->setEntropySliceCurStartCUAddr( uiNextCUAddr ); // to be used in encodeSlice() + context restriction
462	pcSlice->setEntropySliceCurEndCUAddr ( m_uiStoredStartCUAddrForEncodingEntropySlice[uiStartCUAddrEntropySliceIdx+1 ] );
463
464	pcSlice->setNextSlice ( true );
465
466	uiStartCUAddrSliceIdx++;
467	uiStartCUAddrEntropySliceIdx++;
468	}
469	else if (uiNextCUAddr == m_uiStoredStartCUAddrForEncodingEntropySlice[uiStartCUAddrEntropySliceIdx])
470	{
471	// Entropy slice
472	pcSlice->setEntropySliceCurStartCUAddr( uiNextCUAddr ); // to be used in encodeSlice() + context restriction
473	pcSlice->setEntropySliceCurEndCUAddr ( m_uiStoredStartCUAddrForEncodingEntropySlice[uiStartCUAddrEntropySliceIdx+1 ] );
474
475	pcSlice->setNextEntropySlice( true );
476
477	uiStartCUAddrEntropySliceIdx++;
478	}
479
480	// Get ready for writing slice header (other than the first one in the picture)
481	if (uiNextCUAddr!=0)
482	{
483	m_pcEntropyCoder->setEntropyCoder ( m_pcCavlcCoder, pcSlice );
484	m_pcEntropyCoder->setBitstream ( pcBitstreamOut );
485	m_pcEntropyCoder->resetEntropy ();
486	}
487
488	// write SliceHeader
489	m_pcEntropyCoder->encodeSliceHeader ( pcSlice );
490
491	// is it needed?
492	if ( pcSlice->getSymbolMode() )
493	{
494	m_pcSbacCoder->init( (TEncBinIf*)m_pcBinCABAC );
495	m_pcEntropyCoder->setEntropyCoder ( m_pcSbacCoder, pcSlice );
496	m_pcEntropyCoder->resetEntropy ();
497	}
498
499	if (uiNextCUAddr==0) // Compute ALF params and write only for first slice header
500	{
501	// adaptive loop filter
502	#if MTK_SAO
503	if ( pcSlice->getSPS()->getUseALF() \|\| (pcSlice->getSPS()->getUseSAO()) )
504	#else
505	if ( pcSlice->getSPS()->getUseALF())
506	#endif
507	{
508	ALFParam cAlfParam;
509	#if TSB_ALF_HEADER
510	m_pcAdaptiveLoopFilter->setNumCUsInFrame(pcPic);
511	#endif
512	m_pcAdaptiveLoopFilter->allocALFParam(&cAlfParam);
513
514	// set entropy coder for RD
515	if ( pcSlice->getSymbolMode() )
516	{
517	m_pcEntropyCoder->setEntropyCoder ( m_pcEncTop->getRDGoOnSbacCoder(), pcSlice );
518	}
519	else
520	{
521	m_pcEntropyCoder->setEntropyCoder ( m_pcCavlcCoder, pcSlice );
522	}
523	m_pcEntropyCoder->resetEntropy ();
524	m_pcEntropyCoder->setBitstream ( m_pcBitCounter );
525
526	m_pcAdaptiveLoopFilter->startALFEnc(pcPic, m_pcEntropyCoder );
527	#if MTK_SAO // PostDF
528	{
529	if (pcSlice->getSPS()->getUseSAO())
530	{
531	m_pcSAO->startSaoEnc(pcPic, m_pcEntropyCoder, m_pcEncTop->getRDSbacCoder(), m_pcCfg->getUseSBACRD() ? m_pcEncTop->getRDGoOnSbacCoder() : NULL);
532	m_pcSAO->SAOProcess(pcPic->getSlice(0)->getLambda());
533	m_pcSAO->copyQaoData(&cSaoParam);
534	m_pcSAO->endSaoEnc();
535	}
536	}
537	#endif
538	UInt uiMaxAlfCtrlDepth;
539
540	UInt64 uiDist, uiBits;
541	#if MTK_SAO
542	if ( pcSlice->getSPS()->getUseALF())
543	#endif
544	m_pcAdaptiveLoopFilter->ALFProcess( &cAlfParam, pcPic->getSlice(0)->getLambda(), uiDist, uiBits, uiMaxAlfCtrlDepth );
545	#if MTK_SAO
546	else
547	cAlfParam.cu_control_flag = 0;
548	#endif
549	m_pcAdaptiveLoopFilter->endALFEnc();
550
551	// set entropy coder for writing
552	m_pcSbacCoder->init( (TEncBinIf*)m_pcBinCABAC );
553	if ( pcSlice->getSymbolMode() )
554	{
555	m_pcEntropyCoder->setEntropyCoder ( m_pcSbacCoder, pcSlice );
556	}
557	else
558	{
559	m_pcEntropyCoder->setEntropyCoder ( m_pcCavlcCoder, pcSlice );
560	}
561	m_pcEntropyCoder->resetEntropy ();
562	m_pcEntropyCoder->setBitstream ( pcBitstreamOut );
563	if (cAlfParam.cu_control_flag)
564	{
565	m_pcEntropyCoder->setAlfCtrl( true );
566	m_pcEntropyCoder->setMaxAlfCtrlDepth(uiMaxAlfCtrlDepth);
567	if (pcSlice->getSymbolMode() == 0)
568	{
569	m_pcCavlcCoder->setAlfCtrl(true);
570	m_pcCavlcCoder->setMaxAlfCtrlDepth(uiMaxAlfCtrlDepth); //D0201
571	}
572	}
573	else
574	{
575	m_pcEntropyCoder->setAlfCtrl(false);
576	}
577	#if MTK_SAO
578	if (pcSlice->getSPS()->getUseSAO())
579	{
580	m_pcEntropyCoder->encodeSaoParam(&cSaoParam);
581	}
582	if (pcSlice->getSPS()->getUseALF())
583	#endif
584	m_pcEntropyCoder->encodeAlfParam(&cAlfParam);
585
586	#if TSB_ALF_HEADER
587	if(cAlfParam.cu_control_flag)
588	{
589	m_pcEntropyCoder->encodeAlfCtrlParam(&cAlfParam);
590	}
591	#endif
592	m_pcAdaptiveLoopFilter->freeALFParam(&cAlfParam);
593	}
594	}
595
596	// File writing
597	m_pcSliceEncoder->encodeSlice( pcPic, pcBitstreamOut );
598
599	// End of bitstream & byte align
600	pcBitstreamOut->write( 1, 1 );
601	pcBitstreamOut->writeAlignZero();
602
603	UInt uiBoundingAddrSlice, uiBoundingAddrEntropySlice;
604	uiBoundingAddrSlice = m_uiStoredStartCUAddrForEncodingSlice[uiStartCUAddrSliceIdx];
605	uiBoundingAddrEntropySlice = m_uiStoredStartCUAddrForEncodingEntropySlice[uiStartCUAddrEntropySliceIdx];
606	uiNextCUAddr = min(uiBoundingAddrSlice, uiBoundingAddrEntropySlice);
607	if (uiNextCUAddr < pcPic->getPicSym()->getNumberOfCUsInFrame()) // if more slices to be encoded insert start code
608	{
609	UInt uiSliceCount = pcBitstreamOut->getSliceCount();
610	pcBitstreamOut->setSliceByteLocation( uiSliceCount, (pcBitstreamOut->getNumberOfWrittenBits()>>3) );
611	pcBitstreamOut->setSliceCount( uiSliceCount+1 );
612	pcBitstreamOut->write( 1, 32);
613	}
614	} // end iteration over slices
615
616
617	#if MTK_NONCROSS_INLOOP_FILTER
618	if(pcSlice->getSPS()->getUseALF())
619	{
620	if(m_pcAdaptiveLoopFilter->getUseNonCrossAlf())
621	m_pcAdaptiveLoopFilter->destroySlice();
622	}
623	#endif
624
625
626	pcBitstreamOut->flushBuffer();
627	pcBitstreamOut->convertRBSPToPayload(0);
628
629	#if POZNAN_MP
630	//pcSlice->getMP()->disable();
631	#endif
632
633	/*#if AMVP_BUFFERCOMPRESS
634	pcPic->compressMotion(); // moved to end of access unit
635	#endif */
636	pcBitstreamOut->freeMemoryAllocatedForSliceLocations();
637
638	//-- For time output for each slice
639	Double dEncTime = (double)(clock()-iBeforeTime) / CLOCKS_PER_SEC;
640
641	xCalculateAddPSNR( pcPic, pcPic->getPicYuvRec(), pcBitstreamOut->getNumberOfWrittenBits(), dEncTime );
642
643	#if FIXED_ROUNDING_FRAME_MEMORY
644	pcPic->getPicYuvRec()->xFixedRoundingPic();
645	#endif
646
647	if (m_pcCfg->getPictureDigestEnabled()) {
648	/* calculate MD5sum for entire reconstructed picture */
649	SEIpictureDigest sei_recon_picture_digest;
650	sei_recon_picture_digest.method = SEIpictureDigest::MD5;
651	calcMD5(*pcPic->getPicYuvRec(), sei_recon_picture_digest.digest);
652	printf("[MD5:%s] ", digestToString(sei_recon_picture_digest.digest));
653
654	TComBitstream seiBs;
655	seiBs.create(1024);
656	/* write the SEI messages */
657	m_pcEntropyCoder->setEntropyCoder(m_pcCavlcCoder, pcSlice);
658	m_pcEntropyCoder->setBitstream(&seiBs);
659	m_pcEntropyCoder->encodeSEI(sei_recon_picture_digest);
660	/* and trailing bits */
661	seiBs.write(1, 1);
662	seiBs.writeAlignZero();
663	seiBs.flushBuffer();
664	seiBs.convertRBSPToPayload(0);
665
666	/* append the SEI message after any SPS/PPS */
667	/* the following loop is a work around current limitations in
668	* TComBitstream that won't be fixed before HM-3.0 */
669	UChar seiData = reinterpret_cast<UChar >(seiBs.getStartStream());
670	for (Int i = 0; i < seiBs.getNumberOfWrittenBits()/8; i++)
671	{
672	bs_SPS_PPS_SEI.write(seiData[i], 8);
673	}
674	bs_SPS_PPS_SEI.write(1, 32);
675	seiBs.destroy();
676	}
677
678	/* insert the bs_SPS_PPS_SEI before the pcBitstreamOut */
679	bs_SPS_PPS_SEI.flushBuffer();
680	pcBitstreamOut->insertAt(bs_SPS_PPS_SEI, 0);
681
682	bs_SPS_PPS_SEI.destroy();
683	pcPic->getPicYuvRec()->copyToPic(pcPicYuvRecOut);
684
685	pcPic->setReconMark ( true );
686
687	}
688
689	Void TEncPic::preLoopFilterPicAll( TComPic* pcPic, UInt64& ruiDist, UInt64& ruiBits )
690	{
691	TComSlice* pcSlice = pcPic->getSlice(pcPic->getCurrSliceIdx());
692	Bool bCalcDist = false;
693
694	m_pcLoopFilter->setCfg(pcSlice->getLoopFilterDisable(), m_pcCfg->getLoopFilterAlphaC0Offget(), m_pcCfg->getLoopFilterBetaOffget());
695	m_pcLoopFilter->loopFilterPic( pcPic );
696
697	m_pcEntropyCoder->setEntropyCoder ( m_pcEncTop->getRDGoOnSbacCoder(), pcSlice );
698	m_pcEntropyCoder->resetEntropy ();
699	m_pcEntropyCoder->setBitstream ( m_pcBitCounter );
700
701	// Adaptive Loop filter
702	if( pcSlice->getSPS()->getUseALF() )
703	{
704	ALFParam cAlfParam;
705	#if TSB_ALF_HEADER
706	m_pcAdaptiveLoopFilter->setNumCUsInFrame(pcPic);
707	#endif
708	m_pcAdaptiveLoopFilter->allocALFParam(&cAlfParam);
709
710	m_pcAdaptiveLoopFilter->startALFEnc(pcPic, m_pcEntropyCoder);
711
712	UInt uiMaxAlfCtrlDepth;
713	m_pcAdaptiveLoopFilter->ALFProcess(&cAlfParam, pcSlice->getLambda(), ruiDist, ruiBits, uiMaxAlfCtrlDepth );
714	m_pcAdaptiveLoopFilter->endALFEnc();
715	m_pcAdaptiveLoopFilter->freeALFParam(&cAlfParam);
716	}
717
718	m_pcEntropyCoder->resetEntropy ();
719	ruiBits += m_pcEntropyCoder->getNumberOfWrittenBits();
720
721	if (!bCalcDist)
722	ruiDist = xFindDistortionFrame(pcPic->getPicYuvOrg(), pcPic->getPicYuvRec());
723	}
724
725	// ====================================================================================================================
726	// Protected member functions
727	// ====================================================================================================================
728
729	UInt64 TEncPic::xFindDistortionFrame (TComPicYuv* pcPic0, TComPicYuv* pcPic1)
730	{
731	Int x, y;
732	Pel* pSrc0 = pcPic0 ->getLumaAddr();
733	Pel* pSrc1 = pcPic1 ->getLumaAddr();
734	#if IBDI_DISTORTION
735	Int iShift = g_uiBitIncrement;
736	Int iOffset = 1<<(g_uiBitIncrement-1);
737	#else
738	UInt uiShift = g_uiBitIncrement<<1;
739	#endif
740	Int iTemp;
741
742	Int iStride = pcPic0->getStride();
743	Int iWidth = pcPic0->getWidth();
744	Int iHeight = pcPic0->getHeight();
745
746	UInt64 uiTotalDiff = 0;
747
748	for( y = 0; y < iHeight; y++ )
749	{
750	for( x = 0; x < iWidth; x++ )
751	{
752	#if IBDI_DISTORTION
753	iTemp = ((pSrc0[x]+iOffset)>>iShift) - ((pSrc1[x]+iOffset)>>iShift); uiTotalDiff += iTemp * iTemp;
754	#else
755	iTemp = pSrc0[x] - pSrc1[x]; uiTotalDiff += (iTemp*iTemp) >> uiShift;
756	#endif
757	}
758	pSrc0 += iStride;
759	pSrc1 += iStride;
760	}
761
762	iHeight >>= 1;
763	iWidth >>= 1;
764	iStride >>= 1;
765
766	pSrc0 = pcPic0->getCbAddr();
767	pSrc1 = pcPic1->getCbAddr();
768
769	for( y = 0; y < iHeight; y++ )
770	{
771	for( x = 0; x < iWidth; x++ )
772	{
773	#if IBDI_DISTORTION
774	iTemp = ((pSrc0[x]+iOffset)>>iShift) - ((pSrc1[x]+iOffset)>>iShift); uiTotalDiff += iTemp * iTemp;
775	#else
776	iTemp = pSrc0[x] - pSrc1[x]; uiTotalDiff += (iTemp*iTemp) >> uiShift;
777	#endif
778	}
779	pSrc0 += iStride;
780	pSrc1 += iStride;
781	}
782
783	pSrc0 = pcPic0->getCrAddr();
784	pSrc1 = pcPic1->getCrAddr();
785
786	for( y = 0; y < iHeight; y++ )
787	{
788	for( x = 0; x < iWidth; x++ )
789	{
790	#if IBDI_DISTORTION
791	iTemp = ((pSrc0[x]+iOffset)>>iShift) - ((pSrc1[x]+iOffset)>>iShift); uiTotalDiff += iTemp * iTemp;
792	#else
793	iTemp = pSrc0[x] - pSrc1[x]; uiTotalDiff += (iTemp*iTemp) >> uiShift;
794	#endif
795	}
796	pSrc0 += iStride;
797	pSrc1 += iStride;
798	}
799
800	return uiTotalDiff;
801	}
802
803	Void TEncPic::xCalculateAddPSNR( TComPic* pcPic, TComPicYuv* pcPicD, UInt uibits, Double dEncTime )
804	{
805	Int x, y;
806	UInt64 uiSSDY = 0;
807	UInt64 uiSSDU = 0;
808	UInt64 uiSSDV = 0;
809
810	Double dYPSNR = 0.0;
811	Double dUPSNR = 0.0;
812	Double dVPSNR = 0.0;
813
814	//===== calculate PSNR =====
815	Pel* pOrg = pcPic ->getPicYuvOrg()->getLumaAddr();
816	Pel* pRec = pcPicD->getLumaAddr();
817	#if POZNAN_CU_SKIP_PSNR
818	Pel* pAvail = NULL;
819	if(pcPic ->getPicYuvAvail())
820	pAvail = pcPic ->getPicYuvAvail()->getLumaAddr();
821	UInt64 iPixelsCnt = 0;
822	#endif
823	Int iStride = pcPicD->getStride();
824
825	Int iWidth;
826	Int iHeight;
827
828	iWidth = pcPicD->getWidth () - m_pcEncTop->getPad(0);
829	iHeight = pcPicD->getHeight() - m_pcEncTop->getPad(1);
830
831	Int iSize = iWidth*iHeight;
832
833	UInt maxval = 255 * (1<<(g_uiBitDepth + g_uiBitIncrement -8));
834	Double fRefValueY = (double) maxval * maxval * iSize;
835	Double fRefValueC = fRefValueY / 4.0;
836
837	#if POZNAN_CU_SKIP_PSNR
838	if(pAvail)
839	{
840	for( y = 0; y < iHeight; y++ )
841	{
842	for( x = 0; x < iWidth; x++ )
843	{
844	if(pAvail[x]==0) //If pixel was codded
845	{
846	Int iDiff = (Int)( pOrg[x] - pRec[x] );
847	uiSSDY += iDiff * iDiff;
848	iPixelsCnt++;
849	}
850	}
851	pOrg += iStride;
852	pRec += iStride;
853	pAvail+=iStride;
854	}
855
856	fRefValueY = (double) maxval * maxval * iPixelsCnt;
857	}
858	else
859	#endif
860	{
861	for( y = 0; y < iHeight; y++ )
862	{
863	for( x = 0; x < iWidth; x++ )
864	{
865	Int iDiff = (Int)( pOrg[x] - pRec[x] );
866	uiSSDY += iDiff * iDiff;
867	}
868	pOrg += iStride;
869	pRec += iStride;
870	}
871	}
872
873	#if HHI_VSO
874	if ( m_pcRdCost->getUseRenModel() )
875	{
876	TRenModel* pcRenModel = m_pcEncTop->getEncTop()->getRenModel();
877	Int64 iDistVSOY, iDistVSOU, iDistVSOV;
878	pcRenModel->getTotalSSE( iDistVSOY, iDistVSOU, iDistVSOV );
879	dYPSNR = ( iDistVSOY ? 10.0 * log10( fRefValueY / (Double) iDistVSOY ) : 99.99 );
880	dUPSNR = ( iDistVSOU ? 10.0 * log10( fRefValueC / (Double) iDistVSOU ) : 99.99 );
881	dVPSNR = ( iDistVSOV ? 10.0 * log10( fRefValueC / (Double) iDistVSOV ) : 99.99 );
882	}
883	else
884	#endif
885	{
886	#if POZNAN_CU_SKIP_PSNR
887	if(pAvail)
888	{
889	iHeight >>= 1;
890	iWidth >>= 1;
891	iStride >>= 1;
892
893	pOrg = pcPic ->getPicYuvOrg()->getCbAddr();
894	pRec = pcPicD->getCbAddr();
895	pAvail = pcPic ->getPicYuvAvail()->getLumaAddr();
896	iPixelsCnt = 0;
897
898	for( y = 0; y < iHeight; y++ )
899	{
900	for( x = 0; x < iWidth; x++ )
901	{
902	if(pAvail[x<<1]==0\|\|pAvail[(x<<1)+1]==0\|\|
903	pAvail[(x+iStride)<<1]==0\|\|pAvail[((x+iStride)<<1)+1]==0) //If pixel was codded
904	{
905	Int iDiff = (Int)( pOrg[x] - pRec[x] );
906	uiSSDU += iDiff * iDiff;
907	iPixelsCnt++;
908	}
909	}
910	pOrg += iStride;
911	pRec += iStride;
912	pAvail+= (iStride<<2);
913	}
914
915	fRefValueC = (double) maxval * maxval * iPixelsCnt;
916
917	pOrg = pcPic ->getPicYuvOrg()->getCrAddr();
918	pRec = pcPicD->getCrAddr();
919	pAvail = pcPic ->getPicYuvAvail()->getLumaAddr();
920	for( y = 0; y < iHeight; y++ )
921	{
922	for( x = 0; x < iWidth; x++ )
923	{
924	if(pAvail[x<<1]==0\|\|pAvail[(x<<1)+1]==0\|\|
925	pAvail[(x+iStride)<<1]==0\|\|pAvail[((x+iStride)<<1)+1]==0) //If pixel was codded
926	{
927	Int iDiff = (Int)( pOrg[x] - pRec[x] );
928	uiSSDV += iDiff * iDiff;
929	}
930	}
931	pOrg += iStride;
932	pRec += iStride;
933	pAvail+= iStride<<2;
934	}
935	}
936	else
937	#endif
938	{
939	iHeight >>= 1;
940	iWidth >>= 1;
941	iStride >>= 1;
942	pOrg = pcPic ->getPicYuvOrg()->getCbAddr();
943	pRec = pcPicD->getCbAddr();
944
945	for( y = 0; y < iHeight; y++ )
946	{
947	for( x = 0; x < iWidth; x++ )
948	{
949	Int iDiff = (Int)( pOrg[x] - pRec[x] );
950	uiSSDU += iDiff * iDiff;
951	}
952	pOrg += iStride;
953	pRec += iStride;
954	}
955
956	pOrg = pcPic ->getPicYuvOrg()->getCrAddr();
957	pRec = pcPicD->getCrAddr();
958
959	for( y = 0; y < iHeight; y++ )
960	{
961	for( x = 0; x < iWidth; x++ )
962	{
963	Int iDiff = (Int)( pOrg[x] - pRec[x] );
964	uiSSDV += iDiff * iDiff;
965	}
966	pOrg += iStride;
967	pRec += iStride;
968	}
969	}
970
971	dYPSNR = ( uiSSDY ? 10.0 * log10( fRefValueY / (Double)uiSSDY ) : 99.99 );
972	dUPSNR = ( uiSSDU ? 10.0 * log10( fRefValueC / (Double)uiSSDU ) : 99.99 );
973	dVPSNR = ( uiSSDV ? 10.0 * log10( fRefValueC / (Double)uiSSDV ) : 99.99 );
974	}
975	// fix: total bits should consider slice size bits (32bit)
976	uibits += 32;
977
978	#if RVM_VCEGAM10
979	m_vRVM_RP.push_back( uibits );
980	#endif
981
982	//===== add PSNR =====
983	m_pcEncTop->m_cAnalyzeAll.addResult (dYPSNR, dUPSNR, dVPSNR, (Double)uibits);
984	TComSlice* pcSlice = pcPic->getSlice(0);
985	if (pcSlice->isIntra())
986	{
987	m_pcEncTop->m_cAnalyzeI.addResult (dYPSNR, dUPSNR, dVPSNR, (Double)uibits);
988	}
989	if (pcSlice->isInterP())
990	{
991	m_pcEncTop->m_cAnalyzeP.addResult (dYPSNR, dUPSNR, dVPSNR, (Double)uibits);
992	}
993	if (pcSlice->isInterB())
994	{
995	m_pcEncTop->m_cAnalyzeB.addResult (dYPSNR, dUPSNR, dVPSNR, (Double)uibits);
996	}
997	if(pcPic->getViewIdx()!=-1)
998	{
999	if(! m_pcEncTop->isDepthCoder())
1000	{
1001	printf("\nView \t\t%2d\t POC %4d ( %c-SLICE, QP %d ) %10d bits ",
1002	pcSlice->getViewIdx(),
1003	pcSlice->getPOC(),
1004	pcSlice->isIntra() ? 'I' : pcSlice->isInterP() ? 'P' : 'B',
1005	pcSlice->getSliceQp(),
1006	uibits );
1007	}
1008	else
1009	{
1010	printf("\nDepth View \t%2d\t POC %4d ( %c-SLICE, QP %d ) %10d bits ",
1011	pcSlice->getViewIdx(),
1012	pcSlice->getPOC(),
1013	pcSlice->isIntra() ? 'I' : pcSlice->isInterP() ? 'P' : 'B',
1014	pcSlice->getSliceQp(),
1015	uibits );
1016	}
1017	}
1018	else
1019	{
1020	printf("\nPOC %4d ( %c-SLICE, QP %d ) %10d bits ",
1021	pcSlice->getPOC(),
1022	pcSlice->isIntra() ? 'I' : pcSlice->isInterP() ? 'P' : 'B',
1023	pcSlice->getSliceQp(),
1024	uibits );
1025	}
1026
1027	printf( "[Y %6.4lf dB U %6.4lf dB V %6.4lf dB] ", dYPSNR, dUPSNR, dVPSNR );
1028	printf ("[ET %5.0f ] ", dEncTime );
1029
1030	for (Int iRefList = 0; iRefList < 2; iRefList++)
1031	{
1032	printf ("[L%d ", iRefList);
1033	for (Int iRefIndex = 0; iRefIndex < pcSlice->getNumRefIdx(RefPicList(iRefList)); iRefIndex++)
1034	{
1035	if( pcSlice->getViewIdx() != pcSlice->getRefViewIdx( RefPicList(iRefList), iRefIndex ) )
1036	{
1037	printf( "V%d", pcSlice->getRefViewIdx( RefPicList(iRefList), iRefIndex ) );
1038	if( pcSlice->getPOC() != pcSlice->getRefPOC( RefPicList(iRefList), iRefIndex ) )
1039	printf( "(%d)", pcSlice->getRefPOC( RefPicList(iRefList), iRefIndex ) );
1040	printf( " " );
1041	}
1042	else
1043	printf ("%d ", pcSlice->getRefPOC(RefPicList(iRefList), iRefIndex));
1044	}
1045	printf ("] ");
1046	}
1047	#if DCM_COMB_LIST
1048	if(pcSlice->getNumRefIdx(REF_PIC_LIST_C)>0 && !pcSlice->getNoBackPredFlag())
1049	{
1050	printf ("[LC ");
1051	for (Int iRefIndex = 0; iRefIndex < pcSlice->getNumRefIdx(REF_PIC_LIST_C); iRefIndex++)
1052	{
1053	printf ("%d ", pcSlice->getRefPOC((RefPicList)pcSlice->getListIdFromIdxOfLC(iRefIndex), pcSlice->getRefIdxFromIdxOfLC(iRefIndex)));
1054	}
1055	printf ("] ");
1056	}
1057	#endif
1058
1059	fflush(stdout);
1060	}
1061
1062	#if DCM_DECODING_REFRESH
1063	/** Function for deciding the nal_unit_type.
1064	* \param uiPOCCurr POC of the current picture
1065	* \returns the nal_unit type of the picture
1066	* This function checks the configuration and returns the appropriate nal_unit_type for the picture.
1067	*/
1068	NalUnitType TEncPic::getNalUnitType(UInt uiPOCCurr)
1069	{
1070	if (uiPOCCurr == 0)
1071	{
1072	return NAL_UNIT_CODED_SLICE_IDR;
1073	}
1074	#if 0
1075	if (uiPOCCurr % m_pcCfg->getIntraPeriod() == 0)
1076	{
1077	if (m_pcCfg->getDecodingRefreshType() == 1)
1078	{
1079	return NAL_UNIT_CODED_SLICE_CDR;
1080	}
1081	else if (m_pcCfg->getDecodingRefreshType() == 2)
1082	{
1083	return NAL_UNIT_CODED_SLICE_IDR;
1084	}
1085	}
1086	#endif
1087	return NAL_UNIT_CODED_SLICE;
1088	}
1089	#endif
1090
1091	#if RVM_VCEGAM10
1092	Double TEncPic::xCalculateRVM()
1093	{
1094	Double dRVM = 0;
1095
1096	//if( m_pcCfg->getGOPSize() == 1 && m_pcCfg->getIntraPeriod() != 1 && m_pcCfg->getFrameToBeEncoded() > RVM_VCEGAM10_M * 2 )
1097	{
1098	// calculate RVM only for lowdelay configurations
1099	std::vector<Double> vRL , vB;
1100	size_t N = m_vRVM_RP.size();
1101	vRL.resize( N );
1102	vB.resize( N );
1103
1104	Int i;
1105	Double dRavg = 0 , dBavg = 0;
1106	vB[RVM_VCEGAM10_M] = 0;
1107	for( i = RVM_VCEGAM10_M + 1 ; i < N - RVM_VCEGAM10_M + 1 ; i++ )
1108	{
1109	vRL[i] = 0;
1110	for( Int j = i - RVM_VCEGAM10_M ; j <= i + RVM_VCEGAM10_M - 1 ; j++ )
1111	vRL[i] += m_vRVM_RP[j];
1112	vRL[i] /= ( 2 * RVM_VCEGAM10_M );
1113	vB[i] = vB[i-1] + m_vRVM_RP[i] - vRL[i];
1114	dRavg += m_vRVM_RP[i];
1115	dBavg += vB[i];
1116	}
1117
1118	dRavg /= ( N - 2 * RVM_VCEGAM10_M );
1119	dBavg /= ( N - 2 * RVM_VCEGAM10_M );
1120
1121	double dSigamB = 0;
1122	for( i = RVM_VCEGAM10_M + 1 ; i < N - RVM_VCEGAM10_M + 1 ; i++ )
1123	{
1124	Double tmp = vB[i] - dBavg;
1125	dSigamB += tmp * tmp;
1126	}
1127	dSigamB = sqrt( dSigamB / ( N - 2 * RVM_VCEGAM10_M ) );
1128
1129	double f = sqrt( 12.0 * ( RVM_VCEGAM10_M - 1 ) / ( RVM_VCEGAM10_M + 1 ) );
1130
1131	dRVM = dSigamB / dRavg * f;
1132	}
1133
1134	return( dRVM );
1135	}
1136	#endif
1137

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

Download in other formats: