source: 3DVCSoftware/branches/HTM-5.0-Sony/source/App/TAppEncoder/TAppEncTop.cpp @ 197

Last change on this file since 197 was 197, checked in by sony, 12 years ago

Add DV_V_RESTRICTION_B0037 macro and two config parameters (DisparitySearchRangeRestriction, VerticalDisparitySearchRange).

It enables to restrict disparity vector range at encoder on motion search.
When users want to try the option, please set DisparitySearchRangeRestriction to 1 and set VerticalDisparitySearchRange to any positive integer value to be tested. The restriction is disabled by default.

  • Property svn:eol-style set to native
File size: 63.1 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-2012, ITU/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 ITU/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/** \file     TAppEncTop.cpp
35    \brief    Encoder application class
36*/
37
38#include <list>
39#include <fstream>
40#include <stdlib.h>
41#include <stdio.h>
42#include <fcntl.h>
43#include <assert.h>
44
45#include "TAppEncTop.h"
46#include "TLibEncoder/AnnexBwrite.h"
47
48using namespace std;
49
50//! \ingroup TAppEncoder
51//! \{
52
53// ====================================================================================================================
54// Constructor / destructor / initialization / destroy
55// ====================================================================================================================
56
57TAppEncTop::TAppEncTop()
58{
59  m_totalBytes = 0;
60  m_essentialBytes = 0;
61}
62
63TAppEncTop::~TAppEncTop()
64{
65}
66
67Void TAppEncTop::xInitLibCfg()
68{
69#if VIDYO_VPS_INTEGRATION|QC_MVHEVC_B0046
70#if !QC_MVHEVC_B0046
71  UInt layerId = 0;
72#endif
73  // TODO: fix the assumption here that the temporal structures are all equal across all layers???
74  m_cVPS.setMaxTLayers( m_maxTempLayer[0] );
75#if QC_MVHEVC_B0046
76  m_cVPS.setMaxLayers( m_iNumberOfViews );
77#else
78  m_cVPS.setMaxLayers( m_iNumberOfViews * (m_bUsingDepthMaps ? 2:1) );
79#endif
80  for(Int i = 0; i < MAX_TLAYER; i++)
81  {
82    m_cVPS.setNumReorderPics( m_numReorderPics[0][i], i );
83    m_cVPS.setMaxDecPicBuffering( m_maxDecPicBuffering[0][i], i );
84  }
85#endif
86 
87  for(Int iViewIdx=0; iViewIdx<m_iNumberOfViews; iViewIdx++)
88  {
89    m_frameRcvd.push_back(0);
90    m_acTEncTopList.push_back(new TEncTop); 
91    m_acTVideoIOYuvInputFileList.push_back(new TVideoIOYuv);
92    m_acTVideoIOYuvReconFileList.push_back(new TVideoIOYuv);
93    m_picYuvRec.push_back(new TComList<TComPicYuv*>) ;
94
95    m_acTEncTopList[iViewIdx]->setFrameRate                    ( m_iFrameRate );
96    m_acTEncTopList[iViewIdx]->setFrameSkip                    ( m_FrameSkip );
97    m_acTEncTopList[iViewIdx]->setSourceWidth                  ( m_iSourceWidth );
98    m_acTEncTopList[iViewIdx]->setSourceHeight                 ( m_iSourceHeight );
99#if PIC_CROPPING
100    m_acTEncTopList[iViewIdx]->setCroppingMode                 ( m_croppingMode );
101    m_acTEncTopList[iViewIdx]->setCropLeft                     ( m_cropLeft );
102    m_acTEncTopList[iViewIdx]->setCropRight                    ( m_cropRight );
103    m_acTEncTopList[iViewIdx]->setCropTop                      ( m_cropTop );
104    m_acTEncTopList[iViewIdx]->setCropBottom                   ( m_cropBottom );
105#endif
106    m_acTEncTopList[iViewIdx]->setFrameToBeEncoded             ( m_iFrameToBeEncoded );
107    m_acTEncTopList[iViewIdx]->setViewId                       ( iViewIdx );
108    m_acTEncTopList[iViewIdx]->setIsDepth                      ( false );
109#if QC_MVHEVC_B0046
110    m_acTEncTopList[iViewIdx]->setLayerId                      ( iViewIdx );
111    m_cVPS.setViewId                                           ( m_aiVId[ iViewIdx ], iViewIdx );
112#else
113    m_acTEncTopList[iViewIdx]->setViewOrderIdx                 ( m_cCameraData.getViewOrderIndex()[ iViewIdx ] );
114#if VIDYO_VPS_INTEGRATION
115    layerId = iViewIdx * (m_bUsingDepthMaps ? 2:1);
116    m_acTEncTopList[iViewIdx]->setLayerId                      ( layerId );
117    m_cVPS.setDepthFlag                                        ( false, layerId );
118    m_cVPS.setViewId                                           ( iViewIdx, layerId );
119    m_cVPS.setViewOrderIdx                                     ( m_cCameraData.getViewOrderIndex()[ iViewIdx ], layerId );
120    // TODO: set correct dependentFlag and dependentLayer
121    m_cVPS.setDependentFlag                                    ( iViewIdx ? true:false, layerId );
122    m_cVPS.setDependentLayer                                   ( layerId - (m_bUsingDepthMaps ? 2:1), layerId );
123#endif
124   
125    m_acTEncTopList[iViewIdx]->setCamParPrecision              ( m_cCameraData.getCamParsCodedPrecision  () );
126    m_acTEncTopList[iViewIdx]->setCamParInSliceHeader          ( m_cCameraData.getVaryingCameraParameters() );
127    m_acTEncTopList[iViewIdx]->setCodedScale                   ( m_cCameraData.getCodedScale             () );
128    m_acTEncTopList[iViewIdx]->setCodedOffset                  ( m_cCameraData.getCodedOffset            () );
129#endif   
130
131  //====== Coding Structure ========
132    m_acTEncTopList[iViewIdx]->setIntraPeriod                  ( m_iIntraPeriod );
133    m_acTEncTopList[iViewIdx]->setDecodingRefreshType          ( m_iDecodingRefreshType );
134    m_acTEncTopList[iViewIdx]->setGOPSize                      ( m_iGOPSize );
135    m_acTEncTopList[iViewIdx]->setGopList                      ( m_GOPListsMvc[iViewIdx] );
136    m_acTEncTopList[iViewIdx]->setExtraRPSs                    ( m_extraRPSs[iViewIdx] );
137#if H0567_DPB_PARAMETERS_PER_TEMPORAL_LAYER
138    for(Int i = 0; i < MAX_TLAYER; i++)
139    {
140      m_acTEncTopList[iViewIdx]->setNumReorderPics             ( m_numReorderPics[iViewIdx][i], i );
141      m_acTEncTopList[iViewIdx]->setMaxDecPicBuffering         ( m_maxDecPicBuffering[iViewIdx][i], i );
142    }
143#else
144    m_acTEncTopList[iViewIdx]->setNumReorderFrames             ( m_numReorderFrames );
145    m_acTEncTopList[iViewIdx]->setMaxNumberOfReferencePictures ( m_maxNumberOfReferencePictures );
146#endif
147    for( UInt uiLoop = 0; uiLoop < MAX_TLAYER; ++uiLoop )
148    {
149      m_acTEncTopList[iViewIdx]->setLambdaModifier( uiLoop, m_adLambdaModifier[ uiLoop ] );
150    }
151    m_acTEncTopList[iViewIdx]->setQP                           ( m_aiQP[0] );
152 
153    m_acTEncTopList[iViewIdx]->setTemporalLayerQPOffset        ( m_aiTLayerQPOffset );
154    m_acTEncTopList[iViewIdx]->setPad                          ( m_aiPad );
155   
156#if H0566_TLA
157    m_acTEncTopList[iViewIdx]->setMaxTempLayer                 ( m_maxTempLayer[iViewIdx] );
158#else
159    m_acTEncTopList[iViewIdx]->setTLayering                    ( m_bTLayering );
160    m_acTEncTopList[iViewIdx]->setTLayerSwitchingFlag          ( m_abTLayerSwitchingFlag );
161#endif
162
163    m_acTEncTopList[iViewIdx]->setDisInter4x4                  ( m_bDisInter4x4);
164 
165    m_acTEncTopList[iViewIdx]->setUseNSQT( m_enableNSQT );
166    m_acTEncTopList[iViewIdx]->setUseAMP( m_enableAMP );
167 
168  //===== Slice ========
169 
170  //====== Loop/Deblock Filter ========
171    m_acTEncTopList[iViewIdx]->setLoopFilterDisable            ( m_abLoopFilterDisable[0]       );
172    m_acTEncTopList[iViewIdx]->setLoopFilterOffsetInAPS        ( m_loopFilterOffsetInAPS );
173    m_acTEncTopList[iViewIdx]->setLoopFilterBetaOffset         ( m_loopFilterBetaOffsetDiv2  );
174    m_acTEncTopList[iViewIdx]->setLoopFilterTcOffset           ( m_loopFilterTcOffsetDiv2    );
175#if DBL_CONTROL
176    m_acTEncTopList[iViewIdx]->setDeblockingFilterControlPresent( m_DeblockingFilterControlPresent);
177#endif
178
179  //====== Motion search ========
180    m_acTEncTopList[iViewIdx]->setFastSearch                   ( m_iFastSearch  );
181    m_acTEncTopList[iViewIdx]->setSearchRange                  ( m_iSearchRange );
182    m_acTEncTopList[iViewIdx]->setBipredSearchRange            ( m_bipredSearchRange );
183#if DV_V_RESTRICTION_B0037
184    m_acTEncTopList[iViewIdx]->setUseDisparitySearchRangeRestriction ( m_bUseDisparitySearchRangeRestriction );
185    m_acTEncTopList[iViewIdx]->setVerticalDisparitySearchRange( m_iVerticalDisparitySearchRange );
186#endif
187  //====== Quality control ========
188    m_acTEncTopList[iViewIdx]->setMaxDeltaQP                   ( m_iMaxDeltaQP  );
189    m_acTEncTopList[iViewIdx]->setMaxCuDQPDepth                ( m_iMaxCuDQPDepth  );
190
191    m_acTEncTopList[iViewIdx]->setChromaQpOffset               ( m_iChromaQpOffset     );
192    m_acTEncTopList[iViewIdx]->setChromaQpOffset2nd            ( m_iChromaQpOffset2nd  );
193
194#if ADAPTIVE_QP_SELECTION
195    m_acTEncTopList[iViewIdx]->setUseAdaptQpSelect             ( m_bUseAdaptQpSelect   );
196#endif
197
198#if LOSSLESS_CODING
199    Int lowestQP;
200#if H0736_AVC_STYLE_QP_RANGE
201    lowestQP =  - ( (Int)(6*(g_uiBitDepth + g_uiBitIncrement - 8)) );
202#else
203    lowestQP = 0;
204#endif
205    if ((m_iMaxDeltaQP == 0 ) && (m_aiQP[0] == lowestQP) && (m_useLossless == true))
206    {
207      m_bUseAdaptiveQP = false;
208    }
209#endif
210
211    m_acTEncTopList[iViewIdx]->setUseAdaptiveQP                ( m_bUseAdaptiveQP  );
212    m_acTEncTopList[iViewIdx]->setQPAdaptationRange            ( m_iQPAdaptationRange );
213 
214#if HHI_VSO
215    //====== VSO =========
216    m_acTEncTopList[iViewIdx]->setForceLambdaScaleVSO          ( false );
217    m_acTEncTopList[iViewIdx]->setLambdaScaleVSO               ( 1     );
218    m_acTEncTopList[iViewIdx]->setVSOMode                      ( 0     );
219    m_acTEncTopList[iViewIdx]->setUseVSO                       ( false ); 
220#if SAIT_VSO_EST_A0033
221    m_acTEncTopList[iViewIdx]->setUseEstimatedVSD              ( false );
222#endif
223#if LGE_WVSO_A0119
224    m_acTEncTopList[iViewIdx]->setUseWVSO                      ( false ); 
225#endif
226#endif
227
228#if DEPTH_MAP_GENERATION
229    m_acTEncTopList[iViewIdx]->setPredDepthMapGeneration       ( m_uiPredDepthMapGeneration );
230    m_acTEncTopList[iViewIdx]->setPdmPrecision                 ( (UInt)m_cCameraData.getPdmPrecision     () );
231    m_acTEncTopList[iViewIdx]->setPdmScaleNomDelta             (       m_cCameraData.getPdmScaleNomDelta () );
232    m_acTEncTopList[iViewIdx]->setPdmOffset                    (       m_cCameraData.getPdmOffset        () );
233#endif
234#if HHI_INTER_VIEW_MOTION_PRED
235    m_acTEncTopList[iViewIdx]->setMultiviewMvPredMode          ( m_uiMultiviewMvPredMode );
236    m_acTEncTopList[iViewIdx]->setMultiviewMvRegMode           ( iViewIdx ? m_uiMultiviewMvRegMode       : 0   );
237    m_acTEncTopList[iViewIdx]->setMultiviewMvRegLambdaScale    ( iViewIdx ? m_dMultiviewMvRegLambdaScale : 0.0 );
238#endif
239#if HHI_INTER_VIEW_RESIDUAL_PRED
240    m_acTEncTopList[iViewIdx]->setMultiviewResPredMode         ( m_uiMultiviewResPredMode );
241#endif
242
243  //====== Tool list ========
244    m_acTEncTopList[iViewIdx]->setUseSBACRD                    ( m_bUseSBACRD   );
245    m_acTEncTopList[iViewIdx]->setDeltaQpRD                    ( m_uiDeltaQpRD  );
246    m_acTEncTopList[iViewIdx]->setUseASR                       ( m_bUseASR      );
247    m_acTEncTopList[iViewIdx]->setUseHADME                     ( m_bUseHADME    );
248    m_acTEncTopList[iViewIdx]->setUseALF                       ( m_abUseALF[0]  );
249    m_acTEncTopList[iViewIdx]->setALFEncodePassReduction       ( m_iALFEncodePassReduction );
250#if LOSSLESS_CODING
251    m_acTEncTopList[iViewIdx]->setUseLossless                  ( m_useLossless );
252#endif
253    m_acTEncTopList[iViewIdx]->setALFMaxNumberFilters          ( m_iALFMaxNumberFilters ) ;
254
255    m_acTEncTopList[iViewIdx]->setUseLComb                     ( m_bUseLComb    );
256    m_acTEncTopList[iViewIdx]->setLCMod                        ( m_bLCMod         );
257    m_acTEncTopList[iViewIdx]->setdQPs                         ( m_aidQP        );
258    m_acTEncTopList[iViewIdx]->setUseRDOQ                      ( m_abUseRDOQ[0] );
259#if !PIC_CROPPING
260    m_acTEncTopList[iViewIdx]->setUsePAD                       ( m_bUsePAD      );
261#endif
262    m_acTEncTopList[iViewIdx]->setQuadtreeTULog2MaxSize        ( m_uiQuadtreeTULog2MaxSize );
263    m_acTEncTopList[iViewIdx]->setQuadtreeTULog2MinSize        ( m_uiQuadtreeTULog2MinSize );
264    m_acTEncTopList[iViewIdx]->setQuadtreeTUMaxDepthInter      ( m_uiQuadtreeTUMaxDepthInter );
265    m_acTEncTopList[iViewIdx]->setQuadtreeTUMaxDepthIntra      ( m_uiQuadtreeTUMaxDepthIntra );
266    m_acTEncTopList[iViewIdx]->setUseFastEnc                   ( m_bUseFastEnc  );
267    m_acTEncTopList[iViewIdx]->setUseEarlyCU                   ( m_bUseEarlyCU  ); 
268#if FAST_DECISION_FOR_MRG_RD_COST
269    m_acTEncTopList[iViewIdx]->setUseFastDecisionForMerge      ( m_useFastDecisionForMerge  );
270#endif
271    m_acTEncTopList[iViewIdx]->setUseCbfFastMode               ( m_bUseCbfFastMode  );
272#if HHI_INTERVIEW_SKIP
273    m_acTEncTopList[iViewIdx]->setInterViewSkip            ( iViewIdx>0 ? m_bInterViewSkip : false );
274#if HHI_INTERVIEW_SKIP_LAMBDA_SCALE
275    m_acTEncTopList[iViewIdx]->setInterViewSkipLambdaScale ( iViewIdx>0 ? (UInt)m_dInterViewSkipLambdaScale : 1 );
276#endif
277#endif
278    m_acTEncTopList[iViewIdx]->setUseLMChroma                  ( m_bUseLMChroma );
279    m_acTEncTopList[iViewIdx]->setUseConstrainedIntraPred      ( m_bUseConstrainedIntraPred );
280    m_acTEncTopList[iViewIdx]->setPCMLog2MinSize               ( m_uiPCMLog2MinSize);
281    m_acTEncTopList[iViewIdx]->setUsePCM                       ( m_usePCM );
282    m_acTEncTopList[iViewIdx]->setPCMLog2MaxSize               ( m_pcmLog2MaxSize);
283
284  //====== Weighted Prediction ========
285    m_acTEncTopList[iViewIdx]->setUseWP                        ( m_bUseWeightPred      );
286    m_acTEncTopList[iViewIdx]->setWPBiPredIdc                  ( m_uiBiPredIdc         );
287  //====== Slice ========
288    m_acTEncTopList[iViewIdx]->setSliceMode                    ( m_iSliceMode                );
289    m_acTEncTopList[iViewIdx]->setSliceArgument                ( m_iSliceArgument            );
290
291  //====== Entropy Slice ========
292    m_acTEncTopList[iViewIdx]->setEntropySliceMode             ( m_iEntropySliceMode         );
293    m_acTEncTopList[iViewIdx]->setEntropySliceArgument         ( m_iEntropySliceArgument     );
294    int iNumPartInCU = 1<<(m_uiMaxCUDepth<<1);
295    if(m_iEntropySliceMode==SHARP_FIXED_NUMBER_OF_LCU_IN_ENTROPY_SLICE)
296    {
297      m_acTEncTopList[iViewIdx]->setEntropySliceArgument ( m_iEntropySliceArgument * ( iNumPartInCU >> ( m_iSliceGranularity << 1 ) ) );
298    }
299    if(m_iSliceMode==AD_HOC_SLICES_FIXED_NUMBER_OF_LCU_IN_SLICE)
300    {
301      m_acTEncTopList[iViewIdx]->setSliceArgument ( m_iSliceArgument * ( iNumPartInCU >> ( m_iSliceGranularity << 1 ) ) );
302    }
303#if FIXED_NUMBER_OF_TILES_SLICE_MODE
304    if(m_iSliceMode==AD_HOC_SLICES_FIXED_NUMBER_OF_TILES_IN_SLICE)
305    {
306      m_acTEncTopList[iViewIdx]->setSliceArgument ( m_iSliceArgument );
307    }
308#endif
309    m_acTEncTopList[iViewIdx]->setSliceGranularity        ( m_iSliceGranularity         );
310    if(m_iSliceMode == 0 )
311    {
312      m_bLFCrossSliceBoundaryFlag = true;
313    }
314    m_acTEncTopList[iViewIdx]->setLFCrossSliceBoundaryFlag( m_bLFCrossSliceBoundaryFlag );
315    m_acTEncTopList[iViewIdx]->setUseSAO               ( m_abUseSAO[0]     );
316#if LGE_ILLUCOMP_B0045
317    m_acTEncTopList[iViewIdx]->setUseIC                ( m_bUseIC          );
318#endif
319#if SAO_UNIT_INTERLEAVING
320    m_acTEncTopList[iViewIdx]->setMaxNumOffsetsPerPic (m_maxNumOffsetsPerPic);
321    m_acTEncTopList[iViewIdx]->setSaoInterleavingFlag (m_saoInterleavingFlag);
322#endif
323    m_acTEncTopList[iViewIdx]->setPCMInputBitDepthFlag  ( m_bPCMInputBitDepthFlag); 
324    m_acTEncTopList[iViewIdx]->setPCMFilterDisableFlag  ( m_bPCMFilterDisableFlag); 
325
326    m_acTEncTopList[iViewIdx]->setPictureDigestEnabled(m_pictureDigestEnabled);
327
328    m_acTEncTopList[iViewIdx]->setColumnRowInfoPresent       ( m_iColumnRowInfoPresent );
329    m_acTEncTopList[iViewIdx]->setUniformSpacingIdr          ( m_iUniformSpacingIdr );
330#if !REMOVE_TILE_DEPENDENCE
331    m_acTEncTopList[iViewIdx]->setTileBoundaryIndependenceIdr( m_iTileBoundaryIndependenceIdr );
332#endif
333    m_acTEncTopList[iViewIdx]->setNumColumnsMinus1           ( m_iNumColumnsMinus1 );
334    m_acTEncTopList[iViewIdx]->setNumRowsMinus1              ( m_iNumRowsMinus1 );
335    if(m_iUniformSpacingIdr==0)
336    {
337      m_acTEncTopList[iViewIdx]->setColumnWidth              ( m_pchColumnWidth );
338      m_acTEncTopList[iViewIdx]->setRowHeight                ( m_pchRowHeight );
339    }
340    m_acTEncTopList[iViewIdx]->xCheckGSParameters();
341    m_acTEncTopList[iViewIdx]->setTileLocationInSliceHeaderFlag ( m_iTileLocationInSliceHeaderFlag );
342    m_acTEncTopList[iViewIdx]->setTileMarkerFlag              ( m_iTileMarkerFlag );
343    m_acTEncTopList[iViewIdx]->setMaxTileMarkerEntryPoints    ( m_iMaxTileMarkerEntryPoints );
344 
345    Int uiTilesCount          = (m_iNumRowsMinus1+1) * (m_iNumColumnsMinus1+1);
346    m_dMaxTileMarkerOffset    = ((Double)uiTilesCount) / m_iMaxTileMarkerEntryPoints;
347    m_acTEncTopList[iViewIdx]->setMaxTileMarkerOffset         ( m_dMaxTileMarkerOffset );
348    m_acTEncTopList[iViewIdx]->setTileBehaviorControlPresentFlag( m_iTileBehaviorControlPresentFlag );
349#if !REMOVE_TILE_DEPENDENCE
350    if(m_iTileBoundaryIndependenceIdr == 0 || uiTilesCount == 1)
351#else
352    if(uiTilesCount == 1)
353#endif
354    {
355      m_bLFCrossTileBoundaryFlag = true; 
356    }
357    m_acTEncTopList[iViewIdx]->setLFCrossTileBoundaryFlag( m_bLFCrossTileBoundaryFlag );
358    m_acTEncTopList[iViewIdx]->setWaveFrontSynchro           ( m_iWaveFrontSynchro );
359    m_acTEncTopList[iViewIdx]->setWaveFrontFlush             ( m_iWaveFrontFlush );
360    m_acTEncTopList[iViewIdx]->setWaveFrontSubstreams        ( m_iWaveFrontSubstreams );
361#if TMVP_DEPTH_SWITCH
362    m_acTEncTopList[iViewIdx]->setEnableTMVP                 ( m_enableTMVP[0] );
363#else
364    m_acTEncTopList[iViewIdx]->setEnableTMVP ( m_enableTMVP );
365#endif
366    m_acTEncTopList[iViewIdx]->setUseScalingListId           ( m_useScalingListId  );
367    m_acTEncTopList[iViewIdx]->setScalingListFile            ( m_scalingListFile   );
368#if MULTIBITS_DATA_HIDING
369    m_acTEncTopList[iViewIdx]->setSignHideFlag(m_signHideFlag);
370    m_acTEncTopList[iViewIdx]->setTSIG(m_signHidingThreshold);
371#endif
372
373#if LCU_SYNTAX_ALF
374    if(uiTilesCount > 1)
375    {
376      m_bALFParamInSlice = false;
377      m_bALFPicBasedEncode = true;
378    }
379    m_acTEncTopList[iViewIdx]->setALFParamInSlice              ( m_bALFParamInSlice);
380    m_acTEncTopList[iViewIdx]->setALFPicBasedEncode            ( m_bALFPicBasedEncode);
381#endif
382
383    //====== Depth tools ========
384#if HHI_DMM_WEDGE_INTRA || HHI_DMM_PRED_TEX
385    m_acTEncTopList[iViewIdx]->setUseDMM                     ( false );
386#endif
387#if OL_QTLIMIT_PREDCODING_B0068
388    m_acTEncTopList[iViewIdx]->setUseQTLPC                   ( false );
389#endif
390#if HHI_MPI
391    m_acTEncTopList[iViewIdx]->setUseMVI( false );
392#endif
393#if RWTH_SDC_DLT_B0036
394    m_acTEncTopList[iViewIdx]->setUseDLT                      ( false );
395    m_acTEncTopList[iViewIdx]->setUseSDC                      ( false );
396#endif
397  }
398  if( m_bUsingDepthMaps )
399  {
400    for(Int iViewIdx=0; iViewIdx<m_iNumberOfViews; iViewIdx++)
401    {
402      m_depthFrameRcvd.push_back(0);
403      m_acTEncDepthTopList.push_back(new TEncTop); 
404      m_acTVideoIOYuvDepthInputFileList.push_back(new TVideoIOYuv);
405      m_acTVideoIOYuvDepthReconFileList.push_back(new TVideoIOYuv);
406      m_picYuvDepthRec.push_back(new TComList<TComPicYuv*>) ;
407
408      m_acTEncDepthTopList[iViewIdx]->setFrameRate                    ( m_iFrameRate );
409      m_acTEncDepthTopList[iViewIdx]->setFrameSkip                    ( m_FrameSkip );
410      m_acTEncDepthTopList[iViewIdx]->setSourceWidth                  ( m_iSourceWidth );
411      m_acTEncDepthTopList[iViewIdx]->setSourceHeight                 ( m_iSourceHeight );
412#if PIC_CROPPING
413      m_acTEncDepthTopList[iViewIdx]->setCroppingMode                 ( m_croppingMode );
414      m_acTEncDepthTopList[iViewIdx]->setCropLeft                     ( m_cropLeft );
415      m_acTEncDepthTopList[iViewIdx]->setCropRight                    ( m_cropRight );
416      m_acTEncDepthTopList[iViewIdx]->setCropTop                      ( m_cropTop );
417      m_acTEncDepthTopList[iViewIdx]->setCropBottom                   ( m_cropBottom );
418#endif
419      m_acTEncDepthTopList[iViewIdx]->setFrameToBeEncoded             ( m_iFrameToBeEncoded );
420      m_acTEncDepthTopList[iViewIdx]->setViewId                       ( iViewIdx );
421      m_acTEncDepthTopList[iViewIdx]->setIsDepth                      ( true );
422#if QC_MVHEVC_B0046
423      m_acTEncDepthTopList[iViewIdx]->setLayerId                      ( iViewIdx );
424#else
425      m_acTEncDepthTopList[iViewIdx]->setViewOrderIdx                 ( m_cCameraData.getViewOrderIndex()[ iViewIdx ] );
426#endif
427#if VIDYO_VPS_INTEGRATION
428      layerId = iViewIdx * 2 + 1;
429      m_acTEncDepthTopList[iViewIdx]->setLayerId                      ( layerId );
430      m_cVPS.setDepthFlag                                             ( true, layerId );
431      m_cVPS.setViewId                                                ( iViewIdx, layerId );
432      m_cVPS.setViewOrderIdx                                          ( m_cCameraData.getViewOrderIndex()[ iViewIdx ], layerId );
433      m_cVPS.setDependentFlag                                         ( true, layerId );
434      m_cVPS.setDependentLayer                                        ( layerId-1, layerId);
435#endif
436      m_acTEncDepthTopList[iViewIdx]->setCamParPrecision              ( 0 );
437      m_acTEncDepthTopList[iViewIdx]->setCamParInSliceHeader          ( false );
438      m_acTEncDepthTopList[iViewIdx]->setCodedScale                   ( 0 );
439      m_acTEncDepthTopList[iViewIdx]->setCodedOffset                  ( 0 );
440
441      //====== Coding Structure ========
442      m_acTEncDepthTopList[iViewIdx]->setIntraPeriod                  ( m_iIntraPeriod );
443      m_acTEncDepthTopList[iViewIdx]->setDecodingRefreshType          ( m_iDecodingRefreshType );
444      m_acTEncDepthTopList[iViewIdx]->setGOPSize                      ( m_iGOPSize );
445      m_acTEncDepthTopList[iViewIdx]->setGopList                      ( m_GOPListsMvc[iViewIdx] );
446      m_acTEncDepthTopList[iViewIdx]->setExtraRPSs                    ( m_extraRPSs[iViewIdx] );
447#if H0567_DPB_PARAMETERS_PER_TEMPORAL_LAYER
448      for(Int i = 0; i < MAX_TLAYER; i++)
449      {
450        m_acTEncDepthTopList[iViewIdx]->setNumReorderPics             ( m_numReorderPics[iViewIdx][i], i );
451        m_acTEncDepthTopList[iViewIdx]->setMaxDecPicBuffering         ( m_maxDecPicBuffering[iViewIdx][i], i );
452      }
453#else
454      m_acTEncDepthTopList[iViewIdx]->setNumReorderFrames             ( m_numReorderFrames );
455      m_acTEncDepthTopList[iViewIdx]->setMaxNumberOfReferencePictures ( m_maxNumberOfReferencePictures );
456#endif
457      for( UInt uiLoop = 0; uiLoop < MAX_TLAYER; ++uiLoop )
458      {
459        m_acTEncDepthTopList[iViewIdx]->setLambdaModifier( uiLoop, m_adLambdaModifier[ uiLoop ] );
460      }
461      m_acTEncDepthTopList[iViewIdx]->setQP                           ( m_aiQP[1] );
462
463      m_acTEncDepthTopList[iViewIdx]->setTemporalLayerQPOffset        ( m_aiTLayerQPOffset );
464      m_acTEncDepthTopList[iViewIdx]->setPad                          ( m_aiPad );
465
466#if H0566_TLA
467      m_acTEncDepthTopList[iViewIdx]->setMaxTempLayer                 ( m_maxTempLayer[iViewIdx] );
468#else
469      m_acTEncDepthTopList[iViewIdx]->setTLayering                    ( m_bTLayering );
470      m_acTEncDepthTopList[iViewIdx]->setTLayerSwitchingFlag          ( m_abTLayerSwitchingFlag );
471#endif
472
473      m_acTEncDepthTopList[iViewIdx]->setDisInter4x4                  ( m_bDisInter4x4);
474
475      m_acTEncDepthTopList[iViewIdx]->setUseNSQT( m_enableNSQT );
476      m_acTEncDepthTopList[iViewIdx]->setUseAMP( m_enableAMP );
477
478      //===== Slice ========
479
480      //====== Loop/Deblock Filter ========
481      m_acTEncDepthTopList[iViewIdx]->setLoopFilterDisable            ( m_abLoopFilterDisable[1]   );
482      m_acTEncDepthTopList[iViewIdx]->setLoopFilterOffsetInAPS        ( m_loopFilterOffsetInAPS );
483      m_acTEncDepthTopList[iViewIdx]->setLoopFilterBetaOffset         ( m_loopFilterBetaOffsetDiv2  );
484      m_acTEncDepthTopList[iViewIdx]->setLoopFilterTcOffset           ( m_loopFilterTcOffsetDiv2    );
485#if DBL_CONTROL
486      m_acTEncDepthTopList[iViewIdx]->setDeblockingFilterControlPresent( m_DeblockingFilterControlPresent);
487#endif
488
489      //====== Motion search ========
490      m_acTEncDepthTopList[iViewIdx]->setFastSearch                   ( m_iFastSearch  );
491      m_acTEncDepthTopList[iViewIdx]->setSearchRange                  ( m_iSearchRange );
492      m_acTEncDepthTopList[iViewIdx]->setBipredSearchRange            ( m_bipredSearchRange );
493#if DV_V_RESTRICTION_B0037
494      m_acTEncDepthTopList[iViewIdx]->setUseDisparitySearchRangeRestriction ( m_bUseDisparitySearchRangeRestriction );
495      m_acTEncDepthTopList[iViewIdx]->setVerticalDisparitySearchRange( m_iVerticalDisparitySearchRange );
496#endif
497      //====== Quality control ========
498      m_acTEncDepthTopList[iViewIdx]->setMaxDeltaQP                   ( m_iMaxDeltaQP  );
499      m_acTEncDepthTopList[iViewIdx]->setMaxCuDQPDepth                ( m_iMaxCuDQPDepth  );
500
501      m_acTEncDepthTopList[iViewIdx]->setChromaQpOffset               ( m_iChromaQpOffset     );
502      m_acTEncDepthTopList[iViewIdx]->setChromaQpOffset2nd            ( m_iChromaQpOffset2nd  );
503
504#if ADAPTIVE_QP_SELECTION
505      m_acTEncDepthTopList[iViewIdx]->setUseAdaptQpSelect             ( m_bUseAdaptQpSelect   );
506#endif
507
508      m_acTEncDepthTopList[iViewIdx]->setUseAdaptiveQP                ( m_bUseAdaptiveQP  );
509      m_acTEncDepthTopList[iViewIdx]->setQPAdaptationRange            ( m_iQPAdaptationRange );
510
511      //====== Tool list ========
512      m_acTEncDepthTopList[iViewIdx]->setUseSBACRD                    ( m_bUseSBACRD   );
513      m_acTEncDepthTopList[iViewIdx]->setDeltaQpRD                    ( m_uiDeltaQpRD  );
514      m_acTEncDepthTopList[iViewIdx]->setUseASR                       ( m_bUseASR      );
515      m_acTEncDepthTopList[iViewIdx]->setUseHADME                     ( m_bUseHADME    );
516      m_acTEncDepthTopList[iViewIdx]->setUseALF                       ( m_abUseALF[1]  );
517      m_acTEncDepthTopList[iViewIdx]->setALFEncodePassReduction       ( m_iALFEncodePassReduction );
518#if LOSSLESS_CODING
519      m_acTEncDepthTopList[iViewIdx]->setUseLossless                  ( m_useLossless );
520#endif
521      m_acTEncDepthTopList[iViewIdx]->setALFMaxNumberFilters          ( m_iALFMaxNumberFilters ) ;
522
523      m_acTEncDepthTopList[iViewIdx]->setUseLComb                     ( m_bUseLComb    );
524      m_acTEncDepthTopList[iViewIdx]->setLCMod                        ( m_bLCMod       );
525      m_acTEncDepthTopList[iViewIdx]->setdQPs                         ( m_aidQPdepth   );
526      m_acTEncDepthTopList[iViewIdx]->setUseRDOQ                      ( m_abUseRDOQ[1] );
527#if !PIC_CROPPING
528      m_acTEncDepthTopList[iViewIdx]->setUsePAD                       ( m_bUsePAD      );
529#endif
530      m_acTEncDepthTopList[iViewIdx]->setQuadtreeTULog2MaxSize        ( m_uiQuadtreeTULog2MaxSize );
531      m_acTEncDepthTopList[iViewIdx]->setQuadtreeTULog2MinSize        ( m_uiQuadtreeTULog2MinSize );
532      m_acTEncDepthTopList[iViewIdx]->setQuadtreeTUMaxDepthInter      ( m_uiQuadtreeTUMaxDepthInter );
533      m_acTEncDepthTopList[iViewIdx]->setQuadtreeTUMaxDepthIntra      ( m_uiQuadtreeTUMaxDepthIntra );
534      m_acTEncDepthTopList[iViewIdx]->setUseFastEnc                   ( m_bUseFastEnc  );
535      m_acTEncDepthTopList[iViewIdx]->setUseEarlyCU                   ( m_bUseEarlyCU  ); 
536#if FAST_DECISION_FOR_MRG_RD_COST
537      m_acTEncDepthTopList[iViewIdx]->setUseFastDecisionForMerge      ( m_useFastDecisionForMerge  );
538#endif
539      m_acTEncDepthTopList[iViewIdx]->setUseCbfFastMode               ( m_bUseCbfFastMode  );
540#if HHI_INTERVIEW_SKIP
541      m_acTEncDepthTopList[iViewIdx]->setInterViewSkip            ( 0 );
542#if HHI_INTERVIEW_SKIP_LAMBDA_SCALE
543      m_acTEncDepthTopList[iViewIdx]->setInterViewSkipLambdaScale ( 1 );
544#endif
545#endif
546      m_acTEncDepthTopList[iViewIdx]->setUseLMChroma                  ( m_bUseLMChroma );
547      m_acTEncDepthTopList[iViewIdx]->setUseConstrainedIntraPred      ( m_bUseConstrainedIntraPred );
548      m_acTEncDepthTopList[iViewIdx]->setPCMLog2MinSize               ( m_uiPCMLog2MinSize);
549      m_acTEncDepthTopList[iViewIdx]->setUsePCM                       ( m_usePCM );
550      m_acTEncDepthTopList[iViewIdx]->setPCMLog2MaxSize               ( m_pcmLog2MaxSize);
551      //====== VSO ========
552#if HHI_VSO
553      m_acTEncDepthTopList[iViewIdx]->setUseVSO                       ( m_bUseVSO      ); //GT: might be enabled/disabled later for VSO Mode 4
554      m_acTEncDepthTopList[iViewIdx]->setForceLambdaScaleVSO          ( m_bForceLambdaScaleVSO );
555      m_acTEncDepthTopList[iViewIdx]->setLambdaScaleVSO               ( m_dLambdaScaleVSO );
556#if HHI_VSO_DIST_INT
557      m_acTEncDepthTopList[iViewIdx]->setAllowNegDist                 ( m_bAllowNegDist );
558#endif
559      m_acTEncDepthTopList[iViewIdx]->setVSOMode                      ( m_uiVSOMode );
560
561#if SAIT_VSO_EST_A0033
562      m_acTEncDepthTopList[iViewIdx]->setUseEstimatedVSD              ( m_bUseEstimatedVSD );
563#endif
564#if LGE_WVSO_A0119
565      m_acTEncDepthTopList[iViewIdx]->setUseWVSO                      ( m_bUseWVSO         );
566#endif
567#endif
568
569#if DEPTH_MAP_GENERATION
570      m_acTEncDepthTopList[iViewIdx]->setPredDepthMapGeneration       ( 0 );
571#endif
572#if HHI_INTER_VIEW_MOTION_PRED
573      m_acTEncDepthTopList[iViewIdx]->setMultiviewMvPredMode          ( 0 );
574      m_acTEncDepthTopList[iViewIdx]->setMultiviewMvRegMode           ( 0 );
575      m_acTEncDepthTopList[iViewIdx]->setMultiviewMvRegLambdaScale    ( 0.0 );
576#endif
577#if HHI_INTER_VIEW_RESIDUAL_PRED
578      m_acTEncDepthTopList[iViewIdx]->setMultiviewResPredMode         ( 0 );
579#endif
580
581      //====== Weighted Prediction ========
582      m_acTEncDepthTopList[iViewIdx]->setUseWP                        ( m_bUseWeightPred      );
583      m_acTEncDepthTopList[iViewIdx]->setWPBiPredIdc                  ( m_uiBiPredIdc         );
584      //====== Slice ========
585      m_acTEncDepthTopList[iViewIdx]->setSliceMode                    ( m_iSliceMode                );
586      m_acTEncDepthTopList[iViewIdx]->setSliceArgument                ( m_iSliceArgument            );
587
588      //====== Entropy Slice ========
589      m_acTEncDepthTopList[iViewIdx]->setEntropySliceMode             ( m_iEntropySliceMode         );
590      m_acTEncDepthTopList[iViewIdx]->setEntropySliceArgument         ( m_iEntropySliceArgument     );
591      int iNumPartInCU = 1<<(m_uiMaxCUDepth<<1);
592      if(m_iEntropySliceMode==SHARP_FIXED_NUMBER_OF_LCU_IN_ENTROPY_SLICE)
593      {
594        m_acTEncDepthTopList[iViewIdx]->setEntropySliceArgument ( m_iEntropySliceArgument * ( iNumPartInCU >> ( m_iSliceGranularity << 1 ) ) );
595      }
596      if(m_iSliceMode==AD_HOC_SLICES_FIXED_NUMBER_OF_LCU_IN_SLICE)
597      {
598        m_acTEncDepthTopList[iViewIdx]->setSliceArgument ( m_iSliceArgument * ( iNumPartInCU >> ( m_iSliceGranularity << 1 ) ) );
599      }
600#if FIXED_NUMBER_OF_TILES_SLICE_MODE
601      if(m_iSliceMode==AD_HOC_SLICES_FIXED_NUMBER_OF_TILES_IN_SLICE)
602      {
603        m_acTEncDepthTopList[iViewIdx]->setSliceArgument ( m_iSliceArgument );
604      }
605#endif
606      m_acTEncDepthTopList[iViewIdx]->setSliceGranularity        ( m_iSliceGranularity         );
607      if(m_iSliceMode == 0 )
608      {
609        m_bLFCrossSliceBoundaryFlag = true;
610      }
611      m_acTEncDepthTopList[iViewIdx]->setLFCrossSliceBoundaryFlag( m_bLFCrossSliceBoundaryFlag );
612      m_acTEncDepthTopList[iViewIdx]->setUseSAO               ( m_abUseSAO[1]     );
613#if LGE_ILLUCOMP_B0045
614      m_acTEncDepthTopList[iViewIdx]->setUseIC                ( false     );
615#endif
616#if SAO_UNIT_INTERLEAVING
617      m_acTEncDepthTopList[iViewIdx]->setMaxNumOffsetsPerPic (m_maxNumOffsetsPerPic);
618      m_acTEncDepthTopList[iViewIdx]->setSaoInterleavingFlag (m_saoInterleavingFlag);
619#endif
620      m_acTEncDepthTopList[iViewIdx]->setPCMInputBitDepthFlag  ( m_bPCMInputBitDepthFlag); 
621      m_acTEncDepthTopList[iViewIdx]->setPCMFilterDisableFlag  ( m_bPCMFilterDisableFlag); 
622
623      m_acTEncDepthTopList[iViewIdx]->setPictureDigestEnabled(m_pictureDigestEnabled);
624
625      m_acTEncDepthTopList[iViewIdx]->setColumnRowInfoPresent       ( m_iColumnRowInfoPresent );
626      m_acTEncDepthTopList[iViewIdx]->setUniformSpacingIdr          ( m_iUniformSpacingIdr );
627#if !REMOVE_TILE_DEPENDENCE
628      m_acTEncDepthTopList[iViewIdx]->setTileBoundaryIndependenceIdr( m_iTileBoundaryIndependenceIdr );
629#endif
630      m_acTEncDepthTopList[iViewIdx]->setNumColumnsMinus1           ( m_iNumColumnsMinus1 );
631      m_acTEncDepthTopList[iViewIdx]->setNumRowsMinus1              ( m_iNumRowsMinus1 );
632      if(m_iUniformSpacingIdr==0)
633      {
634        m_acTEncDepthTopList[iViewIdx]->setColumnWidth              ( m_pchColumnWidth );
635        m_acTEncDepthTopList[iViewIdx]->setRowHeight                ( m_pchRowHeight );
636      }
637      m_acTEncDepthTopList[iViewIdx]->xCheckGSParameters();
638      m_acTEncDepthTopList[iViewIdx]->setTileLocationInSliceHeaderFlag ( m_iTileLocationInSliceHeaderFlag );
639      m_acTEncDepthTopList[iViewIdx]->setTileMarkerFlag              ( m_iTileMarkerFlag );
640      m_acTEncDepthTopList[iViewIdx]->setMaxTileMarkerEntryPoints    ( m_iMaxTileMarkerEntryPoints );
641
642      Int uiTilesCount          = (m_iNumRowsMinus1+1) * (m_iNumColumnsMinus1+1);
643      m_dMaxTileMarkerOffset    = ((Double)uiTilesCount) / m_iMaxTileMarkerEntryPoints;
644      m_acTEncDepthTopList[iViewIdx]->setMaxTileMarkerOffset         ( m_dMaxTileMarkerOffset );
645      m_acTEncDepthTopList[iViewIdx]->setTileBehaviorControlPresentFlag( m_iTileBehaviorControlPresentFlag );
646#if !REMOVE_TILE_DEPENDENCE
647      if(m_iTileBoundaryIndependenceIdr == 0 || uiTilesCount == 1)
648#else
649      if(uiTilesCount == 1)
650#endif
651      {
652        m_bLFCrossTileBoundaryFlag = true; 
653      }
654      m_acTEncDepthTopList[iViewIdx]->setLFCrossTileBoundaryFlag( m_bLFCrossTileBoundaryFlag );
655      m_acTEncDepthTopList[iViewIdx]->setWaveFrontSynchro           ( m_iWaveFrontSynchro );
656      m_acTEncDepthTopList[iViewIdx]->setWaveFrontFlush             ( m_iWaveFrontFlush );
657      m_acTEncDepthTopList[iViewIdx]->setWaveFrontSubstreams        ( m_iWaveFrontSubstreams );
658#if TMVP_DEPTH_SWITCH
659      m_acTEncDepthTopList[iViewIdx]->setEnableTMVP                 ( m_enableTMVP[1] );
660#else
661      m_acTEncDepthTopList[iViewIdx]->setEnableTMVP ( m_enableTMVP );
662#endif
663      m_acTEncDepthTopList[iViewIdx]->setUseScalingListId           ( m_useScalingListId  );
664      m_acTEncDepthTopList[iViewIdx]->setScalingListFile            ( m_scalingListFile   );
665#if MULTIBITS_DATA_HIDING
666      m_acTEncDepthTopList[iViewIdx]->setSignHideFlag(m_signHideFlag);
667      m_acTEncDepthTopList[iViewIdx]->setTSIG(m_signHidingThreshold);
668#endif
669
670#if LCU_SYNTAX_ALF
671      if(uiTilesCount > 1)
672      {
673        m_bALFParamInSlice = false;
674        m_bALFPicBasedEncode = true;
675      }
676      m_acTEncDepthTopList[iViewIdx]->setALFParamInSlice              ( m_bALFParamInSlice);
677      m_acTEncDepthTopList[iViewIdx]->setALFPicBasedEncode            ( m_bALFPicBasedEncode);
678#endif
679
680  //====== Depth tools ========
681#if HHI_DMM_WEDGE_INTRA || HHI_DMM_PRED_TEX
682    m_acTEncDepthTopList[iViewIdx]->setUseDMM                     ( m_bUseDMM );
683#endif
684#if OL_QTLIMIT_PREDCODING_B0068
685    m_acTEncDepthTopList[iViewIdx]->setUseQTLPC                   (m_bUseQTLPC);
686#endif
687#if HHI_MPI
688     m_acTEncDepthTopList[iViewIdx]->setUseMVI( m_bUseMVI );
689#endif
690#if RWTH_SDC_DLT_B0036
691      m_acTEncDepthTopList[iViewIdx]->setUseDLT                   ( m_bUseDLT );
692      m_acTEncDepthTopList[iViewIdx]->setUseSDC                   ( m_bUseSDC );
693#endif
694    }
695  }
696
697#if HHI_INTER_VIEW_MOTION_PRED
698  else if( m_uiMultiviewMvRegMode )
699  {
700    for(Int iViewIdx=0; iViewIdx<m_iNumberOfViews; iViewIdx++)
701    {
702      m_acTVideoIOYuvDepthInputFileList.push_back( new TVideoIOYuv );
703    }
704  }
705#endif
706
707#if HHI_VSO
708  if ( m_bUseVSO )
709  {
710    if ( m_uiVSOMode == 4 )
711    {
712#if LGE_VSO_EARLY_SKIP_A0093
713      m_cRendererModel.create( m_cRenModStrParser.getNumOfBaseViews(), m_cRenModStrParser.getNumOfModels(), m_iSourceWidth, g_uiMaxCUHeight , LOG2_DISP_PREC_LUT, 0, m_bVSOEarlySkip );
714#else
715      m_cRendererModel.create( m_cRenModStrParser.getNumOfBaseViews(), m_cRenModStrParser.getNumOfModels(), m_iSourceWidth, g_uiMaxCUHeight , LOG2_DISP_PREC_LUT, 0 );
716#endif
717
718      for ( Int iViewNum = 0; iViewNum < m_iNumberOfViews; iViewNum++ )
719      {
720        for (Int iContent = 0; iContent < 2; iContent++ )
721        {
722          Int iNumOfModels   = m_cRenModStrParser.getNumOfModelsForView(iViewNum, iContent);
723          Bool bUseVSO = (iNumOfModels != 0);
724
725          TEncTop* pcEncTop = ( iContent == 0 ) ? m_acTEncTopList[iViewNum] : m_acTEncDepthTopList[iViewNum];
726          pcEncTop->setUseVSO( bUseVSO );
727          pcEncTop->getRdCost()->setRenModel( bUseVSO ? &m_cRendererModel : NULL );
728
729          for (Int iCurModel = 0; iCurModel < iNumOfModels; iCurModel++ )
730          {
731            Int iModelNum; Int iLeftViewNum; Int iRightViewNum; Int iDump; Int iOrgRefNum; Int iBlendMode;
732
733            m_cRenModStrParser.getSingleModelData  ( iViewNum, iContent, iCurModel, iModelNum, iBlendMode, iLeftViewNum, iRightViewNum, iOrgRefNum, iDump ) ;
734            m_cRendererModel  .createSingleModel   ( iViewNum, iContent, iModelNum, iLeftViewNum, iRightViewNum, (iOrgRefNum != -1), iBlendMode );
735          }
736        }
737      }
738    }
739    else
740    {
741      AOT(true);
742    }
743#if LGE_WVSO_A0119
744    for ( Int iViewNum = 0; iViewNum < m_iNumberOfViews; iViewNum++ )
745    {
746      for (Int iContent = 0; iContent < 2; iContent++ )
747      {
748        TEncTop* pcEncTop = ( iContent == 0 ) ? m_acTEncTopList[iViewNum] : m_acTEncDepthTopList[iViewNum]; 
749        pcEncTop->setUseWVSO  ( m_bUseWVSO );
750        pcEncTop->setVSOWeight( m_iVSOWeight );
751        pcEncTop->setVSDWeight( m_iVSDWeight );
752        pcEncTop->setDWeight  ( m_iDWeight );
753      }
754    }
755#endif
756  }
757#endif
758
759#if HHI_INTERVIEW_SKIP
760  m_cUsedPelsRenderer.init(m_iSourceWidth, m_iSourceHeight, true, 0, LOG2_DISP_PREC_LUT, true, 0, 0, 0, 0, 0, 6, 4, 1, 0, 6 );
761#endif
762
763}
764
765Void TAppEncTop::xCreateLib()
766{
767  for(Int iViewIdx=0; iViewIdx<m_iNumberOfViews; iViewIdx++)
768  {
769    m_acTVideoIOYuvInputFileList[iViewIdx]->open( m_pchInputFileList[iViewIdx],     false, m_uiInputBitDepth, m_uiInternalBitDepth );  // read  mode
770    m_acTVideoIOYuvInputFileList[iViewIdx]->skipFrames(m_FrameSkip, m_iSourceWidth - m_aiPad[0], m_iSourceHeight - m_aiPad[1]);
771
772    if (m_pchReconFileList[iViewIdx])
773      m_acTVideoIOYuvReconFileList[iViewIdx]->open(m_pchReconFileList[iViewIdx], true, m_uiOutputBitDepth, m_uiInternalBitDepth);  // write mode
774    m_acTEncTopList[iViewIdx]->create();
775    if( m_bUsingDepthMaps )
776    {
777      m_acTVideoIOYuvDepthInputFileList[iViewIdx]->open( m_pchDepthInputFileList[iViewIdx],     false, m_uiInputBitDepth, m_uiInternalBitDepth );  // read  mode
778      m_acTVideoIOYuvDepthInputFileList[iViewIdx]->skipFrames(m_FrameSkip, m_iSourceWidth - m_aiPad[0], m_iSourceHeight - m_aiPad[1]);
779
780      if (m_pchDepthReconFileList[iViewIdx])
781        m_acTVideoIOYuvDepthReconFileList[iViewIdx]->open(m_pchDepthReconFileList[iViewIdx], true, m_uiOutputBitDepth, m_uiInternalBitDepth);  // write mode
782      m_acTEncDepthTopList[iViewIdx]->create();
783    }
784#if HHI_INTER_VIEW_MOTION_PRED
785    else if( m_uiMultiviewMvRegMode )
786    {
787      m_acTVideoIOYuvDepthInputFileList[iViewIdx]->open( m_pchDepthInputFileList[iViewIdx],     false, m_uiInputBitDepth, m_uiInternalBitDepth );  // read  mode
788      m_acTVideoIOYuvDepthInputFileList[iViewIdx]->skipFrames(m_FrameSkip, m_iSourceWidth, m_iSourceHeight);
789    }
790#endif
791  }
792}
793
794Void TAppEncTop::xDestroyLib()
795{
796  // Video I/O
797  for(Int iViewIdx=0; iViewIdx<m_iNumberOfViews; iViewIdx++)
798  {
799    m_acTVideoIOYuvInputFileList[iViewIdx]->close();
800    m_acTVideoIOYuvReconFileList[iViewIdx]->close();
801    delete m_acTVideoIOYuvInputFileList[iViewIdx] ; 
802    m_acTVideoIOYuvInputFileList[iViewIdx] = NULL;
803    delete m_acTVideoIOYuvReconFileList[iViewIdx] ; 
804    m_acTVideoIOYuvReconFileList[iViewIdx] = NULL;
805    m_acTEncTopList[iViewIdx]->deletePicBuffer();
806    m_acTEncTopList[iViewIdx]->destroy();
807    delete m_acTEncTopList[iViewIdx] ; 
808    m_acTEncTopList[iViewIdx] = NULL;
809    delete m_picYuvRec[iViewIdx] ; 
810    m_picYuvRec[iViewIdx] = NULL;
811
812    if( iViewIdx < Int( m_acTVideoIOYuvDepthInputFileList.size() ) && m_acTVideoIOYuvDepthInputFileList[iViewIdx] )
813    {
814      m_acTVideoIOYuvDepthInputFileList[iViewIdx]->close( );
815      delete m_acTVideoIOYuvDepthInputFileList[iViewIdx];
816      m_acTVideoIOYuvDepthInputFileList[iViewIdx] = NULL;
817    }
818    if( iViewIdx < Int( m_acTVideoIOYuvDepthReconFileList.size() ) && m_acTVideoIOYuvDepthReconFileList[iViewIdx] )
819    {
820      m_acTVideoIOYuvDepthReconFileList[iViewIdx]->close () ;
821      delete m_acTVideoIOYuvDepthReconFileList[iViewIdx];
822      m_acTVideoIOYuvDepthReconFileList[iViewIdx] = NULL;
823    }
824    if( iViewIdx < Int( m_acTEncDepthTopList.size() ) && m_acTEncDepthTopList[iViewIdx] )
825    {
826      m_acTEncDepthTopList[iViewIdx]->deletePicBuffer();
827      m_acTEncDepthTopList[iViewIdx]->destroy();
828      delete m_acTEncDepthTopList[iViewIdx];
829      m_acTEncDepthTopList[iViewIdx] = NULL;
830    }
831    if( iViewIdx < Int( m_picYuvDepthRec.size() ) && m_picYuvDepthRec[iViewIdx] )
832    {
833      delete m_picYuvDepthRec[iViewIdx] ; 
834      m_picYuvDepthRec[iViewIdx] = NULL;
835    }
836  }
837}
838
839Void TAppEncTop::xInitLib()
840{
841  for(Int iViewIdx=0; iViewIdx<m_iNumberOfViews; iViewIdx++)
842  {
843    m_acTEncTopList[iViewIdx]->init( this );
844#if QC_MVHEVC_B0046
845  //set setNumDirectRefLayer
846  Int iNumDirectRef = m_acTEncTopList[iViewIdx]->getSPS()->getNumberOfUsableInterViewRefs();
847  m_acTEncTopList[iViewIdx]->getEncTop()->getVPS()->setNumDirectRefLayer(iNumDirectRef, iViewIdx);
848  for(Int iNumIvRef = 0; iNumIvRef < iNumDirectRef; iNumIvRef ++)
849  {
850    Int iLayerId = m_acTEncTopList[iViewIdx]->getSPS()->getUsableInterViewRef(iNumIvRef);
851    m_acTEncTopList[iViewIdx]->getEncTop()->getVPS()->setDirectRefLayerId( iLayerId + iViewIdx, iViewIdx, iNumIvRef);
852  }
853#endif
854  }
855  for(Int iViewIdx=0; iViewIdx<m_iNumberOfViews; iViewIdx++)
856  {
857    m_acTEncTopList[iViewIdx]->setTEncTopList( &m_acTEncTopList  );
858  }
859  if ( m_bUsingDepthMaps )
860  {
861    for(Int iViewIdx=0; iViewIdx<m_iNumberOfViews; iViewIdx++)
862    {
863      m_acTEncDepthTopList[iViewIdx]->init( this );
864    }
865    for(Int iViewIdx=0; iViewIdx<m_iNumberOfViews; iViewIdx++)
866    {
867      m_acTEncDepthTopList[iViewIdx]->setTEncTopList( &m_acTEncDepthTopList  );
868    }
869  }
870}
871
872// ====================================================================================================================
873// Public member functions
874// ====================================================================================================================
875
876/**
877 - create internal class
878 - initialize internal variable
879 - until the end of input YUV file, call encoding function in TEncTop class
880 - delete allocated buffers
881 - destroy internal class
882 .
883 */
884Void TAppEncTop::encode()
885{
886  fstream bitstreamFile(m_pchBitstreamFile, fstream::binary | fstream::out);
887  if (!bitstreamFile)
888  {
889    fprintf(stderr, "\nfailed to open bitstream file `%s' for writing\n", m_pchBitstreamFile);
890    exit(EXIT_FAILURE);
891  }
892
893  TComPicYuv*       pcPicYuvOrg = new TComPicYuv;
894  TComPicYuv*       pcDepthPicYuvOrg = new TComPicYuv;
895#if !QC_MVHEVC_B0046
896  TComPicYuv*       pcPdmDepthOrg    = new TComPicYuv;
897#endif
898  TComPicYuv*       pcPicYuvRec = NULL;
899  TComPicYuv*       pcDepthPicYuvRec = NULL;
900 
901  // initialize internal class & member variables
902  xInitLibCfg();
903  xCreateLib();
904  xInitLib();
905 
906  // main encoder loop
907  Bool  allEos = false;
908  std::vector<Bool>  eos ;
909  std::vector<Bool>  depthEos ;
910  Int maxGopSize = 0;
911  Int gopSize = 1;
912 
913  list<AccessUnit> outputAccessUnits; ///< list of access units to write out.  is populated by the encoding process
914  maxGopSize = (std::max)(maxGopSize, m_acTEncTopList[0]->getGOPSize());   
915
916  for(Int iViewIdx=0; iViewIdx < m_iNumberOfViews; iViewIdx++ )
917  {
918    eos.push_back( false );
919    depthEos.push_back( false );
920   
921#if RWTH_SDC_DLT_B0036
922    if( m_bUsingDepthMaps && m_bUseDLT )
923      xAnalyzeInputBaseDepth(iViewIdx, m_iIntraPeriod);
924#endif
925  }
926
927  // allocate original YUV buffer
928  pcPicYuvOrg->create( m_iSourceWidth, m_iSourceHeight, m_uiMaxCUWidth, m_uiMaxCUHeight, m_uiMaxCUDepth );
929  pcDepthPicYuvOrg->create( m_iSourceWidth, m_iSourceHeight, m_uiMaxCUWidth, m_uiMaxCUHeight, m_uiMaxCUDepth );
930
931#if HHI_INTER_VIEW_MOTION_PRED
932  if( m_uiMultiviewMvRegMode )
933  {
934    pcPdmDepthOrg->create( m_iSourceWidth, m_iSourceHeight, m_uiMaxCUWidth, m_uiMaxCUHeight, m_uiMaxCUDepth );
935  }
936#endif
937
938  while ( !allEos )
939  {
940    for(Int iViewIdx=0; iViewIdx < m_iNumberOfViews; iViewIdx++ )
941    {
942      Int frmCnt = 0;
943      while ( !eos[iViewIdx] && !(frmCnt == gopSize))
944      {
945        // get buffers
946        xGetBuffer(pcPicYuvRec, iViewIdx, false);
947
948        // read input YUV file
949        m_acTVideoIOYuvInputFileList[iViewIdx]->read( pcPicYuvOrg, m_aiPad );
950     
951#if HHI_INTER_VIEW_MOTION_PRED
952        if( m_uiMultiviewMvRegMode && iViewIdx )
953        {
954          m_acTVideoIOYuvDepthInputFileList[iViewIdx]->read( pcPdmDepthOrg, m_aiPad, m_bUsingDepthMaps );
955        }
956#endif
957
958#if HHI_INTER_VIEW_MOTION_PRED
959        m_acTEncTopList[iViewIdx]->initNewPic( pcPicYuvOrg, ( m_uiMultiviewMvRegMode && iViewIdx ? pcPdmDepthOrg : 0 ) );
960#else
961        m_acTEncTopList[iViewIdx]->initNewPic( pcPicYuvOrg );
962#endif
963
964        // increase number of received frames
965        m_frameRcvd[iViewIdx]++;
966        frmCnt++;
967        // check end of file
968        eos[iViewIdx] = ( m_acTVideoIOYuvInputFileList[iViewIdx]->isEof() == 1 ?   true : false  );
969        eos[iViewIdx] = ( m_frameRcvd[iViewIdx] == m_iFrameToBeEncoded ?    true : eos[iViewIdx]   );
970        allEos = allEos|eos[iViewIdx] ; 
971      }
972      if( m_bUsingDepthMaps )
973      {
974        Int frmCntDepth = 0;
975        while ( !depthEos[iViewIdx] && !(frmCntDepth == gopSize))
976        {
977          // get buffers
978          xGetBuffer(pcDepthPicYuvRec, iViewIdx, true);
979
980          // read input YUV file
981          m_acTVideoIOYuvDepthInputFileList[iViewIdx]->read( pcDepthPicYuvOrg, m_aiPad );
982
983          m_acTEncDepthTopList[iViewIdx]->initNewPic( pcDepthPicYuvOrg );
984
985          // increase number of received frames
986          m_depthFrameRcvd[iViewIdx]++;
987          frmCntDepth++;
988          // check end of file
989          depthEos[iViewIdx] = ( m_acTVideoIOYuvDepthInputFileList[iViewIdx]->isEof() == 1 ?   true : false  );
990          depthEos[iViewIdx] = ( m_depthFrameRcvd[iViewIdx] == m_iFrameToBeEncoded ?    true : depthEos[iViewIdx]   );
991          allEos = allEos|depthEos[iViewIdx] ; 
992        }
993      }
994    }
995    for ( Int gopId=0; gopId < gopSize; gopId++ )
996    {
997      Int  iNumEncoded = 0;
998#if !QC_MVHEVC_B0046
999      UInt iNextPoc = m_acTEncTopList[0] -> getFrameId( gopId );
1000      if ( iNextPoc < m_iFrameToBeEncoded )
1001      {
1002      m_cCameraData.update( iNextPoc );
1003      }
1004#endif
1005      for(Int iViewIdx=0; iViewIdx < m_iNumberOfViews; iViewIdx++ )
1006      {
1007#if SAIT_VSO_EST_A0033
1008        if( m_bUseVSO && iNextPoc < m_iFrameToBeEncoded )
1009        {
1010          m_cCameraData.xSetDispCoeff( iNextPoc, iViewIdx );
1011          m_acTEncDepthTopList[iViewIdx]->setDispCoeff( m_cCameraData.getDispCoeff() );
1012        }
1013#endif
1014        iNumEncoded = 0;
1015        // call encoding function for one frame
1016        m_acTEncTopList[iViewIdx]->encode( eos[iViewIdx], pcPicYuvOrg, *m_picYuvRec[iViewIdx], outputAccessUnits, iNumEncoded, gopId );
1017        xWriteOutput(bitstreamFile, iNumEncoded, outputAccessUnits, iViewIdx, false);
1018        outputAccessUnits.clear();
1019        if( m_bUsingDepthMaps )
1020        {
1021          Int  iNumDepthEncoded = 0;
1022          // call encoding function for one depth frame
1023          m_acTEncDepthTopList[iViewIdx]->encode( depthEos[iViewIdx], pcDepthPicYuvOrg, *m_picYuvDepthRec[iViewIdx], outputAccessUnits, iNumDepthEncoded, gopId );
1024          xWriteOutput(bitstreamFile, iNumDepthEncoded, outputAccessUnits, iViewIdx, true);
1025          outputAccessUnits.clear();
1026        }
1027      }
1028#if HHI_INTERVIEW_SKIP || HHI_INTER_VIEW_MOTION_PRED || HHI_INTER_VIEW_RESIDUAL_PRED
1029      for( Int iViewIdx = 0; iViewIdx < m_iNumberOfViews; iViewIdx++ )
1030      {
1031        if( iViewIdx < (Int)m_acTEncTopList.size() && m_acTEncTopList[iViewIdx] )
1032        {
1033          m_acTEncTopList[iViewIdx]->deleteExtraPicBuffers( m_acTEncTopList[iViewIdx]->getGOPEncoder()->getPocLastCoded() );
1034        }
1035        if( iViewIdx < (Int)m_acTEncDepthTopList.size() && m_acTEncDepthTopList[iViewIdx] )
1036        {
1037          m_acTEncDepthTopList[iViewIdx]->deleteExtraPicBuffers( m_acTEncTopList[iViewIdx]->getGOPEncoder()->getPocLastCoded() );
1038        }
1039      }
1040#endif
1041      for(Int iViewIdx=0; iViewIdx < m_iNumberOfViews; iViewIdx++ )
1042      {
1043        m_acTEncTopList[iViewIdx]->compressMotion( m_acTEncTopList[iViewIdx]->getGOPEncoder()->getPocLastCoded() );
1044        if( m_bUsingDepthMaps )
1045        {
1046          m_acTEncDepthTopList[iViewIdx]->compressMotion( m_acTEncDepthTopList[iViewIdx]->getGOPEncoder()->getPocLastCoded() );
1047        }
1048      }
1049    }
1050    gopSize = maxGopSize;
1051  }
1052  // delete original YUV buffer
1053  pcPicYuvOrg->destroy();
1054  delete pcPicYuvOrg;
1055  pcPicYuvOrg = NULL;
1056  pcDepthPicYuvOrg->destroy();
1057  delete pcDepthPicYuvOrg;
1058  pcDepthPicYuvOrg = NULL;
1059
1060#if !QC_MVHEVC_B0046
1061#if FIX_DEL_NULLPTR
1062  if ( pcPdmDepthOrg != NULL && m_uiMultiviewMvRegMode )
1063#else
1064  if ( pcPdmDepthOrg != NULL )
1065#endif
1066  {
1067    pcPdmDepthOrg->destroy();
1068    delete pcPdmDepthOrg;     
1069    pcPdmDepthOrg = NULL; 
1070  };
1071#endif
1072 
1073  for(Int iViewIdx=0; iViewIdx < m_iNumberOfViews; iViewIdx++ )
1074  {
1075    m_acTEncTopList[iViewIdx]->printOutSummary(m_acTEncTopList[iViewIdx]->getNumAllPicCoded());
1076    if ( m_bUsingDepthMaps )
1077    {
1078      m_acTEncDepthTopList[iViewIdx]->printOutSummary(m_acTEncDepthTopList[iViewIdx]->getNumAllPicCoded());
1079    }
1080  }
1081
1082  // delete buffers & classes
1083  xDeleteBuffer();
1084  xDestroyLib();
1085
1086  return;
1087}
1088
1089TEncTop*  TAppEncTop::getTEncTop( Int viewId, Bool isDepth )   
1090{ 
1091  if ( isDepth ) 
1092  {
1093    return m_acTEncDepthTopList[viewId]; 
1094  } 
1095  else
1096  { 
1097    return m_acTEncTopList[viewId]; 
1098  } 
1099}
1100
1101
1102// ====================================================================================================================
1103// Protected member functions
1104// ====================================================================================================================
1105
1106/**
1107 - application has picture buffer list with size of GOP
1108 - picture buffer list acts as ring buffer
1109 - end of the list has the latest picture
1110 .
1111 */
1112Void TAppEncTop::xGetBuffer( TComPicYuv*& rpcPicYuvRec, Int iViewIdx, Bool isDepth)
1113{
1114  assert( m_iGOPSize > 0 );
1115 
1116  if( !isDepth )
1117  {
1118    if ( m_picYuvRec[iViewIdx]->size() == (UInt)m_iGOPSize )
1119    {
1120      rpcPicYuvRec = m_picYuvRec[iViewIdx]->popFront();
1121    }
1122    else
1123    {
1124      rpcPicYuvRec = new TComPicYuv; 
1125      rpcPicYuvRec->create( m_iSourceWidth, m_iSourceHeight, m_uiMaxCUWidth, m_uiMaxCUHeight, m_uiMaxCUDepth );
1126    }
1127    m_picYuvRec[iViewIdx]->pushBack( rpcPicYuvRec );
1128  }
1129  else
1130  {
1131    if ( m_picYuvDepthRec[iViewIdx]->size() == (UInt)m_iGOPSize )
1132    {
1133      rpcPicYuvRec = m_picYuvDepthRec[iViewIdx]->popFront();
1134    }
1135    else
1136    {
1137      rpcPicYuvRec = new TComPicYuv; 
1138      rpcPicYuvRec->create( m_iSourceWidth, m_iSourceHeight, m_uiMaxCUWidth, m_uiMaxCUHeight, m_uiMaxCUDepth );
1139    }
1140    m_picYuvDepthRec[iViewIdx]->pushBack( rpcPicYuvRec );
1141  }
1142}
1143
1144Void TAppEncTop::xDeleteBuffer( )
1145{
1146  for(Int iViewIdx=0; iViewIdx<m_picYuvRec.size(); iViewIdx++)
1147  {
1148    if(m_picYuvRec[iViewIdx])
1149    {
1150      TComList<TComPicYuv*>::iterator iterPicYuvRec  = m_picYuvRec[iViewIdx]->begin();
1151      Int iSize = Int( m_picYuvRec[iViewIdx]->size() );
1152      for ( Int i = 0; i < iSize; i++ )
1153      {
1154        TComPicYuv*  pcPicYuvRec  = *(iterPicYuvRec++);
1155        if(pcPicYuvRec)
1156        {
1157          pcPicYuvRec->destroy();
1158          delete pcPicYuvRec; 
1159          pcPicYuvRec = NULL;
1160        }
1161      }
1162    } 
1163  }
1164  for(Int iViewIdx=0; iViewIdx<m_picYuvDepthRec.size(); iViewIdx++)
1165  {
1166    if(m_picYuvDepthRec[iViewIdx])
1167    {
1168      TComList<TComPicYuv*>::iterator iterPicYuvRec  = m_picYuvDepthRec[iViewIdx]->begin();
1169      Int iSize = Int( m_picYuvDepthRec[iViewIdx]->size() );
1170      for ( Int i = 0; i < iSize; i++ )
1171      {
1172        TComPicYuv*  pcPicYuvRec  = *(iterPicYuvRec++);
1173        if(pcPicYuvRec)
1174        {
1175          pcPicYuvRec->destroy();
1176          delete pcPicYuvRec; 
1177          pcPicYuvRec = NULL;
1178        }
1179      } 
1180    }
1181  }
1182}
1183
1184/** \param iNumEncoded  number of encoded frames
1185 */
1186Void TAppEncTop::xWriteOutput(std::ostream& bitstreamFile, Int iNumEncoded, std::list<AccessUnit>& accessUnits, Int iViewIdx, Bool isDepth )
1187{
1188  Int i;
1189 
1190  if( iNumEncoded > 0 )
1191  {
1192    TComList<TComPicYuv*>::iterator iterPicYuvRec = !isDepth ? m_picYuvRec[iViewIdx]->end() : m_picYuvDepthRec[iViewIdx]->end();
1193 
1194    for ( i = 0; i < iNumEncoded; i++ )
1195    {
1196      --iterPicYuvRec;
1197    }
1198 
1199    for ( i = 0; i < iNumEncoded; i++ )
1200    {
1201      TComPicYuv*  pcPicYuvRec  = *(iterPicYuvRec++);
1202      if( !isDepth )
1203      {
1204        if (m_pchReconFileList[iViewIdx])
1205        {
1206#if PIC_CROPPING
1207          m_acTVideoIOYuvReconFileList[iViewIdx]->write( pcPicYuvRec, m_cropLeft, m_cropRight, m_cropTop, m_cropBottom );
1208#else
1209          m_acTVideoIOYuvReconFileList[iViewIdx]->write( pcPicYuvRec, m_aiPad );
1210#endif
1211        }
1212      }
1213      else
1214      {
1215        if (m_pchDepthReconFileList[iViewIdx])
1216        {
1217#if PIC_CROPPING
1218          m_acTVideoIOYuvDepthReconFileList[iViewIdx]->write( pcPicYuvRec, m_cropLeft, m_cropRight, m_cropTop, m_cropBottom );
1219#else
1220          m_acTVideoIOYuvDepthReconFileList[iViewIdx]->write( pcPicYuvRec, m_aiPad );
1221#endif
1222        }
1223      }
1224    }
1225  }
1226  if( ! accessUnits.empty() )
1227  {
1228    list<AccessUnit>::iterator aUIter;
1229    for( aUIter = accessUnits.begin(); aUIter != accessUnits.end(); aUIter++ )
1230    {
1231      const vector<unsigned>& stats = writeAnnexB(bitstreamFile, *aUIter);
1232      rateStatsAccum(*aUIter, stats);
1233    }
1234  }
1235}
1236
1237
1238TComPicYuv* TAppEncTop::xGetPicYuvFromView( Int iViewIdx, Int iPoc, Bool bDepth, Bool bRecon )
1239{
1240  TComPic*    pcPic = xGetPicFromView( iViewIdx, iPoc, bDepth);
1241  TComPicYuv* pcPicYuv = NULL;
1242
1243  if (pcPic != NULL)
1244  {
1245    if( bRecon )
1246    {
1247      if ( pcPic->getReconMark() )
1248      {
1249        pcPicYuv = pcPic->getPicYuvRec();
1250      }
1251    }
1252    else
1253    {
1254      pcPicYuv = pcPic->getPicYuvOrg();
1255    }
1256  };
1257
1258  return pcPicYuv;
1259};
1260
1261/**
1262 *
1263 */
1264void TAppEncTop::rateStatsAccum(const AccessUnit& au, const std::vector<unsigned>& annexBsizes)
1265{
1266  AccessUnit::const_iterator it_au = au.begin();
1267  vector<unsigned>::const_iterator it_stats = annexBsizes.begin();
1268
1269  for (; it_au != au.end(); it_au++, it_stats++)
1270  {
1271    switch ((*it_au)->m_nalUnitType)
1272    {
1273    case NAL_UNIT_CODED_SLICE:
1274#if H0566_TLA
1275#if !QC_REM_IDV_B0046
1276    case NAL_UNIT_CODED_SLICE_IDV:
1277#endif
1278    case NAL_UNIT_CODED_SLICE_TLA:
1279    case NAL_UNIT_CODED_SLICE_CRA:
1280#else
1281    case NAL_UNIT_CODED_SLICE_DATAPART_A:
1282    case NAL_UNIT_CODED_SLICE_DATAPART_B:
1283    case NAL_UNIT_CODED_SLICE_CDR:
1284#endif
1285    case NAL_UNIT_CODED_SLICE_IDR:
1286    case NAL_UNIT_SPS:
1287    case NAL_UNIT_PPS:
1288#if VIDYO_VPS_INTEGRATION
1289    case NAL_UNIT_VPS:
1290#endif
1291      m_essentialBytes += *it_stats;
1292      break;
1293    default:
1294      break;
1295    }
1296
1297    m_totalBytes += *it_stats;
1298  }
1299}
1300
1301#if HHI_INTERVIEW_SKIP
1302Void TAppEncTop::getUsedPelsMap( Int iViewIdx, Int iPoc, TComPicYuv* pcPicYuvUsedSplsMap )
1303{
1304  AOT( iViewIdx <= 0);
1305  AOT( iViewIdx >= m_iNumberOfViews );
1306  AOF( m_cCameraData.getCurFrameId() == iPoc );
1307  Int iViewSIdx      = m_cCameraData.getBaseId2SortedId()[iViewIdx];
1308  Int iFirstViewSIdx = m_cCameraData.getBaseId2SortedId()[0];
1309
1310  AOT( iViewSIdx == iFirstViewSIdx );
1311
1312  Bool bFirstIsLeft = (iFirstViewSIdx < iViewSIdx);
1313
1314  m_cUsedPelsRenderer.setShiftLUTs(
1315      m_cCameraData.getBaseViewShiftLUTD()[0][iViewIdx],
1316      m_cCameraData.getBaseViewShiftLUTI()[0][iViewIdx],
1317      m_cCameraData.getBaseViewShiftLUTI()[0][iViewIdx],
1318      m_cCameraData.getBaseViewShiftLUTD()[0][iViewIdx],
1319      m_cCameraData.getBaseViewShiftLUTI()[0][iViewIdx],
1320      m_cCameraData.getBaseViewShiftLUTI()[0][iViewIdx],
1321      -1
1322      );
1323
1324  TComPicYuv* pcPicYuvDepth = xGetPicYuvFromView(0, iPoc, true, true );
1325  AOF( pcPicYuvDepth);
1326
1327  m_cUsedPelsRenderer.getUsedSamplesMap( pcPicYuvDepth, pcPicYuvUsedSplsMap, bFirstIsLeft );
1328}
1329#endif
1330#if HHI_VSO
1331Void TAppEncTop::setupRenModel( Int iPoc, Int iEncViewIdx, Int iEncContent, Int iHorOffset )
1332{
1333  m_cRendererModel.setupPart( iHorOffset, Min( g_uiMaxCUHeight, m_iSourceHeight - iHorOffset ) ); 
1334  Int iEncViewSIdx = m_cCameraData.getBaseId2SortedId()[ iEncViewIdx ];
1335
1336  // setup base views
1337  Int iNumOfBV = m_cRenModStrParser.getNumOfBaseViewsForView( iEncViewSIdx, iEncContent );
1338
1339  for (Int iCurView = 0; iCurView < iNumOfBV; iCurView++ )
1340  {
1341    Int iBaseViewSIdx;
1342    Int iVideoDistMode;
1343    Int iDepthDistMode;
1344
1345    m_cRenModStrParser.getBaseViewData( iEncViewSIdx, iEncContent, iCurView, iBaseViewSIdx, iVideoDistMode, iDepthDistMode );
1346
1347    AOT( iVideoDistMode < 0 || iVideoDistMode > 2 );
1348
1349    Int iBaseViewIdx = m_cCameraData.getBaseSortedId2Id()[ iBaseViewSIdx ];
1350
1351    TComPicYuv* pcPicYuvVideoRec  = xGetPicYuvFromView( iBaseViewIdx, iPoc, false, true  );
1352    TComPicYuv* pcPicYuvDepthRec  = xGetPicYuvFromView( iBaseViewIdx, iPoc, true , true  );
1353    TComPicYuv* pcPicYuvVideoOrg  = xGetPicYuvFromView( iBaseViewIdx, iPoc, false, false );
1354    TComPicYuv* pcPicYuvDepthOrg  = xGetPicYuvFromView( iBaseViewIdx, iPoc, true , false );
1355
1356    TComPicYuv* pcPicYuvVideoRef  = ( iVideoDistMode == 2 ) ? pcPicYuvVideoOrg  : NULL;
1357    TComPicYuv* pcPicYuvDepthRef  = ( iDepthDistMode == 2 ) ? pcPicYuvDepthOrg  : NULL;
1358
1359    TComPicYuv* pcPicYuvVideoTest = ( iVideoDistMode == 0 ) ? pcPicYuvVideoOrg  : pcPicYuvVideoRec;
1360    TComPicYuv* pcPicYuvDepthTest = ( iDepthDistMode == 0 ) ? pcPicYuvDepthOrg  : pcPicYuvDepthRec;
1361
1362    AOT( (iVideoDistMode == 2) != (pcPicYuvVideoRef != NULL) );
1363    AOT( (iDepthDistMode == 2) != (pcPicYuvDepthRef != NULL) );
1364    AOT( pcPicYuvDepthTest == NULL );
1365    AOT( pcPicYuvVideoTest == NULL );
1366
1367    m_cRendererModel.setBaseView( iBaseViewSIdx, pcPicYuvVideoTest, pcPicYuvDepthTest, pcPicYuvVideoRef, pcPicYuvDepthRef );
1368  }
1369
1370  m_cRendererModel.setErrorMode( iEncViewSIdx, iEncContent, 0 );
1371  // setup virtual views
1372  Int iNumOfSV  = m_cRenModStrParser.getNumOfModelsForView( iEncViewSIdx, iEncContent );
1373  for (Int iCurView = 0; iCurView < iNumOfSV; iCurView++ )
1374  {
1375    Int iOrgRefBaseViewSIdx;
1376    Int iLeftBaseViewSIdx;
1377    Int iRightBaseViewSIdx;
1378    Int iSynthViewRelNum;
1379    Int iModelNum;
1380    Int iBlendMode;
1381    m_cRenModStrParser.getSingleModelData(iEncViewSIdx, iEncContent, iCurView, iModelNum, iBlendMode,iLeftBaseViewSIdx, iRightBaseViewSIdx, iOrgRefBaseViewSIdx, iSynthViewRelNum );
1382
1383    Int iLeftBaseViewIdx    = -1;
1384    Int iRightBaseViewIdx   = -1;
1385
1386    TComPicYuv* pcPicYuvOrgRef  = NULL;
1387    Int**      ppiShiftLUTLeft  = NULL;
1388    Int**      ppiShiftLUTRight = NULL;
1389    Int**      ppiBaseShiftLUTLeft  = NULL;
1390    Int**      ppiBaseShiftLUTRight = NULL;
1391
1392
1393    Int        iDistToLeft      = -1;
1394
1395    Int iSynthViewIdx = m_cCameraData.synthRelNum2Idx( iSynthViewRelNum );
1396
1397    if ( iLeftBaseViewSIdx != -1 )
1398    {
1399      iLeftBaseViewIdx   = m_cCameraData.getBaseSortedId2Id()   [ iLeftBaseViewSIdx ];
1400      ppiShiftLUTLeft    = m_cCameraData.getSynthViewShiftLUTI()[ iLeftBaseViewIdx  ][ iSynthViewIdx  ];
1401    }
1402
1403    if ( iRightBaseViewSIdx != -1 )
1404    {
1405      iRightBaseViewIdx  = m_cCameraData.getBaseSortedId2Id()   [iRightBaseViewSIdx ];
1406      ppiShiftLUTRight   = m_cCameraData.getSynthViewShiftLUTI()[ iRightBaseViewIdx ][ iSynthViewIdx ];
1407    }
1408
1409    if ( iRightBaseViewSIdx != -1 && iLeftBaseViewSIdx != -1 )
1410    {
1411      iDistToLeft    = m_cCameraData.getRelDistLeft(  iSynthViewIdx , iLeftBaseViewIdx, iRightBaseViewIdx);
1412      ppiBaseShiftLUTLeft  = m_cCameraData.getBaseViewShiftLUTI() [ iLeftBaseViewIdx  ][ iRightBaseViewIdx ];
1413      ppiBaseShiftLUTRight = m_cCameraData.getBaseViewShiftLUTI() [ iRightBaseViewIdx ][ iLeftBaseViewIdx  ];
1414
1415    }
1416
1417    if ( iOrgRefBaseViewSIdx != -1 )
1418    {
1419      pcPicYuvOrgRef = xGetPicYuvFromView( m_cCameraData.getBaseSortedId2Id()[ iOrgRefBaseViewSIdx ] , iPoc, false, false );
1420      AOF ( pcPicYuvOrgRef );
1421    }
1422
1423    m_cRendererModel.setSingleModel( iModelNum, ppiShiftLUTLeft, ppiBaseShiftLUTLeft, ppiShiftLUTRight, ppiBaseShiftLUTRight, iDistToLeft, pcPicYuvOrgRef );
1424  }
1425}
1426#endif
1427
1428
1429
1430/*
1431void TAppEncTop::printRateSummary()
1432{
1433  double time = (double) m_iFrameRcvd / m_iFrameRate;
1434  printf("Bytes written to file: %u (%.3f kbps)\n", m_totalBytes, 0.008 * m_totalBytes / time);
1435#if VERBOSE_RATE
1436  printf("Bytes for SPS/PPS/Slice (Incl. Annex B): %u (%.3f kbps)\n", m_essentialBytes, 0.008 * m_essentialBytes / time);
1437#endif
1438}
1439*/
1440
1441std::vector<TComPic*> TAppEncTop::getInterViewRefPics( Int viewId, Int poc, Bool isDepth, TComSPS* sps )
1442{
1443  std::vector<TComPic*> apcRefPics( sps->getNumberOfUsableInterViewRefs(), (TComPic*)NULL );
1444  for( Int k = 0; k < sps->getNumberOfUsableInterViewRefs(); k++ )
1445  {
1446    TComPic* pcRefPic = xGetPicFromView( sps->getUsableInterViewRef( k ) + viewId, poc, isDepth );
1447    assert( pcRefPic != NULL );
1448    apcRefPics[k] = pcRefPic;
1449  }
1450  return apcRefPics;
1451}
1452
1453TComPic* TAppEncTop::xGetPicFromView( Int viewIdx, Int poc, Bool isDepth )
1454{
1455  assert( ( viewIdx >= 0 ) && ( viewIdx < m_iNumberOfViews ) );
1456
1457  TComList<TComPic*>* apcListPic = (isDepth ?  m_acTEncDepthTopList[viewIdx] : m_acTEncTopList[viewIdx])->getListPic() ;
1458
1459  TComPic* pcPic = NULL;
1460  for(TComList<TComPic*>::iterator it=apcListPic->begin(); it!=apcListPic->end(); it++)
1461  {
1462    if( (*it)->getPOC() == poc )
1463    {
1464      pcPic = *it ;
1465      break ;
1466    }
1467  }
1468
1469  return pcPic;
1470};
1471 
1472#if RWTH_SDC_DLT_B0036
1473Void TAppEncTop::xAnalyzeInputBaseDepth(Int iViewIdx, UInt uiNumFrames)
1474{
1475  TComPicYuv*       pcDepthPicYuvOrg = new TComPicYuv;
1476  // allocate original YUV buffer
1477  pcDepthPicYuvOrg->create( m_iSourceWidth, m_iSourceHeight, m_uiMaxCUWidth, m_uiMaxCUHeight, m_uiMaxCUDepth );
1478 
1479  TVideoIOYuv* depthVideoFile = new TVideoIOYuv;
1480 
1481  UInt uiMaxDepthValue = g_uiIBDI_MAX;
1482 
1483  Bool abValidDepths[256];
1484 
1485  depthVideoFile->open( m_pchDepthInputFileList[iViewIdx], false, m_uiInputBitDepth, m_uiInternalBitDepth );  // read  mode
1486 
1487  // initialize boolean array
1488  for(Int p=0; p<=uiMaxDepthValue; p++)
1489    abValidDepths[p] = false;
1490 
1491  Int iHeight   = pcDepthPicYuvOrg->getHeight();
1492  Int iWidth    = pcDepthPicYuvOrg->getWidth();
1493  Int iStride   = pcDepthPicYuvOrg->getStride();
1494 
1495  Pel* pInDM    = pcDepthPicYuvOrg->getLumaAddr();
1496 
1497  for(Int uiFrame=0; uiFrame < uiNumFrames; uiFrame++ )
1498  {
1499    depthVideoFile->read( pcDepthPicYuvOrg, m_aiPad, false );
1500   
1501    // check all pixel values
1502    for (Int i=0; i<iHeight; i++)
1503    {
1504      Int rowOffset = i*iStride;
1505     
1506      for (Int j=0; j<iWidth; j++)
1507      {
1508        Pel depthValue = pInDM[rowOffset+j];
1509        abValidDepths[depthValue] = true;
1510      }
1511    }
1512  }
1513 
1514  depthVideoFile->close();
1515 
1516  pcDepthPicYuvOrg->destroy();
1517  delete pcDepthPicYuvOrg;
1518 
1519  // convert boolean array to idx2Depth LUT
1520  UInt* auiIdx2DepthValue = (UInt*) calloc(uiMaxDepthValue, sizeof(UInt));
1521  UInt uiNumDepthValues = 0;
1522  for(UInt p=0; p<=uiMaxDepthValue; p++)
1523  {
1524    if( abValidDepths[p] == true)
1525    {
1526      auiIdx2DepthValue[uiNumDepthValues++] = p;
1527    }
1528  }
1529 
1530  if( uiNumFrames == 0 || ceil(Log2(uiNumDepthValues)) == ceil(Log2(g_uiIBDI_MAX)) )
1531  {
1532    // don't use DLT
1533    m_acTEncDepthTopList[iViewIdx]->setUseDLT(false);
1534    m_acTEncDepthTopList[iViewIdx]->getSPS()->setUseDLT(false);
1535  }
1536 
1537  // assign LUT
1538  if( m_acTEncDepthTopList[iViewIdx]->getUseDLT() )
1539    m_acTEncDepthTopList[iViewIdx]->getSPS()->setDepthLUTs(auiIdx2DepthValue, uiNumDepthValues);
1540  else
1541    m_acTEncDepthTopList[iViewIdx]->getSPS()->setDepthLUTs();
1542 
1543  // free temporary memory
1544  free(auiIdx2DepthValue);
1545}
1546#endif
1547
1548//! \}
Note: See TracBrowser for help on using the repository browser.