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

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

Incorporated:

  • MV-HEVC 5 HLS
  • Cleanups
  • Further ENC_DEC trace functionalities.
  • Update cfg files.
  • Property svn:eol-style set to native
File size: 42.0 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  rpcPic->getPicYuvOrg()->setBorderExtension(false);
518}
519
520Void TEncTop::xInitSPS()
521{
522#if H_MV
523  m_cSPS.setSPSId( getLayerIdInVps() );
524  m_cSPS.setLayerId( getLayerId() );
525#endif
526  ProfileTierLevel& profileTierLevel = *m_cSPS.getPTL()->getGeneralPTL();
527  profileTierLevel.setLevelIdc(m_level);
528  profileTierLevel.setTierFlag(m_levelTier);
529  profileTierLevel.setProfileIdc(m_profile);
530  profileTierLevel.setProfileCompatibilityFlag(m_profile, 1);
531  profileTierLevel.setProgressiveSourceFlag(m_progressiveSourceFlag);
532  profileTierLevel.setInterlacedSourceFlag(m_interlacedSourceFlag);
533  profileTierLevel.setNonPackedConstraintFlag(m_nonPackedConstraintFlag);
534  profileTierLevel.setFrameOnlyConstraintFlag(m_frameOnlyConstraintFlag);
535 
536  if (m_profile == Profile::MAIN10 && g_bitDepthY == 8 && g_bitDepthC == 8)
537  {
538    /* The above constraint is equal to Profile::MAIN */
539    profileTierLevel.setProfileCompatibilityFlag(Profile::MAIN, 1);
540  }
541  if (m_profile == Profile::MAIN)
542  {
543    /* A Profile::MAIN10 decoder can always decode Profile::MAIN */
544    profileTierLevel.setProfileCompatibilityFlag(Profile::MAIN10, 1);
545  }
546  /* XXX: should Main be marked as compatible with still picture? */
547  /* XXX: may be a good idea to refactor the above into a function
548   * that chooses the actual compatibility based upon options */
549
550#if H_MV5
551#if H_MV 
552  m_cSPS.setUpdateRepFormatFlag           ( m_layerId == 0 );   
553  m_cSPS.setSpsInferScalingListFlag       ( m_layerId > 0 && m_cVPS->getInDirectDependencyFlag( getLayerIdInVps(), 0 ) ); 
554  m_cSPS.setSpsScalingListRefLayerId      ( 0              ); 
555#endif
556#endif
557  m_cSPS.setPicWidthInLumaSamples         ( m_iSourceWidth      );
558  m_cSPS.setPicHeightInLumaSamples        ( m_iSourceHeight     );
559  m_cSPS.setConformanceWindow             ( m_conformanceWindow );
560  m_cSPS.setMaxCUWidth    ( g_uiMaxCUWidth      );
561  m_cSPS.setMaxCUHeight   ( g_uiMaxCUHeight     );
562  m_cSPS.setMaxCUDepth    ( g_uiMaxCUDepth      );
563
564  Int minCUSize = m_cSPS.getMaxCUWidth() >> ( m_cSPS.getMaxCUDepth()-g_uiAddCUDepth );
565  Int log2MinCUSize = 0;
566  while(minCUSize > 1)
567  {
568    minCUSize >>= 1;
569    log2MinCUSize++;
570  }
571
572  m_cSPS.setLog2MinCodingBlockSize(log2MinCUSize);
573  m_cSPS.setLog2DiffMaxMinCodingBlockSize(m_cSPS.getMaxCUDepth()-g_uiAddCUDepth);
574 
575  m_cSPS.setPCMLog2MinSize (m_uiPCMLog2MinSize);
576  m_cSPS.setUsePCM        ( m_usePCM           );
577  m_cSPS.setPCMLog2MaxSize( m_pcmLog2MaxSize  );
578
579  m_cSPS.setQuadtreeTULog2MaxSize( m_uiQuadtreeTULog2MaxSize );
580  m_cSPS.setQuadtreeTULog2MinSize( m_uiQuadtreeTULog2MinSize );
581  m_cSPS.setQuadtreeTUMaxDepthInter( m_uiQuadtreeTUMaxDepthInter    );
582  m_cSPS.setQuadtreeTUMaxDepthIntra( m_uiQuadtreeTUMaxDepthIntra    );
583 
584  m_cSPS.setTMVPFlagsPresent(false);
585  m_cSPS.setUseLossless   ( m_useLossless  );
586
587  m_cSPS.setMaxTrSize   ( 1 << m_uiQuadtreeTULog2MaxSize );
588 
589  Int i;
590 
591  for (i = 0; i < g_uiMaxCUDepth-g_uiAddCUDepth; i++ )
592  {
593    m_cSPS.setAMPAcc( i, m_useAMP );
594    //m_cSPS.setAMPAcc( i, 1 );
595  }
596
597  m_cSPS.setUseAMP ( m_useAMP );
598
599#if H_3D_QTLPC
600  m_cSPS.setUseQTL( m_bUseQTL );
601  m_cSPS.setUsePC ( m_bUsePC  );
602#endif
603
604  for (i = g_uiMaxCUDepth-g_uiAddCUDepth; i < g_uiMaxCUDepth; i++ )
605  {
606    m_cSPS.setAMPAcc(i, 0);
607  }
608
609  m_cSPS.setBitDepthY( g_bitDepthY );
610  m_cSPS.setBitDepthC( g_bitDepthC );
611
612  m_cSPS.setQpBDOffsetY ( 6*(g_bitDepthY - 8) );
613  m_cSPS.setQpBDOffsetC ( 6*(g_bitDepthC - 8) );
614
615  m_cSPS.setUseSAO( m_bUseSAO );
616
617  m_cSPS.setMaxTLayers( m_maxTempLayer );
618  m_cSPS.setTemporalIdNestingFlag( ( m_maxTempLayer == 1 ) ? true : false );
619  for ( i = 0; i < m_cSPS.getMaxTLayers(); i++ )
620  {
621    m_cSPS.setMaxDecPicBuffering(m_maxDecPicBuffering[i], i);
622    m_cSPS.setNumReorderPics(m_numReorderPics[i], i);
623  }
624  m_cSPS.setPCMBitDepthLuma (g_uiPCMBitDepthLuma);
625  m_cSPS.setPCMBitDepthChroma (g_uiPCMBitDepthChroma);
626  m_cSPS.setPCMFilterDisableFlag  ( m_bPCMFilterDisableFlag );
627
628  m_cSPS.setScalingListFlag ( (m_useScalingListId == 0) ? 0 : 1 );
629
630  m_cSPS.setUseStrongIntraSmoothing( m_useStrongIntraSmoothing );
631
632  m_cSPS.setVuiParametersPresentFlag(getVuiParametersPresentFlag());
633  if (m_cSPS.getVuiParametersPresentFlag())
634  {
635    TComVUI* pcVUI = m_cSPS.getVuiParameters();
636    pcVUI->setAspectRatioInfoPresentFlag(getAspectRatioIdc() != -1);
637    pcVUI->setAspectRatioIdc(getAspectRatioIdc());
638    pcVUI->setSarWidth(getSarWidth());
639    pcVUI->setSarHeight(getSarHeight());
640    pcVUI->setOverscanInfoPresentFlag(getOverscanInfoPresentFlag());
641    pcVUI->setOverscanAppropriateFlag(getOverscanAppropriateFlag());
642    pcVUI->setVideoSignalTypePresentFlag(getVideoSignalTypePresentFlag());
643    pcVUI->setVideoFormat(getVideoFormat());
644    pcVUI->setVideoFullRangeFlag(getVideoFullRangeFlag());
645    pcVUI->setColourDescriptionPresentFlag(getColourDescriptionPresentFlag());
646    pcVUI->setColourPrimaries(getColourPrimaries());
647    pcVUI->setTransferCharacteristics(getTransferCharacteristics());
648    pcVUI->setMatrixCoefficients(getMatrixCoefficients());
649    pcVUI->setChromaLocInfoPresentFlag(getChromaLocInfoPresentFlag());
650    pcVUI->setChromaSampleLocTypeTopField(getChromaSampleLocTypeTopField());
651    pcVUI->setChromaSampleLocTypeBottomField(getChromaSampleLocTypeBottomField());
652    pcVUI->setNeutralChromaIndicationFlag(getNeutralChromaIndicationFlag());
653    pcVUI->setDefaultDisplayWindow(getDefaultDisplayWindow());
654    pcVUI->setFrameFieldInfoPresentFlag(getFrameFieldInfoPresentFlag());
655    pcVUI->setFieldSeqFlag(false);
656    pcVUI->setHrdParametersPresentFlag(false);
657    pcVUI->getTimingInfo()->setPocProportionalToTimingFlag(getPocProportionalToTimingFlag());
658    pcVUI->getTimingInfo()->setNumTicksPocDiffOneMinus1   (getNumTicksPocDiffOneMinus1()   );
659    pcVUI->setBitstreamRestrictionFlag(getBitstreamRestrictionFlag());
660    pcVUI->setTilesFixedStructureFlag(getTilesFixedStructureFlag());
661    pcVUI->setMotionVectorsOverPicBoundariesFlag(getMotionVectorsOverPicBoundariesFlag());
662    pcVUI->setMinSpatialSegmentationIdc(getMinSpatialSegmentationIdc());
663    pcVUI->setMaxBytesPerPicDenom(getMaxBytesPerPicDenom());
664    pcVUI->setMaxBitsPerMinCuDenom(getMaxBitsPerMinCuDenom());
665    pcVUI->setLog2MaxMvLengthHorizontal(getLog2MaxMvLengthHorizontal());
666    pcVUI->setLog2MaxMvLengthVertical(getLog2MaxMvLengthVertical());
667  }
668#if H_3D
669  if ( !m_isDepth )
670  {
671    m_cSPS.initCamParaSPS           ( m_viewIndex, m_uiCamParPrecision, m_bCamParInSliceHeader, m_aaiCodedScale, m_aaiCodedOffset );
672  }
673#endif
674}
675
676Void TEncTop::xInitPPS()
677{
678#if H_MV
679#if H_MV5
680  m_cPPS.setLayerId( getLayerId() );
681  if( getVPS()->getNumDirectRefLayers( getLayerId() ) > 0 )
682#else
683  if( getVPS()->getNumDirectRefLayers( getLayerIdInVps() ) > 0 )
684#endif
685  {
686    m_cPPS.setListsModificationPresentFlag( true );
687  }
688  m_cPPS.setPPSId( getLayerIdInVps() );
689  m_cPPS.setSPSId( getLayerIdInVps() );
690#endif
691  m_cPPS.setConstrainedIntraPred( m_bUseConstrainedIntraPred );
692  Bool bUseDQP = (getMaxCuDQPDepth() > 0)? true : false;
693
694  Int lowestQP = - m_cSPS.getQpBDOffsetY();
695
696  if(getUseLossless())
697  {
698    if ((getMaxCuDQPDepth() == 0) && (getMaxDeltaQP() == 0 ) && (getQP() == lowestQP) )
699    {
700      bUseDQP = false;
701    }
702    else
703    {
704      bUseDQP = true;
705    }
706  }
707  else
708  {
709    if(bUseDQP == false)
710    {
711      if((getMaxDeltaQP() != 0 )|| getUseAdaptiveQP())
712      {
713        bUseDQP = true;
714      }
715    }
716  }
717
718  if(bUseDQP)
719  {
720    m_cPPS.setUseDQP(true);
721    m_cPPS.setMaxCuDQPDepth( m_iMaxCuDQPDepth );
722    m_cPPS.setMinCuDQPSize( m_cPPS.getSPS()->getMaxCUWidth() >> ( m_cPPS.getMaxCuDQPDepth()) );
723  }
724  else
725  {
726    m_cPPS.setUseDQP(false);
727    m_cPPS.setMaxCuDQPDepth( 0 );
728    m_cPPS.setMinCuDQPSize( m_cPPS.getSPS()->getMaxCUWidth() >> ( m_cPPS.getMaxCuDQPDepth()) );
729  }
730
731#if RATE_CONTROL_LAMBDA_DOMAIN
732  if ( m_RCEnableRateControl )
733  {
734    m_cPPS.setUseDQP(true);
735    m_cPPS.setMaxCuDQPDepth( 0 );
736    m_cPPS.setMinCuDQPSize( m_cPPS.getSPS()->getMaxCUWidth() >> ( m_cPPS.getMaxCuDQPDepth()) );
737  } 
738#endif
739
740  m_cPPS.setChromaCbQpOffset( m_chromaCbQpOffset );
741  m_cPPS.setChromaCrQpOffset( m_chromaCrQpOffset );
742
743  m_cPPS.setNumSubstreams(m_iWaveFrontSubstreams);
744  m_cPPS.setEntropyCodingSyncEnabledFlag( m_iWaveFrontSynchro > 0 );
745  m_cPPS.setTilesEnabledFlag( (m_iNumColumnsMinus1 > 0 || m_iNumRowsMinus1 > 0) );
746  m_cPPS.setUseWP( m_useWeightedPred );
747  m_cPPS.setWPBiPred( m_useWeightedBiPred );
748  m_cPPS.setOutputFlagPresentFlag( false );
749#if H_MV
750#if H_MV5
751  m_cPPS.setNumExtraSliceHeaderBits( 2 ); 
752#else
753  m_cPPS.setNumExtraSliceHeaderBits( 1 ); 
754#endif
755#endif
756  m_cPPS.setSignHideFlag(getSignHideFlag());
757#if L0386_DB_METRIC
758  if ( getDeblockingFilterMetric() )
759  {
760    m_cPPS.setDeblockingFilterControlPresentFlag (true);
761    m_cPPS.setDeblockingFilterOverrideEnabledFlag(true);
762    m_cPPS.setPicDisableDeblockingFilterFlag(false);
763    m_cPPS.setDeblockingFilterBetaOffsetDiv2(0);
764    m_cPPS.setDeblockingFilterTcOffsetDiv2(0);
765  } 
766  else
767  {
768  m_cPPS.setDeblockingFilterControlPresentFlag (m_DeblockingFilterControlPresent );
769  }
770#else
771  m_cPPS.setDeblockingFilterControlPresentFlag (m_DeblockingFilterControlPresent );
772#endif
773  m_cPPS.setLog2ParallelMergeLevelMinus2   (m_log2ParallelMergeLevelMinus2 );
774  m_cPPS.setCabacInitPresentFlag(CABAC_INIT_PRESENT_FLAG);
775  m_cPPS.setLoopFilterAcrossSlicesEnabledFlag( m_bLFCrossSliceBoundaryFlag );
776  Int histogram[MAX_NUM_REF + 1];
777  for( Int i = 0; i <= MAX_NUM_REF; i++ )
778  {
779    histogram[i]=0;
780  }
781  for( Int i = 0; i < getGOPSize(); i++ )
782  {
783    assert(getGOPEntry(i).m_numRefPicsActive >= 0 && getGOPEntry(i).m_numRefPicsActive <= MAX_NUM_REF);
784    histogram[getGOPEntry(i).m_numRefPicsActive]++;
785  }
786  Int maxHist=-1;
787  Int bestPos=0;
788  for( Int i = 0; i <= MAX_NUM_REF; i++ )
789  {
790    if(histogram[i]>maxHist)
791    {
792      maxHist=histogram[i];
793      bestPos=i;
794    }
795  }
796  assert(bestPos <= 15);
797  m_cPPS.setNumRefIdxL0DefaultActive(bestPos);
798  m_cPPS.setNumRefIdxL1DefaultActive(bestPos);
799  m_cPPS.setTransquantBypassEnableFlag(getTransquantBypassEnableFlag());
800  m_cPPS.setUseTransformSkip( m_useTransformSkip );
801  if (m_sliceSegmentMode)
802  {
803    m_cPPS.setDependentSliceSegmentsEnabledFlag( true );
804  }
805  if( m_cPPS.getDependentSliceSegmentsEnabledFlag() )
806  {
807    Int NumCtx = m_cPPS.getEntropyCodingSyncEnabledFlag()?2:1;
808    m_cSliceEncoder.initCtxMem( NumCtx );
809    for ( UInt st = 0; st < NumCtx; st++ )
810    {
811      TEncSbac* ctx = NULL;
812      ctx = new TEncSbac;
813      ctx->init( &m_cBinCoderCABAC );
814      m_cSliceEncoder.setCtxMem( ctx, st );
815    }
816  }
817#if H_3D
818  if( m_cSPS.hasCamParInSliceHeader() )
819  {
820    m_cPPS.setSliceHeaderExtensionPresentFlag( true ); 
821  }
822#endif
823}
824
825//Function for initializing m_RPSList, a list of TComReferencePictureSet, based on the GOPEntry objects read from the config file.
826Void TEncTop::xInitRPS()
827{
828  TComReferencePictureSet*      rps;
829 
830  m_cSPS.createRPSList(getGOPSize()+m_extraRPSs);
831  TComRPSList* rpsList = m_cSPS.getRPSList();
832
833  for( Int i = 0; i < getGOPSize()+m_extraRPSs; i++) 
834  {
835    GOPEntry ge = getGOPEntry(i);
836    rps = rpsList->getReferencePictureSet(i);
837    rps->setNumberOfPictures(ge.m_numRefPics);
838    rps->setNumRefIdc(ge.m_numRefIdc);
839    Int numNeg = 0;
840    Int numPos = 0;
841    for( Int j = 0; j < ge.m_numRefPics; j++)
842    {
843      rps->setDeltaPOC(j,ge.m_referencePics[j]);
844      rps->setUsed(j,ge.m_usedByCurrPic[j]);
845      if(ge.m_referencePics[j]>0)
846      {
847        numPos++;
848      }
849      else
850      {
851        numNeg++;
852      }
853    }
854    rps->setNumberOfNegativePictures(numNeg);
855    rps->setNumberOfPositivePictures(numPos);
856
857    // handle inter RPS intialization from the config file.
858#if AUTO_INTER_RPS
859    rps->setInterRPSPrediction(ge.m_interRPSPrediction > 0);  // not very clean, converting anything > 0 to true.
860    rps->setDeltaRIdxMinus1(0);                               // index to the Reference RPS is always the previous one.
861    TComReferencePictureSet*     RPSRef = rpsList->getReferencePictureSet(i-1);  // get the reference RPS
862
863    if (ge.m_interRPSPrediction == 2)  // Automatic generation of the inter RPS idc based on the RIdx provided.
864    {
865      Int deltaRPS = getGOPEntry(i-1).m_POC - ge.m_POC;  // the ref POC - current POC
866      Int numRefDeltaPOC = RPSRef->getNumberOfPictures();
867
868      rps->setDeltaRPS(deltaRPS);           // set delta RPS
869      rps->setNumRefIdc(numRefDeltaPOC+1);  // set the numRefIdc to the number of pictures in the reference RPS + 1.
870      Int count=0;
871      for (Int j = 0; j <= numRefDeltaPOC; j++ ) // cycle through pics in reference RPS.
872      {
873        Int RefDeltaPOC = (j<numRefDeltaPOC)? RPSRef->getDeltaPOC(j): 0;  // if it is the last decoded picture, set RefDeltaPOC = 0
874        rps->setRefIdc(j, 0);
875        for (Int k = 0; k < rps->getNumberOfPictures(); k++ )  // cycle through pics in current RPS.
876        {
877          if (rps->getDeltaPOC(k) == ( RefDeltaPOC + deltaRPS))  // if the current RPS has a same picture as the reference RPS.
878          {
879              rps->setRefIdc(j, (rps->getUsed(k)?1:2));
880              count++;
881              break;
882          }
883        }
884      }
885      if (count != rps->getNumberOfPictures())
886      {
887        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");
888        rps->setInterRPSPrediction(0);
889      }
890    }
891    else if (ge.m_interRPSPrediction == 1)  // inter RPS idc based on the RefIdc values provided in config file.
892    {
893      rps->setDeltaRPS(ge.m_deltaRPS);
894      rps->setNumRefIdc(ge.m_numRefIdc);
895      for (Int j = 0; j < ge.m_numRefIdc; j++ )
896      {
897        rps->setRefIdc(j, ge.m_refIdc[j]);
898      }
899#if WRITE_BACK
900      // the folowing code overwrite the deltaPOC and Used by current values read from the config file with the ones
901      // computed from the RefIdc.  A warning is printed if they are not identical.
902      numNeg = 0;
903      numPos = 0;
904      TComReferencePictureSet      RPSTemp;  // temporary variable
905
906      for (Int j = 0; j < ge.m_numRefIdc; j++ )
907      {
908        if (ge.m_refIdc[j])
909        {
910          Int deltaPOC = ge.m_deltaRPS + ((j < RPSRef->getNumberOfPictures())? RPSRef->getDeltaPOC(j) : 0);
911          RPSTemp.setDeltaPOC((numNeg+numPos),deltaPOC);
912          RPSTemp.setUsed((numNeg+numPos),ge.m_refIdc[j]==1?1:0);
913          if (deltaPOC<0)
914          {
915            numNeg++;
916          }
917          else
918          {
919            numPos++;
920          }
921        }
922      }
923      if (numNeg != rps->getNumberOfNegativePictures())
924      {
925        printf("Warning: number of negative pictures in RPS is different between intra and inter RPS specified in the config file.\n");
926        rps->setNumberOfNegativePictures(numNeg);
927        rps->setNumberOfPositivePictures(numNeg+numPos);
928      }
929      if (numPos != rps->getNumberOfPositivePictures())
930      {
931        printf("Warning: number of positive pictures in RPS is different between intra and inter RPS specified in the config file.\n");
932        rps->setNumberOfPositivePictures(numPos);
933        rps->setNumberOfPositivePictures(numNeg+numPos);
934      }
935      RPSTemp.setNumberOfPictures(numNeg+numPos);
936      RPSTemp.setNumberOfNegativePictures(numNeg);
937      RPSTemp.sortDeltaPOC();     // sort the created delta POC before comparing
938      // check if Delta POC and Used are the same
939      // print warning if they are not.
940      for (Int j = 0; j < ge.m_numRefIdc; j++ )
941      {
942        if (RPSTemp.getDeltaPOC(j) != rps->getDeltaPOC(j))
943        {
944          printf("Warning: delta POC is different between intra RPS and inter RPS specified in the config file.\n");
945          rps->setDeltaPOC(j,RPSTemp.getDeltaPOC(j));
946        }
947        if (RPSTemp.getUsed(j) != rps->getUsed(j))
948        {
949          printf("Warning: Used by Current in RPS is different between intra and inter RPS specified in the config file.\n");
950          rps->setUsed(j,RPSTemp.getUsed(j));
951        }
952      }
953#endif
954    }
955#else
956    rps->setInterRPSPrediction(ge.m_interRPSPrediction);
957    if (ge.m_interRPSPrediction)
958    {
959      rps->setDeltaRIdxMinus1(0);
960      rps->setDeltaRPS(ge.m_deltaRPS);
961      rps->setNumRefIdc(ge.m_numRefIdc);
962      for (Int j = 0; j < ge.m_numRefIdc; j++ )
963      {
964        rps->setRefIdc(j, ge.m_refIdc[j]);
965      }
966#if WRITE_BACK
967      // the folowing code overwrite the deltaPOC and Used by current values read from the config file with the ones
968      // computed from the RefIdc.  This is not necessary if both are identical. Currently there is no check to see if they are identical.
969      numNeg = 0;
970      numPos = 0;
971      TComReferencePictureSet*     RPSRef = m_RPSList.getReferencePictureSet(i-1);
972
973      for (Int j = 0; j < ge.m_numRefIdc; j++ )
974      {
975        if (ge.m_refIdc[j])
976        {
977          Int deltaPOC = ge.m_deltaRPS + ((j < RPSRef->getNumberOfPictures())? RPSRef->getDeltaPOC(j) : 0);
978          rps->setDeltaPOC((numNeg+numPos),deltaPOC);
979          rps->setUsed((numNeg+numPos),ge.m_refIdc[j]==1?1:0);
980          if (deltaPOC<0)
981          {
982            numNeg++;
983          }
984          else
985          {
986            numPos++;
987          }
988        }
989      }
990      rps->setNumberOfNegativePictures(numNeg);
991      rps->setNumberOfPositivePictures(numPos);
992      rps->sortDeltaPOC();
993#endif
994    }
995#endif //INTER_RPS_AUTO
996  }
997 
998}
999
1000   // This is a function that
1001   // determines what Reference Picture Set to use
1002   // for a specific slice (with POC = POCCurr)
1003Void TEncTop::selectReferencePictureSet(TComSlice* slice, Int POCCurr, Int GOPid )
1004{
1005#if H_MV
1006  if( slice->getRapPicFlag() == true && getLayerId() > 0 && POCCurr == 0 )
1007  {
1008    TComReferencePictureSet* rps = slice->getLocalRPS();
1009    rps->setNumberOfNegativePictures(0);
1010    rps->setNumberOfPositivePictures(0);
1011    rps->setNumberOfLongtermPictures(0);
1012    rps->setNumberOfPictures(0);
1013    slice->setRPS(rps);
1014  }
1015  else
1016  {
1017#endif
1018  slice->setRPSidx(GOPid);
1019
1020  for(Int extraNum=m_iGOPSize; extraNum<m_extraRPSs+m_iGOPSize; extraNum++)
1021  {   
1022    if(m_uiIntraPeriod > 0 && getDecodingRefreshType() > 0)
1023    {
1024      Int POCIndex = POCCurr%m_uiIntraPeriod;
1025      if(POCIndex == 0)
1026      {
1027        POCIndex = m_uiIntraPeriod;
1028      }
1029      if(POCIndex == m_GOPList[extraNum].m_POC)
1030      {
1031        slice->setRPSidx(extraNum);
1032      }
1033    }
1034    else
1035    {
1036      if(POCCurr==m_GOPList[extraNum].m_POC)
1037      {
1038        slice->setRPSidx(extraNum);
1039      }
1040    }
1041  }
1042
1043  slice->setRPS(getSPS()->getRPSList()->getReferencePictureSet(slice->getRPSidx()));
1044  slice->getRPS()->setNumberOfPictures(slice->getRPS()->getNumberOfNegativePictures()+slice->getRPS()->getNumberOfPositivePictures());
1045#if H_MV
1046  }
1047#endif
1048
1049}
1050
1051Int TEncTop::getReferencePictureSetIdxForSOP(TComSlice* slice, Int POCCurr, Int GOPid )
1052{
1053  int rpsIdx = GOPid;
1054
1055  for(Int extraNum=m_iGOPSize; extraNum<m_extraRPSs+m_iGOPSize; extraNum++)
1056  {   
1057    if(m_uiIntraPeriod > 0 && getDecodingRefreshType() > 0)
1058    {
1059      Int POCIndex = POCCurr%m_uiIntraPeriod;
1060      if(POCIndex == 0)
1061      {
1062        POCIndex = m_uiIntraPeriod;
1063      }
1064      if(POCIndex == m_GOPList[extraNum].m_POC)
1065      {
1066        rpsIdx = extraNum;
1067      }
1068    }
1069    else
1070    {
1071      if(POCCurr==m_GOPList[extraNum].m_POC)
1072      {
1073        rpsIdx = extraNum;
1074      }
1075    }
1076  }
1077
1078  return rpsIdx;
1079}
1080
1081Void  TEncTop::xInitPPSforTiles()
1082{
1083  m_cPPS.setUniformSpacingFlag( m_iUniformSpacingIdr );
1084  m_cPPS.setNumColumnsMinus1( m_iNumColumnsMinus1 );
1085  m_cPPS.setNumRowsMinus1( m_iNumRowsMinus1 );
1086  if( m_iUniformSpacingIdr == 0 )
1087  {
1088    m_cPPS.setColumnWidth( m_puiColumnWidth );
1089    m_cPPS.setRowHeight( m_puiRowHeight );
1090  }
1091  m_cPPS.setLoopFilterAcrossTilesEnabledFlag( m_loopFilterAcrossTilesEnabledFlag );
1092
1093  // # substreams is "per tile" when tiles are independent.
1094  if (m_iWaveFrontSynchro
1095    )
1096  {
1097    m_cPPS.setNumSubstreams(m_iWaveFrontSubstreams * (m_iNumColumnsMinus1+1));
1098  }
1099}
1100
1101Void  TEncCfg::xCheckGSParameters()
1102{
1103  Int   iWidthInCU = ( m_iSourceWidth%g_uiMaxCUWidth ) ? m_iSourceWidth/g_uiMaxCUWidth + 1 : m_iSourceWidth/g_uiMaxCUWidth;
1104  Int   iHeightInCU = ( m_iSourceHeight%g_uiMaxCUHeight ) ? m_iSourceHeight/g_uiMaxCUHeight + 1 : m_iSourceHeight/g_uiMaxCUHeight;
1105  UInt  uiCummulativeColumnWidth = 0;
1106  UInt  uiCummulativeRowHeight = 0;
1107
1108  //check the column relative parameters
1109  if( m_iNumColumnsMinus1 >= (1<<(LOG2_MAX_NUM_COLUMNS_MINUS1+1)) )
1110  {
1111    printf( "The number of columns is larger than the maximum allowed number of columns.\n" );
1112    exit( EXIT_FAILURE );
1113  }
1114
1115  if( m_iNumColumnsMinus1 >= iWidthInCU )
1116  {
1117    printf( "The current picture can not have so many columns.\n" );
1118    exit( EXIT_FAILURE );
1119  }
1120
1121  if( m_iNumColumnsMinus1 && m_iUniformSpacingIdr==0 )
1122  {
1123    for(Int i=0; i<m_iNumColumnsMinus1; i++)
1124    {
1125      uiCummulativeColumnWidth += m_puiColumnWidth[i];
1126    }
1127
1128    if( uiCummulativeColumnWidth >= iWidthInCU )
1129    {
1130      printf( "The width of the column is too large.\n" );
1131      exit( EXIT_FAILURE );
1132    }
1133  }
1134
1135  //check the row relative parameters
1136  if( m_iNumRowsMinus1 >= (1<<(LOG2_MAX_NUM_ROWS_MINUS1+1)) )
1137  {
1138    printf( "The number of rows is larger than the maximum allowed number of rows.\n" );
1139    exit( EXIT_FAILURE );
1140  }
1141
1142  if( m_iNumRowsMinus1 >= iHeightInCU )
1143  {
1144    printf( "The current picture can not have so many rows.\n" );
1145    exit( EXIT_FAILURE );
1146  }
1147
1148  if( m_iNumRowsMinus1 && m_iUniformSpacingIdr==0 )
1149  {
1150    for(Int i=0; i<m_iNumRowsMinus1; i++)
1151      uiCummulativeRowHeight += m_puiRowHeight[i];
1152
1153    if( uiCummulativeRowHeight >= iHeightInCU )
1154    {
1155      printf( "The height of the row is too large.\n" );
1156      exit( EXIT_FAILURE );
1157    }
1158  }
1159}
1160#if H_MV
1161Void TEncTop::printSummary( Int numAllPicCoded )
1162{
1163  assert (numAllPicCoded == m_cAnalyzeAll.getNumPic());
1164
1165  //--CFG_KDY
1166  m_cAnalyzeAll.setFrmRate( getFrameRate() );
1167  m_cAnalyzeI.setFrmRate( getFrameRate() );
1168  m_cAnalyzeP.setFrmRate( getFrameRate() );
1169  m_cAnalyzeB.setFrmRate( getFrameRate() );
1170
1171  //-- all
1172  printf( "\n\nSUMMARY ------------------------------------------- LayerId %2d\n", m_layerId );
1173
1174  m_cAnalyzeAll.printOut('a');
1175
1176  printf( "\n\nI Slices--------------------------------------------------------\n" );
1177  m_cAnalyzeI.printOut('i');
1178
1179  printf( "\n\nP Slices--------------------------------------------------------\n" );
1180  m_cAnalyzeP.printOut('p');
1181
1182  printf( "\n\nB Slices--------------------------------------------------------\n" );
1183  m_cAnalyzeB.printOut('b');
1184
1185#if _SUMMARY_OUT_
1186  m_cAnalyzeAll.printSummaryOut();
1187#endif
1188#if _SUMMARY_PIC_
1189  m_cAnalyzeI.printSummary('I');
1190  m_cAnalyzeP.printSummary('P');
1191  m_cAnalyzeB.printSummary('B');
1192#endif
1193}
1194
1195Int TEncTop::getFrameId(Int iGOPid) 
1196{
1197  if(m_iPOCLast == 0)
1198  {
1199    return(0 );
1200  }
1201  else
1202  {
1203    return m_iPOCLast -m_iNumPicRcvd+ getGOPEntry(iGOPid).m_POC ;
1204  }
1205}
1206
1207TComPic* TEncTop::getPic( Int poc )
1208{
1209  TComList<TComPic*>* listPic = getListPic();
1210  TComPic* pcPic = NULL;
1211  for(TComList<TComPic*>::iterator it=listPic->begin(); it!=listPic->end(); it++)
1212  {
1213    if( (*it)->getPOC() == poc )
1214    {
1215      pcPic = *it ;
1216      break ;
1217    }
1218  }
1219  return pcPic;
1220}
1221#endif
1222
1223#if H_3D_VSO
1224Void TEncTop::setupRenModel( Int iPoc, Int iEncViewIdx, Int iEncContent, Int iHorOffset )
1225{
1226  TRenModel* rendererModel = m_cRdCost.getRenModel(); 
1227  rendererModel->setupPart( iHorOffset, std::min( (Int) g_uiMaxCUHeight, (Int) ( m_iSourceHeight - iHorOffset ) )) ; 
1228 
1229  Int iEncViewSIdx = m_cameraParameters->getBaseId2SortedId()[ iEncViewIdx ];
1230
1231  // setup base views
1232  Int iNumOfBV = m_renderModelParameters->getNumOfBaseViewsForView( iEncViewSIdx, iEncContent );
1233
1234  for (Int iCurView = 0; iCurView < iNumOfBV; iCurView++ )
1235  {
1236    Int iBaseViewSIdx;
1237    Int iVideoDistMode;
1238    Int iDepthDistMode;
1239
1240    m_renderModelParameters->getBaseViewData( iEncViewSIdx, iEncContent, iCurView, iBaseViewSIdx, iVideoDistMode, iDepthDistMode );
1241
1242    AOT( iVideoDistMode < 0 || iVideoDistMode > 2 );
1243
1244    Int iBaseViewIdx = m_cameraParameters->getBaseSortedId2Id()[ iBaseViewSIdx ];
1245
1246    TComPicYuv* pcPicYuvVideoRec  = m_ivPicLists->getPicYuv( iBaseViewIdx, false, iPoc, true  );
1247    TComPicYuv* pcPicYuvDepthRec  = m_ivPicLists->getPicYuv( iBaseViewIdx, true , iPoc, true  );
1248    TComPicYuv* pcPicYuvVideoOrg  = m_ivPicLists->getPicYuv( iBaseViewIdx, false, iPoc, false );
1249    TComPicYuv* pcPicYuvDepthOrg  = m_ivPicLists->getPicYuv( iBaseViewIdx, true , iPoc, false );   
1250
1251    TComPicYuv* pcPicYuvVideoRef  = ( iVideoDistMode == 2 ) ? pcPicYuvVideoOrg  : NULL;
1252    TComPicYuv* pcPicYuvDepthRef  = ( iDepthDistMode == 2 ) ? pcPicYuvDepthOrg  : NULL;
1253
1254    TComPicYuv* pcPicYuvVideoTest = ( iVideoDistMode == 0 ) ? pcPicYuvVideoOrg  : pcPicYuvVideoRec;
1255    TComPicYuv* pcPicYuvDepthTest = ( iDepthDistMode == 0 ) ? pcPicYuvDepthOrg  : pcPicYuvDepthRec;
1256
1257    AOT( (iVideoDistMode == 2) != (pcPicYuvVideoRef != NULL) );
1258    AOT( (iDepthDistMode == 2) != (pcPicYuvDepthRef != NULL) );
1259    AOT( pcPicYuvDepthTest == NULL );
1260    AOT( pcPicYuvVideoTest == NULL );
1261
1262    rendererModel->setBaseView( iBaseViewSIdx, pcPicYuvVideoTest, pcPicYuvDepthTest, pcPicYuvVideoRef, pcPicYuvDepthRef );
1263  }
1264
1265  rendererModel->setErrorMode( iEncViewSIdx, iEncContent, 0 );
1266  // setup virtual views
1267  Int iNumOfSV  = m_renderModelParameters->getNumOfModelsForView( iEncViewSIdx, iEncContent );
1268  for (Int iCurView = 0; iCurView < iNumOfSV; iCurView++ )
1269  {
1270    Int iOrgRefBaseViewSIdx;
1271    Int iLeftBaseViewSIdx;
1272    Int iRightBaseViewSIdx;
1273    Int iSynthViewRelNum;
1274    Int iModelNum;
1275    Int iBlendMode;
1276    m_renderModelParameters->getSingleModelData(iEncViewSIdx, iEncContent, iCurView, iModelNum, iBlendMode,iLeftBaseViewSIdx, iRightBaseViewSIdx, iOrgRefBaseViewSIdx, iSynthViewRelNum );
1277
1278    Int iLeftBaseViewIdx    = -1;
1279    Int iRightBaseViewIdx   = -1;
1280
1281    TComPicYuv* pcPicYuvOrgRef  = NULL;
1282    Int**      ppiShiftLUTLeft  = NULL;
1283    Int**      ppiShiftLUTRight = NULL;
1284    Int**      ppiBaseShiftLUTLeft  = NULL;
1285    Int**      ppiBaseShiftLUTRight = NULL;
1286
1287
1288    Int        iDistToLeft      = -1;
1289
1290    Int iSynthViewIdx = m_cameraParameters->synthRelNum2Idx( iSynthViewRelNum );
1291
1292    if ( iLeftBaseViewSIdx != -1 )
1293    {
1294      iLeftBaseViewIdx   = m_cameraParameters->getBaseSortedId2Id()   [ iLeftBaseViewSIdx ];
1295      ppiShiftLUTLeft    = m_cameraParameters->getSynthViewShiftLUTI()[ iLeftBaseViewIdx  ][ iSynthViewIdx  ];
1296    }
1297
1298    if ( iRightBaseViewSIdx != -1 )
1299    {
1300      iRightBaseViewIdx  = m_cameraParameters->getBaseSortedId2Id()   [iRightBaseViewSIdx ];
1301      ppiShiftLUTRight   = m_cameraParameters->getSynthViewShiftLUTI()[ iRightBaseViewIdx ][ iSynthViewIdx ];
1302    }
1303
1304    if ( iRightBaseViewSIdx != -1 && iLeftBaseViewSIdx != -1 )
1305    {
1306      iDistToLeft          = m_cameraParameters->getRelDistLeft(  iSynthViewIdx , iLeftBaseViewIdx, iRightBaseViewIdx);
1307      ppiBaseShiftLUTLeft  = m_cameraParameters->getBaseViewShiftLUTI() [ iLeftBaseViewIdx  ][ iRightBaseViewIdx ];
1308      ppiBaseShiftLUTRight = m_cameraParameters->getBaseViewShiftLUTI() [ iRightBaseViewIdx ][ iLeftBaseViewIdx  ];
1309
1310    }
1311
1312    if ( iOrgRefBaseViewSIdx != -1 )
1313    {
1314      pcPicYuvOrgRef = m_ivPicLists->getPicYuv(  m_cameraParameters->getBaseSortedId2Id()[ iOrgRefBaseViewSIdx ] , false, iPoc, false );
1315      AOF ( pcPicYuvOrgRef );
1316    }
1317
1318    rendererModel->setSingleModel( iModelNum, ppiShiftLUTLeft, ppiBaseShiftLUTLeft, ppiShiftLUTRight, ppiBaseShiftLUTRight, iDistToLeft, pcPicYuvOrgRef );
1319  }
1320}
1321#endif
1322//! \}
Note: See TracBrowser for help on using the repository browser.