source: 3DVCSoftware/branches/HTM-8.0-dev0/source/Lib/TLibEncoder/TEncTop.cpp @ 621

Last change on this file since 621 was 621, checked in by tech, 11 years ago

Fixed xRestrictBipredMergeCand call.
Other minor cleanups.

  • Property svn:eol-style set to native
File size: 41.6 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-2013, 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     TEncTop.cpp
35    \brief    encoder class
36*/
37
38#include "TLibCommon/CommonDef.h"
39#include "TEncTop.h"
40#include "TEncPic.h"
41#if FAST_BIT_EST
42#include "TLibCommon/ContextModel.h"
43#endif
44#if H_MV
45#include "../../App/TAppEncoder/TAppEncTop.h"
46#endif
47
48//! \ingroup TLibEncoder
49//! \{
50
51// ====================================================================================================================
52// Constructor / destructor / create / destroy
53// ====================================================================================================================
54
55TEncTop::TEncTop()
56{
57  m_iPOCLast          = -1;
58  m_iNumPicRcvd       =  0;
59  m_uiNumAllPicCoded  =  0;
60  m_pppcRDSbacCoder   =  NULL;
61  m_pppcBinCoderCABAC =  NULL;
62  m_cRDGoOnSbacCoder.init( &m_cRDGoOnBinCoderCABAC );
63#if ENC_DEC_TRACE
64  g_hTrace = fopen( "TraceEnc.txt", "wb" );
65  g_bJustDoIt = g_bEncDecTraceDisable;
66  g_nSymbolCounter = 0;
67#endif
68
69  m_iMaxRefPicNum     = 0;
70
71#if FAST_BIT_EST
72  ContextModel::buildNextStateTable();
73#endif
74
75  m_pcSbacCoders           = NULL;
76  m_pcBinCoderCABACs       = NULL;
77  m_ppppcRDSbacCoders      = NULL;
78  m_ppppcBinCodersCABAC    = NULL;
79  m_pcRDGoOnSbacCoders     = NULL;
80  m_pcRDGoOnBinCodersCABAC = NULL;
81  m_pcBitCounters          = NULL;
82  m_pcRdCosts              = NULL;
83#if H_MV
84  m_ivPicLists = NULL;
85#endif
86}
87
88TEncTop::~TEncTop()
89{
90#if ENC_DEC_TRACE
91  fclose( g_hTrace );
92#endif
93}
94
95Void TEncTop::create ()
96{
97#if !H_MV
98  // initialize global variables
99  initROM();
100#endif
101 
102  // create processing unit classes
103  m_cGOPEncoder.        create();
104  m_cSliceEncoder.      create( getSourceWidth(), getSourceHeight(), g_uiMaxCUWidth, g_uiMaxCUHeight, g_uiMaxCUDepth );
105  m_cCuEncoder.         create( g_uiMaxCUDepth, g_uiMaxCUWidth, g_uiMaxCUHeight );
106  if (m_bUseSAO)
107  {
108    m_cEncSAO.setSaoLcuBoundary(getSaoLcuBoundary());
109    m_cEncSAO.setSaoLcuBasedOptimization(getSaoLcuBasedOptimization());
110    m_cEncSAO.setMaxNumOffsetsPerPic(getMaxNumOffsetsPerPic());
111    m_cEncSAO.create( getSourceWidth(), getSourceHeight(), g_uiMaxCUWidth, g_uiMaxCUHeight );
112    m_cEncSAO.createEncBuffer();
113  }
114#if ADAPTIVE_QP_SELECTION
115  if (m_bUseAdaptQpSelect)
116  {
117    m_cTrQuant.initSliceQpDelta();
118  }
119#endif
120  m_cLoopFilter.        create( g_uiMaxCUDepth );
121
122#if RATE_CONTROL_LAMBDA_DOMAIN
123  if ( m_RCEnableRateControl )
124  {
125    m_cRateCtrl.init( m_framesToBeEncoded, m_RCTargetBitrate, m_iFrameRate, m_iGOPSize, m_iSourceWidth, m_iSourceHeight,
126                      g_uiMaxCUWidth, g_uiMaxCUHeight, m_RCKeepHierarchicalBit, m_RCUseLCUSeparateModel, m_GOPList );
127  }
128#else
129  m_cRateCtrl.create(getIntraPeriod(), getGOPSize(), getFrameRate(), getTargetBitrate(), getQP(), getNumLCUInUnit(), getSourceWidth(), getSourceHeight(), g_uiMaxCUWidth, g_uiMaxCUHeight);
130#endif
131  // if SBAC-based RD optimization is used
132  if( m_bUseSBACRD )
133  {
134    m_pppcRDSbacCoder = new TEncSbac** [g_uiMaxCUDepth+1];
135#if FAST_BIT_EST
136    m_pppcBinCoderCABAC = new TEncBinCABACCounter** [g_uiMaxCUDepth+1];
137#else
138    m_pppcBinCoderCABAC = new TEncBinCABAC** [g_uiMaxCUDepth+1];
139#endif
140   
141    for ( Int iDepth = 0; iDepth < g_uiMaxCUDepth+1; iDepth++ )
142    {
143      m_pppcRDSbacCoder[iDepth] = new TEncSbac* [CI_NUM];
144#if FAST_BIT_EST
145      m_pppcBinCoderCABAC[iDepth] = new TEncBinCABACCounter* [CI_NUM];
146#else
147      m_pppcBinCoderCABAC[iDepth] = new TEncBinCABAC* [CI_NUM];
148#endif
149     
150      for (Int iCIIdx = 0; iCIIdx < CI_NUM; iCIIdx ++ )
151      {
152        m_pppcRDSbacCoder[iDepth][iCIIdx] = new TEncSbac;
153#if FAST_BIT_EST
154        m_pppcBinCoderCABAC [iDepth][iCIIdx] = new TEncBinCABACCounter;
155#else
156        m_pppcBinCoderCABAC [iDepth][iCIIdx] = new TEncBinCABAC;
157#endif
158        m_pppcRDSbacCoder   [iDepth][iCIIdx]->init( m_pppcBinCoderCABAC [iDepth][iCIIdx] );
159      }
160    }
161  }
162}
163
164/**
165 - Allocate coders required for wavefront for the nominated number of substreams.
166 .
167 \param iNumSubstreams Determines how much information to allocate.
168 */
169Void TEncTop::createWPPCoders(Int iNumSubstreams)
170{
171  if (m_pcSbacCoders != NULL)
172  {
173    return; // already generated.
174  }
175
176  m_iNumSubstreams         = iNumSubstreams;
177  m_pcSbacCoders           = new TEncSbac       [iNumSubstreams];
178  m_pcBinCoderCABACs       = new TEncBinCABAC   [iNumSubstreams];
179  m_pcRDGoOnSbacCoders     = new TEncSbac       [iNumSubstreams];
180  m_pcRDGoOnBinCodersCABAC = new TEncBinCABAC   [iNumSubstreams];
181  m_pcBitCounters          = new TComBitCounter [iNumSubstreams];
182  m_pcRdCosts              = new TComRdCost     [iNumSubstreams];
183
184  for ( UInt ui = 0 ; ui < iNumSubstreams; ui++ )
185  {
186    m_pcRDGoOnSbacCoders[ui].init( &m_pcRDGoOnBinCodersCABAC[ui] );
187    m_pcSbacCoders[ui].init( &m_pcBinCoderCABACs[ui] );
188  }
189  if( m_bUseSBACRD )
190  {
191    m_ppppcRDSbacCoders      = new TEncSbac***    [iNumSubstreams];
192    m_ppppcBinCodersCABAC    = new TEncBinCABAC***[iNumSubstreams];
193    for ( UInt ui = 0 ; ui < iNumSubstreams ; ui++ )
194    {
195      m_ppppcRDSbacCoders[ui]  = new TEncSbac** [g_uiMaxCUDepth+1];
196      m_ppppcBinCodersCABAC[ui]= new TEncBinCABAC** [g_uiMaxCUDepth+1];
197     
198      for ( Int iDepth = 0; iDepth < g_uiMaxCUDepth+1; iDepth++ )
199      {
200        m_ppppcRDSbacCoders[ui][iDepth]  = new TEncSbac*     [CI_NUM];
201        m_ppppcBinCodersCABAC[ui][iDepth]= new TEncBinCABAC* [CI_NUM];
202
203        for (Int iCIIdx = 0; iCIIdx < CI_NUM; iCIIdx ++ )
204        {
205          m_ppppcRDSbacCoders  [ui][iDepth][iCIIdx] = new TEncSbac;
206          m_ppppcBinCodersCABAC[ui][iDepth][iCIIdx] = new TEncBinCABAC;
207          m_ppppcRDSbacCoders  [ui][iDepth][iCIIdx]->init( m_ppppcBinCodersCABAC[ui][iDepth][iCIIdx] );
208        }
209      }
210    }
211  }
212}
213
214Void TEncTop::destroy ()
215{
216  // destroy processing unit classes
217  m_cGOPEncoder.        destroy();
218  m_cSliceEncoder.      destroy();
219  m_cCuEncoder.         destroy();
220  if (m_cSPS.getUseSAO())
221  {
222    m_cEncSAO.destroy();
223    m_cEncSAO.destroyEncBuffer();
224  }
225  m_cLoopFilter.        destroy();
226  m_cRateCtrl.          destroy();
227  // SBAC RD
228  if( m_bUseSBACRD )
229  {
230    Int iDepth;
231    for ( iDepth = 0; iDepth < g_uiMaxCUDepth+1; iDepth++ )
232    {
233      for (Int iCIIdx = 0; iCIIdx < CI_NUM; iCIIdx ++ )
234      {
235        delete m_pppcRDSbacCoder[iDepth][iCIIdx];
236        delete m_pppcBinCoderCABAC[iDepth][iCIIdx];
237      }
238    }
239   
240    for ( iDepth = 0; iDepth < g_uiMaxCUDepth+1; iDepth++ )
241    {
242      delete [] m_pppcRDSbacCoder[iDepth];
243      delete [] m_pppcBinCoderCABAC[iDepth];
244    }
245   
246    delete [] m_pppcRDSbacCoder;
247    delete [] m_pppcBinCoderCABAC;
248
249    for ( UInt ui = 0; ui < m_iNumSubstreams; ui++ )
250    {
251      for ( iDepth = 0; iDepth < g_uiMaxCUDepth+1; iDepth++ )
252      {
253        for (Int iCIIdx = 0; iCIIdx < CI_NUM; iCIIdx ++ )
254        {
255          delete m_ppppcRDSbacCoders  [ui][iDepth][iCIIdx];
256          delete m_ppppcBinCodersCABAC[ui][iDepth][iCIIdx];
257        }
258      }
259
260      for ( iDepth = 0; iDepth < g_uiMaxCUDepth+1; iDepth++ )
261      {
262        delete [] m_ppppcRDSbacCoders  [ui][iDepth];
263        delete [] m_ppppcBinCodersCABAC[ui][iDepth];
264      }
265      delete[] m_ppppcRDSbacCoders  [ui];
266      delete[] m_ppppcBinCodersCABAC[ui];
267    }
268    delete[] m_ppppcRDSbacCoders;
269    delete[] m_ppppcBinCodersCABAC;
270  }
271  delete[] m_pcSbacCoders;
272  delete[] m_pcBinCoderCABACs;
273  delete[] m_pcRDGoOnSbacCoders; 
274  delete[] m_pcRDGoOnBinCodersCABAC;
275  delete[] m_pcBitCounters;
276  delete[] m_pcRdCosts;
277 
278#if !H_MV
279    // destroy ROM
280  destroyROM();
281#endif
282
283  return;
284}
285
286Void TEncTop::init()
287{
288  // initialize SPS
289  xInitSPS();
290 
291  /* set the VPS profile information */
292#if H_MV
293  // This seems to be incorrect, but irrelevant for the MV-HEVC
294  *(m_cVPS->getPTL()) = *m_cSPS.getPTL();
295  m_cVPS->getTimingInfo()->setTimingInfoPresentFlag       ( false );
296#else
297  *m_cVPS.getPTL() = *m_cSPS.getPTL();
298  m_cVPS.getTimingInfo()->setTimingInfoPresentFlag       ( false );
299#endif
300  // initialize PPS
301  m_cPPS.setSPS(&m_cSPS);
302  xInitPPS();
303  xInitRPS();
304
305  xInitPPSforTiles();
306
307  // initialize processing unit classes
308  m_cGOPEncoder.  init( this );
309  m_cSliceEncoder.init( this );
310  m_cCuEncoder.   init( this );
311 
312  // initialize transform & quantization class
313  m_pcCavlcCoder = getCavlcCoder();
314 
315  m_cTrQuant.init( 1 << m_uiQuadtreeTULog2MaxSize,
316                  m_useRDOQ, 
317                  m_useRDOQTS,
318                  true 
319                  ,m_useTransformSkipFast
320#if ADAPTIVE_QP_SELECTION                 
321                  , m_bUseAdaptQpSelect
322#endif
323                  );
324 
325  // initialize encoder search class
326  m_cSearch.init( this, &m_cTrQuant, m_iSearchRange, m_bipredSearchRange, m_iFastSearch, 0, &m_cEntropyCoder, &m_cRdCost, getRDSbacCoder(), getRDGoOnSbacCoder() );
327
328  m_iMaxRefPicNum = 0;
329}
330
331// ====================================================================================================================
332// Public member functions
333// ====================================================================================================================
334
335#if H_MV
336Void TEncTop::initNewPic( TComPicYuv* pcPicYuvOrg )
337{
338  TComPic* pcPicCurr = NULL;
339
340  // get original YUV
341  xGetNewPicBuffer( pcPicCurr );
342  pcPicYuvOrg->copyToPic( pcPicCurr->getPicYuvOrg() );
343
344  // compute image characteristics
345  if ( getUseAdaptiveQP() )
346  {
347    m_cPreanalyzer.xPreanalyze( dynamic_cast<TEncPic*>( pcPicCurr ) );
348  }
349#if H_MV
350  pcPicCurr->setLayerId( getLayerId()); 
351#endif
352#if H_3D
353  pcPicCurr->setScaleOffset( m_aaiCodedScale, m_aaiCodedOffset );
354#endif
355}
356#endif
357Void TEncTop::deletePicBuffer()
358{
359  TComList<TComPic*>::iterator iterPic = m_cListPic.begin();
360  Int iSize = Int( m_cListPic.size() );
361 
362  for ( Int i = 0; i < iSize; i++ )
363  {
364    TComPic* pcPic = *(iterPic++);
365   
366    pcPic->destroy();
367    delete pcPic;
368    pcPic = NULL;
369  }
370}
371
372/**
373 - Application has picture buffer list with size of GOP + 1
374 - Picture buffer list acts like as ring buffer
375 - End of the list has the latest picture
376 .
377 \param   flush               cause encoder to encode a partial GOP
378 \param   pcPicYuvOrg         original YUV picture
379 \retval  rcListPicYuvRecOut  list of reconstruction YUV pictures
380 \retval  rcListBitstreamOut  list of output bitstreams
381 \retval  iNumEncoded         number of encoded pictures
382 */
383#if H_MV
384Void TEncTop::encode(Bool flush, TComPicYuv* pcPicYuvOrg, TComList<TComPicYuv*>& rcListPicYuvRecOut, std::list<AccessUnit>& accessUnitsOut, Int& iNumEncoded , Int gopId )
385{
386#else
387Void TEncTop::encode(Bool flush, TComPicYuv* pcPicYuvOrg, TComList<TComPicYuv*>& rcListPicYuvRecOut, std::list<AccessUnit>& accessUnitsOut, Int& iNumEncoded )
388{
389#endif
390#if H_3D
391  TComPic* picLastCoded = getPic( getGOPEncoder()->getPocLastCoded() );
392  if( picLastCoded )
393  {
394#if MTK_SONY_PROGRESSIVE_MV_COMPRESSION_E0170
395    picLastCoded->compressMotion(1); 
396#else
397    picLastCoded->compressMotion(); 
398#endif
399  }
400#endif
401#if H_MV
402  if( gopId == 0)
403  {
404    m_cGOPEncoder.initGOP(m_iPOCLast, m_iNumPicRcvd, m_cListPic, rcListPicYuvRecOut, accessUnitsOut); 
405#else
406  if (pcPicYuvOrg) {
407    // get original YUV
408    TComPic* pcPicCurr = NULL;
409    xGetNewPicBuffer( pcPicCurr );
410    pcPicYuvOrg->copyToPic( pcPicCurr->getPicYuvOrg() );
411
412    // compute image characteristics
413    if ( getUseAdaptiveQP() )
414    {
415      m_cPreanalyzer.xPreanalyze( dynamic_cast<TEncPic*>( pcPicCurr ) );
416    }
417  }
418 
419  if (!m_iNumPicRcvd || (!flush && m_iPOCLast != 0 && m_iNumPicRcvd != m_iGOPSize && m_iGOPSize))
420  {
421    iNumEncoded = 0;
422    return;
423  }
424#endif
425 
426#if RATE_CONTROL_LAMBDA_DOMAIN
427  if ( m_RCEnableRateControl )
428  {
429    m_cRateCtrl.initRCGOP( m_iNumPicRcvd );
430  }
431#endif
432
433#if H_MV
434  }
435  m_cGOPEncoder.compressPicInGOP(m_iPOCLast, m_iNumPicRcvd, m_cListPic, rcListPicYuvRecOut, accessUnitsOut, gopId );
436
437  if( gopId + 1 == m_cGOPEncoder.getGOPSize() )
438  {
439#else
440  // compress GOP
441  m_cGOPEncoder.compressGOP(m_iPOCLast, m_iNumPicRcvd, m_cListPic, rcListPicYuvRecOut, accessUnitsOut);
442#endif
443
444#if RATE_CONTROL_LAMBDA_DOMAIN
445  if ( m_RCEnableRateControl )
446  {
447    m_cRateCtrl.destroyRCGOP();
448  }
449#endif
450 
451  iNumEncoded         = m_iNumPicRcvd;
452  m_iNumPicRcvd       = 0;
453  m_uiNumAllPicCoded += iNumEncoded;
454#if H_MV
455}
456#endif
457}
458
459// ====================================================================================================================
460// Protected member functions
461// ====================================================================================================================
462
463/**
464 - Application has picture buffer list with size of GOP + 1
465 - Picture buffer list acts like as ring buffer
466 - End of the list has the latest picture
467 .
468 \retval rpcPic obtained picture buffer
469 */
470Void TEncTop::xGetNewPicBuffer ( TComPic*& rpcPic )
471{
472  TComSlice::sortPicList(m_cListPic);
473 
474  if (m_cListPic.size() >= (UInt)(m_iGOPSize + getMaxDecPicBuffering(MAX_TLAYER-1) + 2) )
475  {
476    TComList<TComPic*>::iterator iterPic  = m_cListPic.begin();
477    Int iSize = Int( m_cListPic.size() );
478    for ( Int i = 0; i < iSize; i++ )
479    {
480      rpcPic = *(iterPic++);
481      if(rpcPic->getSlice(0)->isReferenced() == false)
482      {
483        break;
484      }
485    }
486  }
487  else
488  {
489    if ( getUseAdaptiveQP() )
490    {
491      TEncPic* pcEPic = new TEncPic;
492      pcEPic->create( m_iSourceWidth, m_iSourceHeight, g_uiMaxCUWidth, g_uiMaxCUHeight, g_uiMaxCUDepth, m_cPPS.getMaxCuDQPDepth()+1 ,
493                      m_conformanceWindow, m_defaultDisplayWindow, m_numReorderPics);
494      rpcPic = pcEPic;
495    }
496    else
497    {
498      rpcPic = new TComPic;
499
500      rpcPic->create( m_iSourceWidth, m_iSourceHeight, g_uiMaxCUWidth, g_uiMaxCUHeight, g_uiMaxCUDepth, 
501                      m_conformanceWindow, m_defaultDisplayWindow, m_numReorderPics);
502    }
503    if (getUseSAO())
504    {
505      rpcPic->getPicSym()->allocSaoParam(&m_cEncSAO);
506    }
507    m_cListPic.pushBack( rpcPic );
508  }
509  rpcPic->setReconMark (false);
510 
511  m_iPOCLast++;
512  m_iNumPicRcvd++;
513 
514  rpcPic->getSlice(0)->setPOC( m_iPOCLast );
515  // mark it should be extended
516  rpcPic->getPicYuvRec()->setBorderExtension(false);
517
518#if H_MV
519  rpcPic->getPicYuvOrg()->setBorderExtension(false);
520#endif
521}
522
523Void TEncTop::xInitSPS()
524{
525#if H_MV
526  m_cSPS.setSPSId( getLayerIdInVps() );
527  m_cSPS.setLayerId( getLayerId() );
528#endif
529  ProfileTierLevel& profileTierLevel = *m_cSPS.getPTL()->getGeneralPTL();
530  profileTierLevel.setLevelIdc(m_level);
531  profileTierLevel.setTierFlag(m_levelTier);
532  profileTierLevel.setProfileIdc(m_profile);
533  profileTierLevel.setProfileCompatibilityFlag(m_profile, 1);
534  profileTierLevel.setProgressiveSourceFlag(m_progressiveSourceFlag);
535  profileTierLevel.setInterlacedSourceFlag(m_interlacedSourceFlag);
536  profileTierLevel.setNonPackedConstraintFlag(m_nonPackedConstraintFlag);
537  profileTierLevel.setFrameOnlyConstraintFlag(m_frameOnlyConstraintFlag);
538 
539  if (m_profile == Profile::MAIN10 && g_bitDepthY == 8 && g_bitDepthC == 8)
540  {
541    /* The above constraint is equal to Profile::MAIN */
542    profileTierLevel.setProfileCompatibilityFlag(Profile::MAIN, 1);
543  }
544  if (m_profile == Profile::MAIN)
545  {
546    /* A Profile::MAIN10 decoder can always decode Profile::MAIN */
547    profileTierLevel.setProfileCompatibilityFlag(Profile::MAIN10, 1);
548  }
549  /* XXX: should Main be marked as compatible with still picture? */
550  /* XXX: may be a good idea to refactor the above into a function
551   * that chooses the actual compatibility based upon options */
552
553#if H_MV5
554#if H_MV 
555  m_cSPS.setUpdateRepFormatFlag           ( m_layerId == 0 );   
556  m_cSPS.setSpsInferScalingListFlag       ( m_layerId > 0 && m_cVPS->getInDirectDependencyFlag( getLayerIdInVps(), 0 ) ); 
557  m_cSPS.setSpsScalingListRefLayerId      ( 0              ); 
558#endif
559#endif
560  m_cSPS.setPicWidthInLumaSamples         ( m_iSourceWidth      );
561  m_cSPS.setPicHeightInLumaSamples        ( m_iSourceHeight     );
562  m_cSPS.setConformanceWindow             ( m_conformanceWindow );
563  m_cSPS.setMaxCUWidth    ( g_uiMaxCUWidth      );
564  m_cSPS.setMaxCUHeight   ( g_uiMaxCUHeight     );
565  m_cSPS.setMaxCUDepth    ( g_uiMaxCUDepth      );
566
567  Int minCUSize = m_cSPS.getMaxCUWidth() >> ( m_cSPS.getMaxCUDepth()-g_uiAddCUDepth );
568  Int log2MinCUSize = 0;
569  while(minCUSize > 1)
570  {
571    minCUSize >>= 1;
572    log2MinCUSize++;
573  }
574
575  m_cSPS.setLog2MinCodingBlockSize(log2MinCUSize);
576  m_cSPS.setLog2DiffMaxMinCodingBlockSize(m_cSPS.getMaxCUDepth()-g_uiAddCUDepth);
577 
578  m_cSPS.setPCMLog2MinSize (m_uiPCMLog2MinSize);
579  m_cSPS.setUsePCM        ( m_usePCM           );
580  m_cSPS.setPCMLog2MaxSize( m_pcmLog2MaxSize  );
581
582  m_cSPS.setQuadtreeTULog2MaxSize( m_uiQuadtreeTULog2MaxSize );
583  m_cSPS.setQuadtreeTULog2MinSize( m_uiQuadtreeTULog2MinSize );
584  m_cSPS.setQuadtreeTUMaxDepthInter( m_uiQuadtreeTUMaxDepthInter    );
585  m_cSPS.setQuadtreeTUMaxDepthIntra( m_uiQuadtreeTUMaxDepthIntra    );
586 
587  m_cSPS.setTMVPFlagsPresent(false);
588  m_cSPS.setUseLossless   ( m_useLossless  );
589
590  m_cSPS.setMaxTrSize   ( 1 << m_uiQuadtreeTULog2MaxSize );
591 
592  Int i;
593 
594  for (i = 0; i < g_uiMaxCUDepth-g_uiAddCUDepth; i++ )
595  {
596    m_cSPS.setAMPAcc( i, m_useAMP );
597    //m_cSPS.setAMPAcc( i, 1 );
598  }
599
600  m_cSPS.setUseAMP ( m_useAMP );
601
602#if H_3D_QTLPC
603  m_cSPS.setUseQTL( m_bUseQTL );
604  m_cSPS.setUsePC ( m_bUsePC  );
605#endif
606
607  for (i = g_uiMaxCUDepth-g_uiAddCUDepth; i < g_uiMaxCUDepth; i++ )
608  {
609    m_cSPS.setAMPAcc(i, 0);
610  }
611
612  m_cSPS.setBitDepthY( g_bitDepthY );
613  m_cSPS.setBitDepthC( g_bitDepthC );
614
615  m_cSPS.setQpBDOffsetY ( 6*(g_bitDepthY - 8) );
616  m_cSPS.setQpBDOffsetC ( 6*(g_bitDepthC - 8) );
617
618  m_cSPS.setUseSAO( m_bUseSAO );
619
620  m_cSPS.setMaxTLayers( m_maxTempLayer );
621  m_cSPS.setTemporalIdNestingFlag( ( m_maxTempLayer == 1 ) ? true : false );
622  for ( i = 0; i < m_cSPS.getMaxTLayers(); i++ )
623  {
624    m_cSPS.setMaxDecPicBuffering(m_maxDecPicBuffering[i], i);
625    m_cSPS.setNumReorderPics(m_numReorderPics[i], i);
626  }
627  m_cSPS.setPCMBitDepthLuma (g_uiPCMBitDepthLuma);
628  m_cSPS.setPCMBitDepthChroma (g_uiPCMBitDepthChroma);
629  m_cSPS.setPCMFilterDisableFlag  ( m_bPCMFilterDisableFlag );
630
631  m_cSPS.setScalingListFlag ( (m_useScalingListId == 0) ? 0 : 1 );
632
633  m_cSPS.setUseStrongIntraSmoothing( m_useStrongIntraSmoothing );
634
635  m_cSPS.setVuiParametersPresentFlag(getVuiParametersPresentFlag());
636  if (m_cSPS.getVuiParametersPresentFlag())
637  {
638    TComVUI* pcVUI = m_cSPS.getVuiParameters();
639    pcVUI->setAspectRatioInfoPresentFlag(getAspectRatioIdc() != -1);
640    pcVUI->setAspectRatioIdc(getAspectRatioIdc());
641    pcVUI->setSarWidth(getSarWidth());
642    pcVUI->setSarHeight(getSarHeight());
643    pcVUI->setOverscanInfoPresentFlag(getOverscanInfoPresentFlag());
644    pcVUI->setOverscanAppropriateFlag(getOverscanAppropriateFlag());
645    pcVUI->setVideoSignalTypePresentFlag(getVideoSignalTypePresentFlag());
646    pcVUI->setVideoFormat(getVideoFormat());
647    pcVUI->setVideoFullRangeFlag(getVideoFullRangeFlag());
648    pcVUI->setColourDescriptionPresentFlag(getColourDescriptionPresentFlag());
649    pcVUI->setColourPrimaries(getColourPrimaries());
650    pcVUI->setTransferCharacteristics(getTransferCharacteristics());
651    pcVUI->setMatrixCoefficients(getMatrixCoefficients());
652    pcVUI->setChromaLocInfoPresentFlag(getChromaLocInfoPresentFlag());
653    pcVUI->setChromaSampleLocTypeTopField(getChromaSampleLocTypeTopField());
654    pcVUI->setChromaSampleLocTypeBottomField(getChromaSampleLocTypeBottomField());
655    pcVUI->setNeutralChromaIndicationFlag(getNeutralChromaIndicationFlag());
656    pcVUI->setDefaultDisplayWindow(getDefaultDisplayWindow());
657    pcVUI->setFrameFieldInfoPresentFlag(getFrameFieldInfoPresentFlag());
658    pcVUI->setFieldSeqFlag(false);
659    pcVUI->setHrdParametersPresentFlag(false);
660    pcVUI->getTimingInfo()->setPocProportionalToTimingFlag(getPocProportionalToTimingFlag());
661    pcVUI->getTimingInfo()->setNumTicksPocDiffOneMinus1   (getNumTicksPocDiffOneMinus1()   );
662    pcVUI->setBitstreamRestrictionFlag(getBitstreamRestrictionFlag());
663    pcVUI->setTilesFixedStructureFlag(getTilesFixedStructureFlag());
664    pcVUI->setMotionVectorsOverPicBoundariesFlag(getMotionVectorsOverPicBoundariesFlag());
665    pcVUI->setMinSpatialSegmentationIdc(getMinSpatialSegmentationIdc());
666    pcVUI->setMaxBytesPerPicDenom(getMaxBytesPerPicDenom());
667    pcVUI->setMaxBitsPerMinCuDenom(getMaxBitsPerMinCuDenom());
668    pcVUI->setLog2MaxMvLengthHorizontal(getLog2MaxMvLengthHorizontal());
669    pcVUI->setLog2MaxMvLengthVertical(getLog2MaxMvLengthVertical());
670  }
671#if H_3D
672  if ( !m_isDepth )
673  {
674    m_cSPS.initCamParaSPS           ( m_viewIndex, m_uiCamParPrecision, m_bCamParInSliceHeader, m_aaiCodedScale, m_aaiCodedOffset );
675  }
676#endif
677}
678
679Void TEncTop::xInitPPS()
680{
681#if H_MV
682#if H_MV5
683  m_cPPS.setLayerId( getLayerId() );
684  if( getVPS()->getNumDirectRefLayers( getLayerId() ) > 0 )
685#else
686  if( getVPS()->getNumDirectRefLayers( getLayerIdInVps() ) > 0 )
687#endif
688  {
689    m_cPPS.setListsModificationPresentFlag( true );
690  }
691  m_cPPS.setPPSId( getLayerIdInVps() );
692  m_cPPS.setSPSId( getLayerIdInVps() );
693#endif
694  m_cPPS.setConstrainedIntraPred( m_bUseConstrainedIntraPred );
695  Bool bUseDQP = (getMaxCuDQPDepth() > 0)? true : false;
696
697  Int lowestQP = - m_cSPS.getQpBDOffsetY();
698
699  if(getUseLossless())
700  {
701    if ((getMaxCuDQPDepth() == 0) && (getMaxDeltaQP() == 0 ) && (getQP() == lowestQP) )
702    {
703      bUseDQP = false;
704    }
705    else
706    {
707      bUseDQP = true;
708    }
709  }
710  else
711  {
712    if(bUseDQP == false)
713    {
714      if((getMaxDeltaQP() != 0 )|| getUseAdaptiveQP())
715      {
716        bUseDQP = true;
717      }
718    }
719  }
720
721  if(bUseDQP)
722  {
723    m_cPPS.setUseDQP(true);
724    m_cPPS.setMaxCuDQPDepth( m_iMaxCuDQPDepth );
725    m_cPPS.setMinCuDQPSize( m_cPPS.getSPS()->getMaxCUWidth() >> ( m_cPPS.getMaxCuDQPDepth()) );
726  }
727  else
728  {
729    m_cPPS.setUseDQP(false);
730    m_cPPS.setMaxCuDQPDepth( 0 );
731    m_cPPS.setMinCuDQPSize( m_cPPS.getSPS()->getMaxCUWidth() >> ( m_cPPS.getMaxCuDQPDepth()) );
732  }
733
734#if RATE_CONTROL_LAMBDA_DOMAIN
735  if ( m_RCEnableRateControl )
736  {
737    m_cPPS.setUseDQP(true);
738    m_cPPS.setMaxCuDQPDepth( 0 );
739    m_cPPS.setMinCuDQPSize( m_cPPS.getSPS()->getMaxCUWidth() >> ( m_cPPS.getMaxCuDQPDepth()) );
740  } 
741#endif
742
743  m_cPPS.setChromaCbQpOffset( m_chromaCbQpOffset );
744  m_cPPS.setChromaCrQpOffset( m_chromaCrQpOffset );
745
746  m_cPPS.setNumSubstreams(m_iWaveFrontSubstreams);
747  m_cPPS.setEntropyCodingSyncEnabledFlag( m_iWaveFrontSynchro > 0 );
748  m_cPPS.setTilesEnabledFlag( (m_iNumColumnsMinus1 > 0 || m_iNumRowsMinus1 > 0) );
749  m_cPPS.setUseWP( m_useWeightedPred );
750  m_cPPS.setWPBiPred( m_useWeightedBiPred );
751  m_cPPS.setOutputFlagPresentFlag( false );
752#if H_MV
753#if H_MV5
754  m_cPPS.setNumExtraSliceHeaderBits( 2 ); 
755#else
756  m_cPPS.setNumExtraSliceHeaderBits( 1 ); 
757#endif
758#endif
759  m_cPPS.setSignHideFlag(getSignHideFlag());
760  m_cPPS.setDeblockingFilterControlPresentFlag (m_DeblockingFilterControlPresent );
761  m_cPPS.setLog2ParallelMergeLevelMinus2   (m_log2ParallelMergeLevelMinus2 );
762  m_cPPS.setCabacInitPresentFlag(CABAC_INIT_PRESENT_FLAG);
763  m_cPPS.setLoopFilterAcrossSlicesEnabledFlag( m_bLFCrossSliceBoundaryFlag );
764  Int histogram[MAX_NUM_REF + 1];
765  for( Int i = 0; i <= MAX_NUM_REF; i++ )
766  {
767    histogram[i]=0;
768  }
769  for( Int i = 0; i < getGOPSize(); i++ )
770  {
771    assert(getGOPEntry(i).m_numRefPicsActive >= 0 && getGOPEntry(i).m_numRefPicsActive <= MAX_NUM_REF);
772    histogram[getGOPEntry(i).m_numRefPicsActive]++;
773  }
774  Int maxHist=-1;
775  Int bestPos=0;
776  for( Int i = 0; i <= MAX_NUM_REF; i++ )
777  {
778    if(histogram[i]>maxHist)
779    {
780      maxHist=histogram[i];
781      bestPos=i;
782    }
783  }
784  assert(bestPos <= 15);
785  m_cPPS.setNumRefIdxL0DefaultActive(bestPos);
786  m_cPPS.setNumRefIdxL1DefaultActive(bestPos);
787  m_cPPS.setTransquantBypassEnableFlag(getTransquantBypassEnableFlag());
788  m_cPPS.setUseTransformSkip( m_useTransformSkip );
789  if (m_sliceSegmentMode)
790  {
791    m_cPPS.setDependentSliceSegmentsEnabledFlag( true );
792  }
793  if( m_cPPS.getDependentSliceSegmentsEnabledFlag() )
794  {
795    Int NumCtx = m_cPPS.getEntropyCodingSyncEnabledFlag()?2:1;
796    m_cSliceEncoder.initCtxMem( NumCtx );
797    for ( UInt st = 0; st < NumCtx; st++ )
798    {
799      TEncSbac* ctx = NULL;
800      ctx = new TEncSbac;
801      ctx->init( &m_cBinCoderCABAC );
802      m_cSliceEncoder.setCtxMem( ctx, st );
803    }
804  }
805#if H_3D
806  if( m_cSPS.hasCamParInSliceHeader() )
807  {
808    m_cPPS.setSliceHeaderExtensionPresentFlag( true ); 
809  }
810#endif
811}
812
813//Function for initializing m_RPSList, a list of TComReferencePictureSet, based on the GOPEntry objects read from the config file.
814Void TEncTop::xInitRPS()
815{
816  TComReferencePictureSet*      rps;
817 
818  m_cSPS.createRPSList(getGOPSize()+m_extraRPSs);
819  TComRPSList* rpsList = m_cSPS.getRPSList();
820
821  for( Int i = 0; i < getGOPSize()+m_extraRPSs; i++) 
822  {
823    GOPEntry ge = getGOPEntry(i);
824    rps = rpsList->getReferencePictureSet(i);
825    rps->setNumberOfPictures(ge.m_numRefPics);
826    rps->setNumRefIdc(ge.m_numRefIdc);
827    Int numNeg = 0;
828    Int numPos = 0;
829    for( Int j = 0; j < ge.m_numRefPics; j++)
830    {
831      rps->setDeltaPOC(j,ge.m_referencePics[j]);
832      rps->setUsed(j,ge.m_usedByCurrPic[j]);
833      if(ge.m_referencePics[j]>0)
834      {
835        numPos++;
836      }
837      else
838      {
839        numNeg++;
840      }
841    }
842    rps->setNumberOfNegativePictures(numNeg);
843    rps->setNumberOfPositivePictures(numPos);
844
845    // handle inter RPS intialization from the config file.
846#if AUTO_INTER_RPS
847    rps->setInterRPSPrediction(ge.m_interRPSPrediction > 0);  // not very clean, converting anything > 0 to true.
848    rps->setDeltaRIdxMinus1(0);                               // index to the Reference RPS is always the previous one.
849    TComReferencePictureSet*     RPSRef = rpsList->getReferencePictureSet(i-1);  // get the reference RPS
850
851    if (ge.m_interRPSPrediction == 2)  // Automatic generation of the inter RPS idc based on the RIdx provided.
852    {
853      Int deltaRPS = getGOPEntry(i-1).m_POC - ge.m_POC;  // the ref POC - current POC
854      Int numRefDeltaPOC = RPSRef->getNumberOfPictures();
855
856      rps->setDeltaRPS(deltaRPS);           // set delta RPS
857      rps->setNumRefIdc(numRefDeltaPOC+1);  // set the numRefIdc to the number of pictures in the reference RPS + 1.
858      Int count=0;
859      for (Int j = 0; j <= numRefDeltaPOC; j++ ) // cycle through pics in reference RPS.
860      {
861        Int RefDeltaPOC = (j<numRefDeltaPOC)? RPSRef->getDeltaPOC(j): 0;  // if it is the last decoded picture, set RefDeltaPOC = 0
862        rps->setRefIdc(j, 0);
863        for (Int k = 0; k < rps->getNumberOfPictures(); k++ )  // cycle through pics in current RPS.
864        {
865          if (rps->getDeltaPOC(k) == ( RefDeltaPOC + deltaRPS))  // if the current RPS has a same picture as the reference RPS.
866          {
867              rps->setRefIdc(j, (rps->getUsed(k)?1:2));
868              count++;
869              break;
870          }
871        }
872      }
873      if (count != rps->getNumberOfPictures())
874      {
875        printf("Warning: Unable fully predict all delta POCs using the reference RPS index given in the config file.  Setting Inter RPS to false for this RPS.\n");
876        rps->setInterRPSPrediction(0);
877      }
878    }
879    else if (ge.m_interRPSPrediction == 1)  // inter RPS idc based on the RefIdc values provided in config file.
880    {
881      rps->setDeltaRPS(ge.m_deltaRPS);
882      rps->setNumRefIdc(ge.m_numRefIdc);
883      for (Int j = 0; j < ge.m_numRefIdc; j++ )
884      {
885        rps->setRefIdc(j, ge.m_refIdc[j]);
886      }
887#if WRITE_BACK
888      // the folowing code overwrite the deltaPOC and Used by current values read from the config file with the ones
889      // computed from the RefIdc.  A warning is printed if they are not identical.
890      numNeg = 0;
891      numPos = 0;
892      TComReferencePictureSet      RPSTemp;  // temporary variable
893
894      for (Int j = 0; j < ge.m_numRefIdc; j++ )
895      {
896        if (ge.m_refIdc[j])
897        {
898          Int deltaPOC = ge.m_deltaRPS + ((j < RPSRef->getNumberOfPictures())? RPSRef->getDeltaPOC(j) : 0);
899          RPSTemp.setDeltaPOC((numNeg+numPos),deltaPOC);
900          RPSTemp.setUsed((numNeg+numPos),ge.m_refIdc[j]==1?1:0);
901          if (deltaPOC<0)
902          {
903            numNeg++;
904          }
905          else
906          {
907            numPos++;
908          }
909        }
910      }
911      if (numNeg != rps->getNumberOfNegativePictures())
912      {
913        printf("Warning: number of negative pictures in RPS is different between intra and inter RPS specified in the config file.\n");
914        rps->setNumberOfNegativePictures(numNeg);
915        rps->setNumberOfPositivePictures(numNeg+numPos);
916      }
917      if (numPos != rps->getNumberOfPositivePictures())
918      {
919        printf("Warning: number of positive pictures in RPS is different between intra and inter RPS specified in the config file.\n");
920        rps->setNumberOfPositivePictures(numPos);
921        rps->setNumberOfPositivePictures(numNeg+numPos);
922      }
923      RPSTemp.setNumberOfPictures(numNeg+numPos);
924      RPSTemp.setNumberOfNegativePictures(numNeg);
925      RPSTemp.sortDeltaPOC();     // sort the created delta POC before comparing
926      // check if Delta POC and Used are the same
927      // print warning if they are not.
928      for (Int j = 0; j < ge.m_numRefIdc; j++ )
929      {
930        if (RPSTemp.getDeltaPOC(j) != rps->getDeltaPOC(j))
931        {
932          printf("Warning: delta POC is different between intra RPS and inter RPS specified in the config file.\n");
933          rps->setDeltaPOC(j,RPSTemp.getDeltaPOC(j));
934        }
935        if (RPSTemp.getUsed(j) != rps->getUsed(j))
936        {
937          printf("Warning: Used by Current in RPS is different between intra and inter RPS specified in the config file.\n");
938          rps->setUsed(j,RPSTemp.getUsed(j));
939        }
940      }
941#endif
942    }
943#else
944    rps->setInterRPSPrediction(ge.m_interRPSPrediction);
945    if (ge.m_interRPSPrediction)
946    {
947      rps->setDeltaRIdxMinus1(0);
948      rps->setDeltaRPS(ge.m_deltaRPS);
949      rps->setNumRefIdc(ge.m_numRefIdc);
950      for (Int j = 0; j < ge.m_numRefIdc; j++ )
951      {
952        rps->setRefIdc(j, ge.m_refIdc[j]);
953      }
954#if WRITE_BACK
955      // the folowing code overwrite the deltaPOC and Used by current values read from the config file with the ones
956      // computed from the RefIdc.  This is not necessary if both are identical. Currently there is no check to see if they are identical.
957      numNeg = 0;
958      numPos = 0;
959      TComReferencePictureSet*     RPSRef = m_RPSList.getReferencePictureSet(i-1);
960
961      for (Int j = 0; j < ge.m_numRefIdc; j++ )
962      {
963        if (ge.m_refIdc[j])
964        {
965          Int deltaPOC = ge.m_deltaRPS + ((j < RPSRef->getNumberOfPictures())? RPSRef->getDeltaPOC(j) : 0);
966          rps->setDeltaPOC((numNeg+numPos),deltaPOC);
967          rps->setUsed((numNeg+numPos),ge.m_refIdc[j]==1?1:0);
968          if (deltaPOC<0)
969          {
970            numNeg++;
971          }
972          else
973          {
974            numPos++;
975          }
976        }
977      }
978      rps->setNumberOfNegativePictures(numNeg);
979      rps->setNumberOfPositivePictures(numPos);
980      rps->sortDeltaPOC();
981#endif
982    }
983#endif //INTER_RPS_AUTO
984  }
985 
986}
987
988   // This is a function that
989   // determines what Reference Picture Set to use
990   // for a specific slice (with POC = POCCurr)
991Void TEncTop::selectReferencePictureSet(TComSlice* slice, Int POCCurr, Int GOPid )
992{
993#if H_MV
994  if( slice->getRapPicFlag() == true && getLayerId() > 0 && POCCurr == 0 )
995  {
996    TComReferencePictureSet* rps = slice->getLocalRPS();
997    rps->setNumberOfNegativePictures(0);
998    rps->setNumberOfPositivePictures(0);
999    rps->setNumberOfLongtermPictures(0);
1000    rps->setNumberOfPictures(0);
1001    slice->setRPS(rps);
1002  }
1003  else
1004  {
1005#endif
1006  slice->setRPSidx(GOPid);
1007
1008  for(Int extraNum=m_iGOPSize; extraNum<m_extraRPSs+m_iGOPSize; extraNum++)
1009  {   
1010    if(m_uiIntraPeriod > 0 && getDecodingRefreshType() > 0)
1011    {
1012      Int POCIndex = POCCurr%m_uiIntraPeriod;
1013      if(POCIndex == 0)
1014      {
1015        POCIndex = m_uiIntraPeriod;
1016      }
1017      if(POCIndex == m_GOPList[extraNum].m_POC)
1018      {
1019        slice->setRPSidx(extraNum);
1020      }
1021    }
1022    else
1023    {
1024      if(POCCurr==m_GOPList[extraNum].m_POC)
1025      {
1026        slice->setRPSidx(extraNum);
1027      }
1028    }
1029  }
1030
1031  slice->setRPS(getSPS()->getRPSList()->getReferencePictureSet(slice->getRPSidx()));
1032  slice->getRPS()->setNumberOfPictures(slice->getRPS()->getNumberOfNegativePictures()+slice->getRPS()->getNumberOfPositivePictures());
1033#if H_MV
1034  }
1035#endif
1036
1037}
1038
1039Int TEncTop::getReferencePictureSetIdxForSOP(TComSlice* slice, Int POCCurr, Int GOPid )
1040{
1041  int rpsIdx = GOPid;
1042
1043  for(Int extraNum=m_iGOPSize; extraNum<m_extraRPSs+m_iGOPSize; extraNum++)
1044  {   
1045    if(m_uiIntraPeriod > 0 && getDecodingRefreshType() > 0)
1046    {
1047      Int POCIndex = POCCurr%m_uiIntraPeriod;
1048      if(POCIndex == 0)
1049      {
1050        POCIndex = m_uiIntraPeriod;
1051      }
1052      if(POCIndex == m_GOPList[extraNum].m_POC)
1053      {
1054        rpsIdx = extraNum;
1055      }
1056    }
1057    else
1058    {
1059      if(POCCurr==m_GOPList[extraNum].m_POC)
1060      {
1061        rpsIdx = extraNum;
1062      }
1063    }
1064  }
1065
1066  return rpsIdx;
1067}
1068
1069Void  TEncTop::xInitPPSforTiles()
1070{
1071  m_cPPS.setUniformSpacingFlag( m_iUniformSpacingIdr );
1072  m_cPPS.setNumColumnsMinus1( m_iNumColumnsMinus1 );
1073  m_cPPS.setNumRowsMinus1( m_iNumRowsMinus1 );
1074  if( m_iUniformSpacingIdr == 0 )
1075  {
1076    m_cPPS.setColumnWidth( m_puiColumnWidth );
1077    m_cPPS.setRowHeight( m_puiRowHeight );
1078  }
1079  m_cPPS.setLoopFilterAcrossTilesEnabledFlag( m_loopFilterAcrossTilesEnabledFlag );
1080
1081  // # substreams is "per tile" when tiles are independent.
1082  if (m_iWaveFrontSynchro
1083    )
1084  {
1085    m_cPPS.setNumSubstreams(m_iWaveFrontSubstreams * (m_iNumColumnsMinus1+1));
1086  }
1087}
1088
1089Void  TEncCfg::xCheckGSParameters()
1090{
1091  Int   iWidthInCU = ( m_iSourceWidth%g_uiMaxCUWidth ) ? m_iSourceWidth/g_uiMaxCUWidth + 1 : m_iSourceWidth/g_uiMaxCUWidth;
1092  Int   iHeightInCU = ( m_iSourceHeight%g_uiMaxCUHeight ) ? m_iSourceHeight/g_uiMaxCUHeight + 1 : m_iSourceHeight/g_uiMaxCUHeight;
1093  UInt  uiCummulativeColumnWidth = 0;
1094  UInt  uiCummulativeRowHeight = 0;
1095
1096  //check the column relative parameters
1097  if( m_iNumColumnsMinus1 >= (1<<(LOG2_MAX_NUM_COLUMNS_MINUS1+1)) )
1098  {
1099    printf( "The number of columns is larger than the maximum allowed number of columns.\n" );
1100    exit( EXIT_FAILURE );
1101  }
1102
1103  if( m_iNumColumnsMinus1 >= iWidthInCU )
1104  {
1105    printf( "The current picture can not have so many columns.\n" );
1106    exit( EXIT_FAILURE );
1107  }
1108
1109  if( m_iNumColumnsMinus1 && m_iUniformSpacingIdr==0 )
1110  {
1111    for(Int i=0; i<m_iNumColumnsMinus1; i++)
1112    {
1113      uiCummulativeColumnWidth += m_puiColumnWidth[i];
1114    }
1115
1116    if( uiCummulativeColumnWidth >= iWidthInCU )
1117    {
1118      printf( "The width of the column is too large.\n" );
1119      exit( EXIT_FAILURE );
1120    }
1121  }
1122
1123  //check the row relative parameters
1124  if( m_iNumRowsMinus1 >= (1<<(LOG2_MAX_NUM_ROWS_MINUS1+1)) )
1125  {
1126    printf( "The number of rows is larger than the maximum allowed number of rows.\n" );
1127    exit( EXIT_FAILURE );
1128  }
1129
1130  if( m_iNumRowsMinus1 >= iHeightInCU )
1131  {
1132    printf( "The current picture can not have so many rows.\n" );
1133    exit( EXIT_FAILURE );
1134  }
1135
1136  if( m_iNumRowsMinus1 && m_iUniformSpacingIdr==0 )
1137  {
1138    for(Int i=0; i<m_iNumRowsMinus1; i++)
1139      uiCummulativeRowHeight += m_puiRowHeight[i];
1140
1141    if( uiCummulativeRowHeight >= iHeightInCU )
1142    {
1143      printf( "The height of the row is too large.\n" );
1144      exit( EXIT_FAILURE );
1145    }
1146  }
1147}
1148#if H_MV
1149Void TEncTop::printSummary( Int numAllPicCoded )
1150{
1151  assert (numAllPicCoded == m_cAnalyzeAll.getNumPic());
1152
1153  //--CFG_KDY
1154  m_cAnalyzeAll.setFrmRate( getFrameRate() );
1155  m_cAnalyzeI.setFrmRate( getFrameRate() );
1156  m_cAnalyzeP.setFrmRate( getFrameRate() );
1157  m_cAnalyzeB.setFrmRate( getFrameRate() );
1158
1159  //-- all
1160  printf( "\n\nSUMMARY ------------------------------------------- LayerId %2d\n", m_layerId );
1161
1162  m_cAnalyzeAll.printOut('a');
1163
1164  printf( "\n\nI Slices--------------------------------------------------------\n" );
1165  m_cAnalyzeI.printOut('i');
1166
1167  printf( "\n\nP Slices--------------------------------------------------------\n" );
1168  m_cAnalyzeP.printOut('p');
1169
1170  printf( "\n\nB Slices--------------------------------------------------------\n" );
1171  m_cAnalyzeB.printOut('b');
1172
1173#if _SUMMARY_OUT_
1174  m_cAnalyzeAll.printSummaryOut();
1175#endif
1176#if _SUMMARY_PIC_
1177  m_cAnalyzeI.printSummary('I');
1178  m_cAnalyzeP.printSummary('P');
1179  m_cAnalyzeB.printSummary('B');
1180#endif
1181}
1182
1183Int TEncTop::getFrameId(Int iGOPid) 
1184{
1185  if(m_iPOCLast == 0)
1186  {
1187    return(0 );
1188  }
1189  else
1190  {
1191    return m_iPOCLast -m_iNumPicRcvd+ getGOPEntry(iGOPid).m_POC ;
1192  }
1193}
1194
1195TComPic* TEncTop::getPic( Int poc )
1196{
1197  TComList<TComPic*>* listPic = getListPic();
1198  TComPic* pcPic = NULL;
1199  for(TComList<TComPic*>::iterator it=listPic->begin(); it!=listPic->end(); it++)
1200  {
1201    if( (*it)->getPOC() == poc )
1202    {
1203      pcPic = *it ;
1204      break ;
1205    }
1206  }
1207  return pcPic;
1208}
1209#endif
1210
1211#if H_3D_VSO
1212Void TEncTop::setupRenModel( Int iPoc, Int iEncViewIdx, Int iEncContent, Int iHorOffset )
1213{
1214  TRenModel* rendererModel = m_cRdCost.getRenModel(); 
1215  rendererModel->setupPart( iHorOffset, std::min( (Int) g_uiMaxCUHeight, (Int) ( m_iSourceHeight - iHorOffset ) )) ; 
1216 
1217  Int iEncViewSIdx = m_cameraParameters->getBaseId2SortedId()[ iEncViewIdx ];
1218
1219  // setup base views
1220  Int iNumOfBV = m_renderModelParameters->getNumOfBaseViewsForView( iEncViewSIdx, iEncContent );
1221
1222  for (Int iCurView = 0; iCurView < iNumOfBV; iCurView++ )
1223  {
1224    Int iBaseViewSIdx;
1225    Int iVideoDistMode;
1226    Int iDepthDistMode;
1227
1228    m_renderModelParameters->getBaseViewData( iEncViewSIdx, iEncContent, iCurView, iBaseViewSIdx, iVideoDistMode, iDepthDistMode );
1229
1230    AOT( iVideoDistMode < 0 || iVideoDistMode > 2 );
1231
1232    Int iBaseViewIdx = m_cameraParameters->getBaseSortedId2Id()[ iBaseViewSIdx ];
1233
1234    TComPicYuv* pcPicYuvVideoRec  = m_ivPicLists->getPicYuv( iBaseViewIdx, false, iPoc, true  );
1235    TComPicYuv* pcPicYuvDepthRec  = m_ivPicLists->getPicYuv( iBaseViewIdx, true , iPoc, true  );
1236    TComPicYuv* pcPicYuvVideoOrg  = m_ivPicLists->getPicYuv( iBaseViewIdx, false, iPoc, false );
1237    TComPicYuv* pcPicYuvDepthOrg  = m_ivPicLists->getPicYuv( iBaseViewIdx, true , iPoc, false );   
1238
1239    TComPicYuv* pcPicYuvVideoRef  = ( iVideoDistMode == 2 ) ? pcPicYuvVideoOrg  : NULL;
1240    TComPicYuv* pcPicYuvDepthRef  = ( iDepthDistMode == 2 ) ? pcPicYuvDepthOrg  : NULL;
1241
1242    TComPicYuv* pcPicYuvVideoTest = ( iVideoDistMode == 0 ) ? pcPicYuvVideoOrg  : pcPicYuvVideoRec;
1243    TComPicYuv* pcPicYuvDepthTest = ( iDepthDistMode == 0 ) ? pcPicYuvDepthOrg  : pcPicYuvDepthRec;
1244
1245    AOT( (iVideoDistMode == 2) != (pcPicYuvVideoRef != NULL) );
1246    AOT( (iDepthDistMode == 2) != (pcPicYuvDepthRef != NULL) );
1247    AOT( pcPicYuvDepthTest == NULL );
1248    AOT( pcPicYuvVideoTest == NULL );
1249
1250    rendererModel->setBaseView( iBaseViewSIdx, pcPicYuvVideoTest, pcPicYuvDepthTest, pcPicYuvVideoRef, pcPicYuvDepthRef );
1251  }
1252
1253  rendererModel->setErrorMode( iEncViewSIdx, iEncContent, 0 );
1254  // setup virtual views
1255  Int iNumOfSV  = m_renderModelParameters->getNumOfModelsForView( iEncViewSIdx, iEncContent );
1256  for (Int iCurView = 0; iCurView < iNumOfSV; iCurView++ )
1257  {
1258    Int iOrgRefBaseViewSIdx;
1259    Int iLeftBaseViewSIdx;
1260    Int iRightBaseViewSIdx;
1261    Int iSynthViewRelNum;
1262    Int iModelNum;
1263    Int iBlendMode;
1264    m_renderModelParameters->getSingleModelData(iEncViewSIdx, iEncContent, iCurView, iModelNum, iBlendMode,iLeftBaseViewSIdx, iRightBaseViewSIdx, iOrgRefBaseViewSIdx, iSynthViewRelNum );
1265
1266    Int iLeftBaseViewIdx    = -1;
1267    Int iRightBaseViewIdx   = -1;
1268
1269    TComPicYuv* pcPicYuvOrgRef  = NULL;
1270    Int**      ppiShiftLUTLeft  = NULL;
1271    Int**      ppiShiftLUTRight = NULL;
1272    Int**      ppiBaseShiftLUTLeft  = NULL;
1273    Int**      ppiBaseShiftLUTRight = NULL;
1274
1275
1276    Int        iDistToLeft      = -1;
1277
1278    Int iSynthViewIdx = m_cameraParameters->synthRelNum2Idx( iSynthViewRelNum );
1279
1280    if ( iLeftBaseViewSIdx != -1 )
1281    {
1282      iLeftBaseViewIdx   = m_cameraParameters->getBaseSortedId2Id()   [ iLeftBaseViewSIdx ];
1283      ppiShiftLUTLeft    = m_cameraParameters->getSynthViewShiftLUTI()[ iLeftBaseViewIdx  ][ iSynthViewIdx  ];
1284    }
1285
1286    if ( iRightBaseViewSIdx != -1 )
1287    {
1288      iRightBaseViewIdx  = m_cameraParameters->getBaseSortedId2Id()   [iRightBaseViewSIdx ];
1289      ppiShiftLUTRight   = m_cameraParameters->getSynthViewShiftLUTI()[ iRightBaseViewIdx ][ iSynthViewIdx ];
1290    }
1291
1292    if ( iRightBaseViewSIdx != -1 && iLeftBaseViewSIdx != -1 )
1293    {
1294      iDistToLeft          = m_cameraParameters->getRelDistLeft(  iSynthViewIdx , iLeftBaseViewIdx, iRightBaseViewIdx);
1295      ppiBaseShiftLUTLeft  = m_cameraParameters->getBaseViewShiftLUTI() [ iLeftBaseViewIdx  ][ iRightBaseViewIdx ];
1296      ppiBaseShiftLUTRight = m_cameraParameters->getBaseViewShiftLUTI() [ iRightBaseViewIdx ][ iLeftBaseViewIdx  ];
1297
1298    }
1299
1300    if ( iOrgRefBaseViewSIdx != -1 )
1301    {
1302      pcPicYuvOrgRef = m_ivPicLists->getPicYuv(  m_cameraParameters->getBaseSortedId2Id()[ iOrgRefBaseViewSIdx ] , false, iPoc, false );
1303      AOF ( pcPicYuvOrgRef );
1304    }
1305
1306    rendererModel->setSingleModel( iModelNum, ppiShiftLUTLeft, ppiBaseShiftLUTLeft, ppiShiftLUTRight, ppiBaseShiftLUTRight, iDistToLeft, pcPicYuvOrgRef );
1307  }
1308}
1309#endif
1310//! \}
Note: See TracBrowser for help on using the repository browser.