source: 3DVCSoftware/branches/HTM-DEV-0.1-dev/source/Lib/TLibEncoder/TEncTop.cpp @ 365

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

Further minor cleanups.

  • Property svn:eol-style set to native
File size: 36.8 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  *m_cVPS.getPTL() = *m_cSPS.getPTL();
293#if L0043_TIMING_INFO
294  m_cVPS.getTimingInfo()->setTimingInfoPresentFlag       ( false );
295#endif
296  // initialize PPS
297  m_cPPS.setSPS(&m_cSPS);
298  xInitPPS();
299  xInitRPS();
300
301  xInitPPSforTiles();
302
303  // initialize processing unit classes
304  m_cGOPEncoder.  init( this );
305  m_cSliceEncoder.init( this );
306  m_cCuEncoder.   init( this );
307 
308  // initialize transform & quantization class
309  m_pcCavlcCoder = getCavlcCoder();
310 
311  m_cTrQuant.init( 1 << m_uiQuadtreeTULog2MaxSize,
312                  m_useRDOQ, 
313                  m_useRDOQTS,
314                  true 
315                  ,m_useTransformSkipFast
316#if ADAPTIVE_QP_SELECTION                 
317                  , m_bUseAdaptQpSelect
318#endif
319                  );
320 
321  // initialize encoder search class
322  m_cSearch.init( this, &m_cTrQuant, m_iSearchRange, m_bipredSearchRange, m_iFastSearch, 0, &m_cEntropyCoder, &m_cRdCost, getRDSbacCoder(), getRDGoOnSbacCoder() );
323
324  m_iMaxRefPicNum = 0;
325}
326
327// ====================================================================================================================
328// Public member functions
329// ====================================================================================================================
330
331#if H_MV
332Void TEncTop::initNewPic( TComPicYuv* pcPicYuvOrg )
333{
334  TComPic* pcPicCurr = NULL;
335
336  // get original YUV
337  xGetNewPicBuffer( pcPicCurr );
338  pcPicYuvOrg->copyToPic( pcPicCurr->getPicYuvOrg() );
339
340  // compute image characteristics
341  if ( getUseAdaptiveQP() )
342  {
343    m_cPreanalyzer.xPreanalyze( dynamic_cast<TEncPic*>( pcPicCurr ) );
344  }
345}
346#endif
347Void TEncTop::deletePicBuffer()
348{
349  TComList<TComPic*>::iterator iterPic = m_cListPic.begin();
350  Int iSize = Int( m_cListPic.size() );
351 
352  for ( Int i = 0; i < iSize; i++ )
353  {
354    TComPic* pcPic = *(iterPic++);
355   
356    pcPic->destroy();
357    delete pcPic;
358    pcPic = NULL;
359  }
360}
361
362/**
363 - Application has picture buffer list with size of GOP + 1
364 - Picture buffer list acts like as ring buffer
365 - End of the list has the latest picture
366 .
367 \param   flush               cause encoder to encode a partial GOP
368 \param   pcPicYuvOrg         original YUV picture
369 \retval  rcListPicYuvRecOut  list of reconstruction YUV pictures
370 \retval  rcListBitstreamOut  list of output bitstreams
371 \retval  iNumEncoded         number of encoded pictures
372 */
373#if H_MV
374Void TEncTop::encode(Bool flush, TComPicYuv* pcPicYuvOrg, TComList<TComPicYuv*>& rcListPicYuvRecOut, std::list<AccessUnit>& accessUnitsOut, Int& iNumEncoded , Int gopId )
375{
376#else
377Void TEncTop::encode(Bool flush, TComPicYuv* pcPicYuvOrg, TComList<TComPicYuv*>& rcListPicYuvRecOut, std::list<AccessUnit>& accessUnitsOut, Int& iNumEncoded )
378{
379#endif
380#if H_3D
381  TComPic* picLastCoded = getPic( getGOPEncoder()->getPocLastCoded() );
382  if( picLastCoded )
383  {
384    picLastCoded->compressMotion(); 
385  }
386#endif
387#if H_MV
388  if( gopId == 0)
389  {
390    m_cGOPEncoder.initGOP(m_iPOCLast, m_iNumPicRcvd, m_cListPic, rcListPicYuvRecOut, accessUnitsOut); 
391#else
392  if (pcPicYuvOrg) {
393    // get original YUV
394    TComPic* pcPicCurr = NULL;
395    xGetNewPicBuffer( pcPicCurr );
396    pcPicYuvOrg->copyToPic( pcPicCurr->getPicYuvOrg() );
397
398    // compute image characteristics
399    if ( getUseAdaptiveQP() )
400    {
401      m_cPreanalyzer.xPreanalyze( dynamic_cast<TEncPic*>( pcPicCurr ) );
402    }
403  }
404 
405  if (!m_iNumPicRcvd || (!flush && m_iPOCLast != 0 && m_iNumPicRcvd != m_iGOPSize && m_iGOPSize))
406  {
407    iNumEncoded = 0;
408    return;
409  }
410#endif
411 
412#if RATE_CONTROL_LAMBDA_DOMAIN
413  if ( m_RCEnableRateControl )
414  {
415    m_cRateCtrl.initRCGOP( m_iNumPicRcvd );
416  }
417#endif
418
419#if H_MV
420  }
421  m_cGOPEncoder.compressPicInGOP(m_iPOCLast, m_iNumPicRcvd, m_cListPic, rcListPicYuvRecOut, accessUnitsOut, gopId );
422
423  if( gopId + 1 == m_cGOPEncoder.getGOPSize() )
424  {
425#else
426  // compress GOP
427  m_cGOPEncoder.compressGOP(m_iPOCLast, m_iNumPicRcvd, m_cListPic, rcListPicYuvRecOut, accessUnitsOut);
428#endif
429
430#if RATE_CONTROL_LAMBDA_DOMAIN
431  if ( m_RCEnableRateControl )
432  {
433    m_cRateCtrl.destroyRCGOP();
434  }
435#endif
436 
437  iNumEncoded         = m_iNumPicRcvd;
438  m_iNumPicRcvd       = 0;
439  m_uiNumAllPicCoded += iNumEncoded;
440#if H_MV
441}
442#endif
443}
444
445// ====================================================================================================================
446// Protected member functions
447// ====================================================================================================================
448
449/**
450 - Application has picture buffer list with size of GOP + 1
451 - Picture buffer list acts like as ring buffer
452 - End of the list has the latest picture
453 .
454 \retval rpcPic obtained picture buffer
455 */
456Void TEncTop::xGetNewPicBuffer ( TComPic*& rpcPic )
457{
458  TComSlice::sortPicList(m_cListPic);
459 
460  if (m_cListPic.size() >= (UInt)(m_iGOPSize + getMaxDecPicBuffering(MAX_TLAYER-1) + 2) )
461  {
462    TComList<TComPic*>::iterator iterPic  = m_cListPic.begin();
463    Int iSize = Int( m_cListPic.size() );
464    for ( Int i = 0; i < iSize; i++ )
465    {
466      rpcPic = *(iterPic++);
467      if(rpcPic->getSlice(0)->isReferenced() == false)
468      {
469        break;
470      }
471    }
472  }
473  else
474  {
475    if ( getUseAdaptiveQP() )
476    {
477      TEncPic* pcEPic = new TEncPic;
478      pcEPic->create( m_iSourceWidth, m_iSourceHeight, g_uiMaxCUWidth, g_uiMaxCUHeight, g_uiMaxCUDepth, m_cPPS.getMaxCuDQPDepth()+1 ,
479                      m_conformanceWindow, m_defaultDisplayWindow, m_numReorderPics);
480      rpcPic = pcEPic;
481    }
482    else
483    {
484      rpcPic = new TComPic;
485
486      rpcPic->create( m_iSourceWidth, m_iSourceHeight, g_uiMaxCUWidth, g_uiMaxCUHeight, g_uiMaxCUDepth, 
487                      m_conformanceWindow, m_defaultDisplayWindow, m_numReorderPics);
488    }
489    if (getUseSAO())
490    {
491      rpcPic->getPicSym()->allocSaoParam(&m_cEncSAO);
492    }
493    m_cListPic.pushBack( rpcPic );
494  }
495  rpcPic->setReconMark (false);
496 
497  m_iPOCLast++;
498  m_iNumPicRcvd++;
499 
500  rpcPic->getSlice(0)->setPOC( m_iPOCLast );
501  // mark it should be extended
502  rpcPic->getPicYuvRec()->setBorderExtension(false);
503}
504
505Void TEncTop::xInitSPS()
506{
507#if H_MV
508  m_cSPS.setSPSId( getLayerIdInVps() );
509#endif
510  ProfileTierLevel& profileTierLevel = *m_cSPS.getPTL()->getGeneralPTL();
511  profileTierLevel.setLevelIdc(m_level);
512  profileTierLevel.setTierFlag(m_levelTier);
513  profileTierLevel.setProfileIdc(m_profile);
514  profileTierLevel.setProfileCompatibilityFlag(m_profile, 1);
515#if L0046_CONSTRAINT_FLAGS
516  profileTierLevel.setProgressiveSourceFlag(m_progressiveSourceFlag);
517  profileTierLevel.setInterlacedSourceFlag(m_interlacedSourceFlag);
518  profileTierLevel.setNonPackedConstraintFlag(m_nonPackedConstraintFlag);
519  profileTierLevel.setFrameOnlyConstraintFlag(m_frameOnlyConstraintFlag);
520#endif
521 
522  if (m_profile == Profile::MAIN10 && g_bitDepthY == 8 && g_bitDepthC == 8)
523  {
524    /* The above constraint is equal to Profile::MAIN */
525    profileTierLevel.setProfileCompatibilityFlag(Profile::MAIN, 1);
526  }
527  if (m_profile == Profile::MAIN)
528  {
529    /* A Profile::MAIN10 decoder can always decode Profile::MAIN */
530    profileTierLevel.setProfileCompatibilityFlag(Profile::MAIN10, 1);
531  }
532  /* XXX: should Main be marked as compatible with still picture? */
533  /* XXX: may be a good idea to refactor the above into a function
534   * that chooses the actual compatibility based upon options */
535
536  m_cSPS.setPicWidthInLumaSamples         ( m_iSourceWidth      );
537  m_cSPS.setPicHeightInLumaSamples        ( m_iSourceHeight     );
538  m_cSPS.setConformanceWindow             ( m_conformanceWindow );
539  m_cSPS.setMaxCUWidth    ( g_uiMaxCUWidth      );
540  m_cSPS.setMaxCUHeight   ( g_uiMaxCUHeight     );
541  m_cSPS.setMaxCUDepth    ( g_uiMaxCUDepth      );
542
543  Int minCUSize = m_cSPS.getMaxCUWidth() >> ( m_cSPS.getMaxCUDepth()-g_uiAddCUDepth );
544  Int log2MinCUSize = 0;
545  while(minCUSize > 1)
546  {
547    minCUSize >>= 1;
548    log2MinCUSize++;
549  }
550
551  m_cSPS.setLog2MinCodingBlockSize(log2MinCUSize);
552  m_cSPS.setLog2DiffMaxMinCodingBlockSize(m_cSPS.getMaxCUDepth()-g_uiAddCUDepth);
553 
554  m_cSPS.setPCMLog2MinSize (m_uiPCMLog2MinSize);
555  m_cSPS.setUsePCM        ( m_usePCM           );
556  m_cSPS.setPCMLog2MaxSize( m_pcmLog2MaxSize  );
557
558  m_cSPS.setQuadtreeTULog2MaxSize( m_uiQuadtreeTULog2MaxSize );
559  m_cSPS.setQuadtreeTULog2MinSize( m_uiQuadtreeTULog2MinSize );
560  m_cSPS.setQuadtreeTUMaxDepthInter( m_uiQuadtreeTUMaxDepthInter    );
561  m_cSPS.setQuadtreeTUMaxDepthIntra( m_uiQuadtreeTUMaxDepthIntra    );
562 
563  m_cSPS.setTMVPFlagsPresent(false);
564  m_cSPS.setUseLossless   ( m_useLossless  );
565
566  m_cSPS.setMaxTrSize   ( 1 << m_uiQuadtreeTULog2MaxSize );
567#if !L0034_COMBINED_LIST_CLEANUP
568  m_cSPS.setUseLComb    ( m_bUseLComb           );
569#endif
570 
571  Int i;
572 
573  for (i = 0; i < g_uiMaxCUDepth-g_uiAddCUDepth; i++ )
574  {
575    m_cSPS.setAMPAcc( i, m_useAMP );
576    //m_cSPS.setAMPAcc( i, 1 );
577  }
578
579  m_cSPS.setUseAMP ( m_useAMP );
580
581  for (i = g_uiMaxCUDepth-g_uiAddCUDepth; i < g_uiMaxCUDepth; i++ )
582  {
583    m_cSPS.setAMPAcc(i, 0);
584  }
585
586  m_cSPS.setBitDepthY( g_bitDepthY );
587  m_cSPS.setBitDepthC( g_bitDepthC );
588
589  m_cSPS.setQpBDOffsetY ( 6*(g_bitDepthY - 8) );
590  m_cSPS.setQpBDOffsetC ( 6*(g_bitDepthC - 8) );
591
592  m_cSPS.setUseSAO( m_bUseSAO );
593
594  m_cSPS.setMaxTLayers( m_maxTempLayer );
595  m_cSPS.setTemporalIdNestingFlag( ( m_maxTempLayer == 1 ) ? true : false );
596  for ( i = 0; i < m_cSPS.getMaxTLayers(); i++ )
597  {
598    m_cSPS.setMaxDecPicBuffering(m_maxDecPicBuffering[i], i);
599    m_cSPS.setNumReorderPics(m_numReorderPics[i], i);
600  }
601  m_cSPS.setPCMBitDepthLuma (g_uiPCMBitDepthLuma);
602  m_cSPS.setPCMBitDepthChroma (g_uiPCMBitDepthChroma);
603  m_cSPS.setPCMFilterDisableFlag  ( m_bPCMFilterDisableFlag );
604
605  m_cSPS.setScalingListFlag ( (m_useScalingListId == 0) ? 0 : 1 );
606
607  m_cSPS.setUseStrongIntraSmoothing( m_useStrongIntraSmoothing );
608
609  m_cSPS.setVuiParametersPresentFlag(getVuiParametersPresentFlag());
610  if (m_cSPS.getVuiParametersPresentFlag())
611  {
612    TComVUI* pcVUI = m_cSPS.getVuiParameters();
613    pcVUI->setAspectRatioInfoPresentFlag(getAspectRatioIdc() != -1);
614    pcVUI->setAspectRatioIdc(getAspectRatioIdc());
615    pcVUI->setSarWidth(getSarWidth());
616    pcVUI->setSarHeight(getSarHeight());
617    pcVUI->setOverscanInfoPresentFlag(getOverscanInfoPresentFlag());
618    pcVUI->setOverscanAppropriateFlag(getOverscanAppropriateFlag());
619    pcVUI->setVideoSignalTypePresentFlag(getVideoSignalTypePresentFlag());
620    pcVUI->setVideoFormat(getVideoFormat());
621    pcVUI->setVideoFullRangeFlag(getVideoFullRangeFlag());
622    pcVUI->setColourDescriptionPresentFlag(getColourDescriptionPresentFlag());
623    pcVUI->setColourPrimaries(getColourPrimaries());
624    pcVUI->setTransferCharacteristics(getTransferCharacteristics());
625    pcVUI->setMatrixCoefficients(getMatrixCoefficients());
626    pcVUI->setChromaLocInfoPresentFlag(getChromaLocInfoPresentFlag());
627    pcVUI->setChromaSampleLocTypeTopField(getChromaSampleLocTypeTopField());
628    pcVUI->setChromaSampleLocTypeBottomField(getChromaSampleLocTypeBottomField());
629    pcVUI->setNeutralChromaIndicationFlag(getNeutralChromaIndicationFlag());
630    pcVUI->setDefaultDisplayWindow(getDefaultDisplayWindow());
631    pcVUI->setFrameFieldInfoPresentFlag(getFrameFieldInfoPresentFlag());
632    pcVUI->setFieldSeqFlag(false);
633    pcVUI->setHrdParametersPresentFlag(false);
634#if L0043_TIMING_INFO
635    pcVUI->getTimingInfo()->setPocProportionalToTimingFlag(getPocProportionalToTimingFlag());
636    pcVUI->getTimingInfo()->setNumTicksPocDiffOneMinus1   (getNumTicksPocDiffOneMinus1()   );
637#else
638    pcVUI->setPocProportionalToTimingFlag(getPocProportionalToTimingFlag());
639    pcVUI->setNumTicksPocDiffOneMinus1   (getNumTicksPocDiffOneMinus1()   );
640#endif
641    pcVUI->setBitstreamRestrictionFlag(getBitstreamRestrictionFlag());
642    pcVUI->setTilesFixedStructureFlag(getTilesFixedStructureFlag());
643    pcVUI->setMotionVectorsOverPicBoundariesFlag(getMotionVectorsOverPicBoundariesFlag());
644    pcVUI->setMinSpatialSegmentationIdc(getMinSpatialSegmentationIdc());
645    pcVUI->setMaxBytesPerPicDenom(getMaxBytesPerPicDenom());
646    pcVUI->setMaxBitsPerMinCuDenom(getMaxBitsPerMinCuDenom());
647    pcVUI->setLog2MaxMvLengthHorizontal(getLog2MaxMvLengthHorizontal());
648    pcVUI->setLog2MaxMvLengthVertical(getLog2MaxMvLengthVertical());
649  }
650}
651
652Void TEncTop::xInitPPS()
653{
654#if H_MV
655  if( m_cVPS.getNumDirectRefLayers( getLayerIdInVps() ) > 0 )
656  {
657    m_cPPS.setListsModificationPresentFlag( true );
658  }
659  m_cPPS.setPPSId( getLayerIdInVps() );
660  m_cPPS.setSPSId( getLayerIdInVps() );
661#endif
662  m_cPPS.setConstrainedIntraPred( m_bUseConstrainedIntraPred );
663  Bool bUseDQP = (getMaxCuDQPDepth() > 0)? true : false;
664
665  Int lowestQP = - m_cSPS.getQpBDOffsetY();
666
667  if(getUseLossless())
668  {
669    if ((getMaxCuDQPDepth() == 0) && (getMaxDeltaQP() == 0 ) && (getQP() == lowestQP) )
670    {
671      bUseDQP = false;
672    }
673    else
674    {
675      bUseDQP = true;
676    }
677  }
678  else
679  {
680    if(bUseDQP == false)
681    {
682      if((getMaxDeltaQP() != 0 )|| getUseAdaptiveQP())
683      {
684        bUseDQP = true;
685      }
686    }
687  }
688
689  if(bUseDQP)
690  {
691    m_cPPS.setUseDQP(true);
692    m_cPPS.setMaxCuDQPDepth( m_iMaxCuDQPDepth );
693    m_cPPS.setMinCuDQPSize( m_cPPS.getSPS()->getMaxCUWidth() >> ( m_cPPS.getMaxCuDQPDepth()) );
694  }
695  else
696  {
697    m_cPPS.setUseDQP(false);
698    m_cPPS.setMaxCuDQPDepth( 0 );
699    m_cPPS.setMinCuDQPSize( m_cPPS.getSPS()->getMaxCUWidth() >> ( m_cPPS.getMaxCuDQPDepth()) );
700  }
701
702#if RATE_CONTROL_LAMBDA_DOMAIN
703  if ( m_RCEnableRateControl )
704  {
705    m_cPPS.setUseDQP(true);
706    m_cPPS.setMaxCuDQPDepth( 0 );
707    m_cPPS.setMinCuDQPSize( m_cPPS.getSPS()->getMaxCUWidth() >> ( m_cPPS.getMaxCuDQPDepth()) );
708  } 
709#endif
710
711  m_cPPS.setChromaCbQpOffset( m_chromaCbQpOffset );
712  m_cPPS.setChromaCrQpOffset( m_chromaCrQpOffset );
713
714  m_cPPS.setNumSubstreams(m_iWaveFrontSubstreams);
715  m_cPPS.setEntropyCodingSyncEnabledFlag( m_iWaveFrontSynchro > 0 );
716  m_cPPS.setTilesEnabledFlag( (m_iNumColumnsMinus1 > 0 || m_iNumRowsMinus1 > 0) );
717  m_cPPS.setUseWP( m_useWeightedPred );
718  m_cPPS.setWPBiPred( m_useWeightedBiPred );
719  m_cPPS.setOutputFlagPresentFlag( false );
720  m_cPPS.setSignHideFlag(getSignHideFlag());
721#if L0386_DB_METRIC
722  if ( getDeblockingFilterMetric() )
723  {
724    m_cPPS.setDeblockingFilterControlPresentFlag (true);
725    m_cPPS.setDeblockingFilterOverrideEnabledFlag(true);
726    m_cPPS.setPicDisableDeblockingFilterFlag(false);
727    m_cPPS.setDeblockingFilterBetaOffsetDiv2(0);
728    m_cPPS.setDeblockingFilterTcOffsetDiv2(0);
729  } 
730  else
731  {
732  m_cPPS.setDeblockingFilterControlPresentFlag (m_DeblockingFilterControlPresent );
733  }
734#else
735  m_cPPS.setDeblockingFilterControlPresentFlag (m_DeblockingFilterControlPresent );
736#endif
737  m_cPPS.setLog2ParallelMergeLevelMinus2   (m_log2ParallelMergeLevelMinus2 );
738  m_cPPS.setCabacInitPresentFlag(CABAC_INIT_PRESENT_FLAG);
739  m_cPPS.setLoopFilterAcrossSlicesEnabledFlag( m_bLFCrossSliceBoundaryFlag );
740  Int histogram[MAX_NUM_REF + 1];
741  for( Int i = 0; i <= MAX_NUM_REF; i++ )
742  {
743    histogram[i]=0;
744  }
745  for( Int i = 0; i < getGOPSize(); i++ )
746  {
747    assert(getGOPEntry(i).m_numRefPicsActive >= 0 && getGOPEntry(i).m_numRefPicsActive <= MAX_NUM_REF);
748    histogram[getGOPEntry(i).m_numRefPicsActive]++;
749  }
750  Int maxHist=-1;
751  Int bestPos=0;
752  for( Int i = 0; i <= MAX_NUM_REF; i++ )
753  {
754    if(histogram[i]>maxHist)
755    {
756      maxHist=histogram[i];
757      bestPos=i;
758    }
759  }
760#if L0323_LIMIT_DEFAULT_LIST_SIZE
761  assert(bestPos <= 15);
762#endif
763  m_cPPS.setNumRefIdxL0DefaultActive(bestPos);
764  m_cPPS.setNumRefIdxL1DefaultActive(bestPos);
765  m_cPPS.setTransquantBypassEnableFlag(getTransquantBypassEnableFlag());
766  m_cPPS.setUseTransformSkip( m_useTransformSkip );
767  if (m_sliceSegmentMode)
768  {
769    m_cPPS.setDependentSliceSegmentsEnabledFlag( true );
770  }
771  if( m_cPPS.getDependentSliceSegmentsEnabledFlag() )
772  {
773    Int NumCtx = m_cPPS.getEntropyCodingSyncEnabledFlag()?2:1;
774    m_cSliceEncoder.initCtxMem( NumCtx );
775    for ( UInt st = 0; st < NumCtx; st++ )
776    {
777      TEncSbac* ctx = NULL;
778      ctx = new TEncSbac;
779      ctx->init( &m_cBinCoderCABAC );
780      m_cSliceEncoder.setCtxMem( ctx, st );
781    }
782  }
783}
784
785//Function for initializing m_RPSList, a list of TComReferencePictureSet, based on the GOPEntry objects read from the config file.
786Void TEncTop::xInitRPS()
787{
788  TComReferencePictureSet*      rps;
789 
790  m_cSPS.createRPSList(getGOPSize()+m_extraRPSs);
791  TComRPSList* rpsList = m_cSPS.getRPSList();
792
793  for( Int i = 0; i < getGOPSize()+m_extraRPSs; i++) 
794  {
795    GOPEntry ge = getGOPEntry(i);
796    rps = rpsList->getReferencePictureSet(i);
797    rps->setNumberOfPictures(ge.m_numRefPics);
798    rps->setNumRefIdc(ge.m_numRefIdc);
799    Int numNeg = 0;
800    Int numPos = 0;
801    for( Int j = 0; j < ge.m_numRefPics; j++)
802    {
803      rps->setDeltaPOC(j,ge.m_referencePics[j]);
804      rps->setUsed(j,ge.m_usedByCurrPic[j]);
805      if(ge.m_referencePics[j]>0)
806      {
807        numPos++;
808      }
809      else
810      {
811        numNeg++;
812      }
813    }
814    rps->setNumberOfNegativePictures(numNeg);
815    rps->setNumberOfPositivePictures(numPos);
816
817    // handle inter RPS intialization from the config file.
818#if AUTO_INTER_RPS
819    rps->setInterRPSPrediction(ge.m_interRPSPrediction > 0);  // not very clean, converting anything > 0 to true.
820    rps->setDeltaRIdxMinus1(0);                               // index to the Reference RPS is always the previous one.
821    TComReferencePictureSet*     RPSRef = rpsList->getReferencePictureSet(i-1);  // get the reference RPS
822
823    if (ge.m_interRPSPrediction == 2)  // Automatic generation of the inter RPS idc based on the RIdx provided.
824    {
825      Int deltaRPS = getGOPEntry(i-1).m_POC - ge.m_POC;  // the ref POC - current POC
826      Int numRefDeltaPOC = RPSRef->getNumberOfPictures();
827
828      rps->setDeltaRPS(deltaRPS);           // set delta RPS
829      rps->setNumRefIdc(numRefDeltaPOC+1);  // set the numRefIdc to the number of pictures in the reference RPS + 1.
830      Int count=0;
831      for (Int j = 0; j <= numRefDeltaPOC; j++ ) // cycle through pics in reference RPS.
832      {
833        Int RefDeltaPOC = (j<numRefDeltaPOC)? RPSRef->getDeltaPOC(j): 0;  // if it is the last decoded picture, set RefDeltaPOC = 0
834        rps->setRefIdc(j, 0);
835        for (Int k = 0; k < rps->getNumberOfPictures(); k++ )  // cycle through pics in current RPS.
836        {
837          if (rps->getDeltaPOC(k) == ( RefDeltaPOC + deltaRPS))  // if the current RPS has a same picture as the reference RPS.
838          {
839              rps->setRefIdc(j, (rps->getUsed(k)?1:2));
840              count++;
841              break;
842          }
843        }
844      }
845      if (count != rps->getNumberOfPictures())
846      {
847        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");
848        rps->setInterRPSPrediction(0);
849      }
850    }
851    else if (ge.m_interRPSPrediction == 1)  // inter RPS idc based on the RefIdc values provided in config file.
852    {
853      rps->setDeltaRPS(ge.m_deltaRPS);
854      rps->setNumRefIdc(ge.m_numRefIdc);
855      for (Int j = 0; j < ge.m_numRefIdc; j++ )
856      {
857        rps->setRefIdc(j, ge.m_refIdc[j]);
858      }
859#if WRITE_BACK
860      // the folowing code overwrite the deltaPOC and Used by current values read from the config file with the ones
861      // computed from the RefIdc.  A warning is printed if they are not identical.
862      numNeg = 0;
863      numPos = 0;
864      TComReferencePictureSet      RPSTemp;  // temporary variable
865
866      for (Int j = 0; j < ge.m_numRefIdc; j++ )
867      {
868        if (ge.m_refIdc[j])
869        {
870          Int deltaPOC = ge.m_deltaRPS + ((j < RPSRef->getNumberOfPictures())? RPSRef->getDeltaPOC(j) : 0);
871          RPSTemp.setDeltaPOC((numNeg+numPos),deltaPOC);
872          RPSTemp.setUsed((numNeg+numPos),ge.m_refIdc[j]==1?1:0);
873          if (deltaPOC<0)
874          {
875            numNeg++;
876          }
877          else
878          {
879            numPos++;
880          }
881        }
882      }
883      if (numNeg != rps->getNumberOfNegativePictures())
884      {
885        printf("Warning: number of negative pictures in RPS is different between intra and inter RPS specified in the config file.\n");
886        rps->setNumberOfNegativePictures(numNeg);
887        rps->setNumberOfPositivePictures(numNeg+numPos);
888      }
889      if (numPos != rps->getNumberOfPositivePictures())
890      {
891        printf("Warning: number of positive pictures in RPS is different between intra and inter RPS specified in the config file.\n");
892        rps->setNumberOfPositivePictures(numPos);
893        rps->setNumberOfPositivePictures(numNeg+numPos);
894      }
895      RPSTemp.setNumberOfPictures(numNeg+numPos);
896      RPSTemp.setNumberOfNegativePictures(numNeg);
897      RPSTemp.sortDeltaPOC();     // sort the created delta POC before comparing
898      // check if Delta POC and Used are the same
899      // print warning if they are not.
900      for (Int j = 0; j < ge.m_numRefIdc; j++ )
901      {
902        if (RPSTemp.getDeltaPOC(j) != rps->getDeltaPOC(j))
903        {
904          printf("Warning: delta POC is different between intra RPS and inter RPS specified in the config file.\n");
905          rps->setDeltaPOC(j,RPSTemp.getDeltaPOC(j));
906        }
907        if (RPSTemp.getUsed(j) != rps->getUsed(j))
908        {
909          printf("Warning: Used by Current in RPS is different between intra and inter RPS specified in the config file.\n");
910          rps->setUsed(j,RPSTemp.getUsed(j));
911        }
912      }
913#endif
914    }
915#else
916    rps->setInterRPSPrediction(ge.m_interRPSPrediction);
917    if (ge.m_interRPSPrediction)
918    {
919      rps->setDeltaRIdxMinus1(0);
920      rps->setDeltaRPS(ge.m_deltaRPS);
921      rps->setNumRefIdc(ge.m_numRefIdc);
922      for (Int j = 0; j < ge.m_numRefIdc; j++ )
923      {
924        rps->setRefIdc(j, ge.m_refIdc[j]);
925      }
926#if WRITE_BACK
927      // the folowing code overwrite the deltaPOC and Used by current values read from the config file with the ones
928      // computed from the RefIdc.  This is not necessary if both are identical. Currently there is no check to see if they are identical.
929      numNeg = 0;
930      numPos = 0;
931      TComReferencePictureSet*     RPSRef = m_RPSList.getReferencePictureSet(i-1);
932
933      for (Int j = 0; j < ge.m_numRefIdc; j++ )
934      {
935        if (ge.m_refIdc[j])
936        {
937          Int deltaPOC = ge.m_deltaRPS + ((j < RPSRef->getNumberOfPictures())? RPSRef->getDeltaPOC(j) : 0);
938          rps->setDeltaPOC((numNeg+numPos),deltaPOC);
939          rps->setUsed((numNeg+numPos),ge.m_refIdc[j]==1?1:0);
940          if (deltaPOC<0)
941          {
942            numNeg++;
943          }
944          else
945          {
946            numPos++;
947          }
948        }
949      }
950      rps->setNumberOfNegativePictures(numNeg);
951      rps->setNumberOfPositivePictures(numPos);
952      rps->sortDeltaPOC();
953#endif
954    }
955#endif //INTER_RPS_AUTO
956  }
957 
958}
959
960   // This is a function that
961   // determines what Reference Picture Set to use
962   // for a specific slice (with POC = POCCurr)
963Void TEncTop::selectReferencePictureSet(TComSlice* slice, Int POCCurr, Int GOPid )
964{
965#if H_MV
966  if( slice->getRapPicFlag() == true && getLayerId() > 0 && POCCurr == 0 )
967  {
968    TComReferencePictureSet* rps = slice->getLocalRPS();
969    rps->setNumberOfNegativePictures(0);
970    rps->setNumberOfPositivePictures(0);
971    rps->setNumberOfLongtermPictures(0);
972    rps->setNumberOfPictures(0);
973    slice->setRPS(rps);
974  }
975  else
976  {
977#endif
978  slice->setRPSidx(GOPid);
979
980  for(Int extraNum=m_iGOPSize; extraNum<m_extraRPSs+m_iGOPSize; extraNum++)
981  {   
982    if(m_uiIntraPeriod > 0 && getDecodingRefreshType() > 0)
983    {
984      Int POCIndex = POCCurr%m_uiIntraPeriod;
985      if(POCIndex == 0)
986      {
987        POCIndex = m_uiIntraPeriod;
988      }
989      if(POCIndex == m_GOPList[extraNum].m_POC)
990      {
991        slice->setRPSidx(extraNum);
992      }
993    }
994    else
995    {
996      if(POCCurr==m_GOPList[extraNum].m_POC)
997      {
998        slice->setRPSidx(extraNum);
999      }
1000    }
1001  }
1002
1003  slice->setRPS(getSPS()->getRPSList()->getReferencePictureSet(slice->getRPSidx()));
1004  slice->getRPS()->setNumberOfPictures(slice->getRPS()->getNumberOfNegativePictures()+slice->getRPS()->getNumberOfPositivePictures());
1005#if H_MV
1006  }
1007#endif
1008}
1009
1010#if L0208_SOP_DESCRIPTION_SEI
1011Int TEncTop::getReferencePictureSetIdxForSOP(TComSlice* slice, Int POCCurr, Int GOPid )
1012{
1013  int rpsIdx = GOPid;
1014
1015  for(Int extraNum=m_iGOPSize; extraNum<m_extraRPSs+m_iGOPSize; extraNum++)
1016  {   
1017    if(m_uiIntraPeriod > 0 && getDecodingRefreshType() > 0)
1018    {
1019      Int POCIndex = POCCurr%m_uiIntraPeriod;
1020      if(POCIndex == 0)
1021      {
1022        POCIndex = m_uiIntraPeriod;
1023      }
1024      if(POCIndex == m_GOPList[extraNum].m_POC)
1025      {
1026        rpsIdx = extraNum;
1027      }
1028    }
1029    else
1030    {
1031      if(POCCurr==m_GOPList[extraNum].m_POC)
1032      {
1033        rpsIdx = extraNum;
1034      }
1035    }
1036  }
1037
1038  return rpsIdx;
1039}
1040#endif
1041
1042Void  TEncTop::xInitPPSforTiles()
1043{
1044  m_cPPS.setUniformSpacingFlag( m_iUniformSpacingIdr );
1045  m_cPPS.setNumColumnsMinus1( m_iNumColumnsMinus1 );
1046  m_cPPS.setNumRowsMinus1( m_iNumRowsMinus1 );
1047  if( m_iUniformSpacingIdr == 0 )
1048  {
1049    m_cPPS.setColumnWidth( m_puiColumnWidth );
1050    m_cPPS.setRowHeight( m_puiRowHeight );
1051  }
1052  m_cPPS.setLoopFilterAcrossTilesEnabledFlag( m_loopFilterAcrossTilesEnabledFlag );
1053
1054  // # substreams is "per tile" when tiles are independent.
1055  if (m_iWaveFrontSynchro
1056    )
1057  {
1058    m_cPPS.setNumSubstreams(m_iWaveFrontSubstreams * (m_iNumColumnsMinus1+1));
1059  }
1060}
1061
1062Void  TEncCfg::xCheckGSParameters()
1063{
1064  Int   iWidthInCU = ( m_iSourceWidth%g_uiMaxCUWidth ) ? m_iSourceWidth/g_uiMaxCUWidth + 1 : m_iSourceWidth/g_uiMaxCUWidth;
1065  Int   iHeightInCU = ( m_iSourceHeight%g_uiMaxCUHeight ) ? m_iSourceHeight/g_uiMaxCUHeight + 1 : m_iSourceHeight/g_uiMaxCUHeight;
1066  UInt  uiCummulativeColumnWidth = 0;
1067  UInt  uiCummulativeRowHeight = 0;
1068
1069  //check the column relative parameters
1070  if( m_iNumColumnsMinus1 >= (1<<(LOG2_MAX_NUM_COLUMNS_MINUS1+1)) )
1071  {
1072    printf( "The number of columns is larger than the maximum allowed number of columns.\n" );
1073    exit( EXIT_FAILURE );
1074  }
1075
1076  if( m_iNumColumnsMinus1 >= iWidthInCU )
1077  {
1078    printf( "The current picture can not have so many columns.\n" );
1079    exit( EXIT_FAILURE );
1080  }
1081
1082  if( m_iNumColumnsMinus1 && m_iUniformSpacingIdr==0 )
1083  {
1084    for(Int i=0; i<m_iNumColumnsMinus1; i++)
1085    {
1086      uiCummulativeColumnWidth += m_puiColumnWidth[i];
1087    }
1088
1089    if( uiCummulativeColumnWidth >= iWidthInCU )
1090    {
1091      printf( "The width of the column is too large.\n" );
1092      exit( EXIT_FAILURE );
1093    }
1094  }
1095
1096  //check the row relative parameters
1097  if( m_iNumRowsMinus1 >= (1<<(LOG2_MAX_NUM_ROWS_MINUS1+1)) )
1098  {
1099    printf( "The number of rows is larger than the maximum allowed number of rows.\n" );
1100    exit( EXIT_FAILURE );
1101  }
1102
1103  if( m_iNumRowsMinus1 >= iHeightInCU )
1104  {
1105    printf( "The current picture can not have so many rows.\n" );
1106    exit( EXIT_FAILURE );
1107  }
1108
1109  if( m_iNumRowsMinus1 && m_iUniformSpacingIdr==0 )
1110  {
1111    for(Int i=0; i<m_iNumRowsMinus1; i++)
1112      uiCummulativeRowHeight += m_puiRowHeight[i];
1113
1114    if( uiCummulativeRowHeight >= iHeightInCU )
1115    {
1116      printf( "The height of the row is too large.\n" );
1117      exit( EXIT_FAILURE );
1118    }
1119  }
1120}
1121
1122#if H_MV
1123Void TEncTop::printSummary( Int numAllPicCoded )
1124{
1125  assert (numAllPicCoded == m_cAnalyzeAll.getNumPic());
1126
1127  //--CFG_KDY
1128  m_cAnalyzeAll.setFrmRate( getFrameRate() );
1129  m_cAnalyzeI.setFrmRate( getFrameRate() );
1130  m_cAnalyzeP.setFrmRate( getFrameRate() );
1131  m_cAnalyzeB.setFrmRate( getFrameRate() );
1132
1133  //-- all
1134  printf( "\n\nSUMMARY ------------------------------------------- LayerId %2d\n", m_layerId );
1135
1136  m_cAnalyzeAll.printOut('a');
1137
1138  printf( "\n\nI Slices--------------------------------------------------------\n" );
1139  m_cAnalyzeI.printOut('i');
1140
1141  printf( "\n\nP Slices--------------------------------------------------------\n" );
1142  m_cAnalyzeP.printOut('p');
1143
1144  printf( "\n\nB Slices--------------------------------------------------------\n" );
1145  m_cAnalyzeB.printOut('b');
1146
1147#if _SUMMARY_OUT_
1148  m_cAnalyzeAll.printSummaryOut();
1149#endif
1150#if _SUMMARY_PIC_
1151  m_cAnalyzeI.printSummary('I');
1152  m_cAnalyzeP.printSummary('P');
1153  m_cAnalyzeB.printSummary('B');
1154#endif
1155}
1156
1157Int TEncTop::getFrameId(Int iGOPid) 
1158{
1159  if(m_iPOCLast == 0)
1160  {
1161    return(0 );
1162  }
1163  else
1164  {
1165    return m_iPOCLast -m_iNumPicRcvd+ getGOPEntry(iGOPid).m_POC ;
1166  }
1167}
1168
1169TComPic* TEncTop::getPic( Int poc )
1170{
1171  TComList<TComPic*>* listPic = getListPic();
1172  TComPic* pcPic = NULL;
1173  for(TComList<TComPic*>::iterator it=listPic->begin(); it!=listPic->end(); it++)
1174  {
1175    if( (*it)->getPOC() == poc )
1176    {
1177      pcPic = *it ;
1178      break ;
1179    }
1180  }
1181  return pcPic;
1182}
1183#endif
1184
1185//! \}
Note: See TracBrowser for help on using the repository browser.