source: SHVCSoftware/trunk/source/Lib/TLibEncoder/TEncTop.cpp @ 594

Last change on this file since 594 was 588, checked in by seregin, 11 years ago

merge with SHM-5.0-dev
  • Property svn:eol-style set to native
File size: 56.5 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
45//! \ingroup TLibEncoder
46//! \{
47#if SVC_EXTENSION 
48Int TEncTop::m_iSPSIdCnt = 0;
49Int TEncTop::m_iPPSIdCnt = 0;
50TComVPS TEncCfg::m_cVPS;
51#endif
52
53// ====================================================================================================================
54// Constructor / destructor / create / destroy
55// ====================================================================================================================
56
57TEncTop::TEncTop()
58{
59  m_iPOCLast          = -1;
60  m_iNumPicRcvd       =  0;
61  m_uiNumAllPicCoded  =  0;
62  m_pppcRDSbacCoder   =  NULL;
63  m_pppcBinCoderCABAC =  NULL;
64  m_cRDGoOnSbacCoder.init( &m_cRDGoOnBinCoderCABAC );
65#if ENC_DEC_TRACE
66  g_hTrace = fopen( "TraceEnc.txt", "wb" );
67  g_bJustDoIt = g_bEncDecTraceDisable;
68  g_nSymbolCounter = 0;
69#endif
70
71  m_iMaxRefPicNum     = 0;
72
73#if FAST_BIT_EST
74  ContextModel::buildNextStateTable();
75#endif
76
77  m_pcSbacCoders           = NULL;
78  m_pcBinCoderCABACs       = NULL;
79  m_ppppcRDSbacCoders      = NULL;
80  m_ppppcBinCodersCABAC    = NULL;
81  m_pcRDGoOnSbacCoders     = NULL;
82  m_pcRDGoOnBinCodersCABAC = NULL;
83  m_pcBitCounters          = NULL;
84  m_pcRdCosts              = NULL;
85#if SVC_EXTENSION
86  memset(m_cIlpPic, 0, sizeof(m_cIlpPic));
87#if REF_IDX_MFM
88  m_bMFMEnabledFlag = false;
89#endif
90  m_numScaledRefLayerOffsets = 0;
91#if POC_RESET_FLAG
92  m_pocAdjustmentValue     = 0;
93#endif
94#if NO_CLRAS_OUTPUT_FLAG
95  m_noClrasOutputFlag          = false;
96  m_layerInitializedFlag       = false;
97  m_firstPicInLayerDecodedFlag = false;
98  m_noOutputOfPriorPicsFlags   = false;
99#endif
100#endif //SVC_EXTENSION
101}
102
103TEncTop::~TEncTop()
104{
105#if ENC_DEC_TRACE
106  fclose( g_hTrace );
107#endif
108}
109
110Void TEncTop::create ()
111{
112#if !SVC_EXTENSION
113  // initialize global variables
114  initROM();
115#endif
116
117  // create processing unit classes
118#if SVC_EXTENSION
119  m_cGOPEncoder.        create( m_layerId );
120#else
121  m_cGOPEncoder.        create();
122#endif
123#if AUXILIARY_PICTURES
124  m_cSliceEncoder.      create( getSourceWidth(), getSourceHeight(), m_chromaFormatIDC, g_uiMaxCUWidth, g_uiMaxCUHeight, g_uiMaxCUDepth );
125#else
126  m_cSliceEncoder.      create( getSourceWidth(), getSourceHeight(), g_uiMaxCUWidth, g_uiMaxCUHeight, g_uiMaxCUDepth );
127#endif
128  m_cCuEncoder.         create( g_uiMaxCUDepth, g_uiMaxCUWidth, g_uiMaxCUHeight );
129  if (m_bUseSAO)
130  {
131#if HM_CLEANUP_SAO
132#if AUXILIARY_PICTURES
133    m_cEncSAO.create( getSourceWidth(), getSourceHeight(), m_chromaFormatIDC, g_uiMaxCUWidth, g_uiMaxCUHeight, g_uiMaxCUDepth );
134#else
135    m_cEncSAO.create( getSourceWidth(), getSourceHeight(), g_uiMaxCUWidth, g_uiMaxCUHeight, g_uiMaxCUDepth );
136#endif
137#if SAO_ENCODE_ALLOW_USE_PREDEBLOCK
138    m_cEncSAO.createEncData(getSaoLcuBoundary());
139#else
140    m_cEncSAO.createEncData();
141#endif
142#else
143    m_cEncSAO.setSaoLcuBoundary(getSaoLcuBoundary());
144    m_cEncSAO.setSaoLcuBasedOptimization(getSaoLcuBasedOptimization());
145    m_cEncSAO.setMaxNumOffsetsPerPic(getMaxNumOffsetsPerPic());
146    m_cEncSAO.create( getSourceWidth(), getSourceHeight(), g_uiMaxCUWidth, g_uiMaxCUHeight );
147    m_cEncSAO.createEncBuffer();
148#endif
149  }
150#if ADAPTIVE_QP_SELECTION
151  if (m_bUseAdaptQpSelect)
152  {
153    m_cTrQuant.initSliceQpDelta();
154  }
155#endif
156  m_cLoopFilter.        create( g_uiMaxCUDepth );
157 
158  if ( m_RCEnableRateControl )
159  {
160    m_cRateCtrl.init( m_framesToBeEncoded, m_RCTargetBitrate, m_iFrameRate, m_iGOPSize, m_iSourceWidth, m_iSourceHeight,
161                      g_uiMaxCUWidth, g_uiMaxCUHeight, m_RCKeepHierarchicalBit, m_RCUseLCUSeparateModel, m_GOPList );
162  }
163  // if SBAC-based RD optimization is used
164  if( m_bUseSBACRD )
165  {
166    m_pppcRDSbacCoder = new TEncSbac** [g_uiMaxCUDepth+1];
167#if FAST_BIT_EST
168    m_pppcBinCoderCABAC = new TEncBinCABACCounter** [g_uiMaxCUDepth+1];
169#else
170    m_pppcBinCoderCABAC = new TEncBinCABAC** [g_uiMaxCUDepth+1];
171#endif
172   
173    for ( Int iDepth = 0; iDepth < g_uiMaxCUDepth+1; iDepth++ )
174    {
175      m_pppcRDSbacCoder[iDepth] = new TEncSbac* [CI_NUM];
176#if FAST_BIT_EST
177      m_pppcBinCoderCABAC[iDepth] = new TEncBinCABACCounter* [CI_NUM];
178#else
179      m_pppcBinCoderCABAC[iDepth] = new TEncBinCABAC* [CI_NUM];
180#endif
181     
182      for (Int iCIIdx = 0; iCIIdx < CI_NUM; iCIIdx ++ )
183      {
184        m_pppcRDSbacCoder[iDepth][iCIIdx] = new TEncSbac;
185#if FAST_BIT_EST
186        m_pppcBinCoderCABAC [iDepth][iCIIdx] = new TEncBinCABACCounter;
187#else
188        m_pppcBinCoderCABAC [iDepth][iCIIdx] = new TEncBinCABAC;
189#endif
190        m_pppcRDSbacCoder   [iDepth][iCIIdx]->init( m_pppcBinCoderCABAC [iDepth][iCIIdx] );
191      }
192    }
193  }
194
195#if LAYER_CTB
196  memcpy(g_auiLayerZscanToRaster[m_layerId], g_auiZscanToRaster, sizeof( g_auiZscanToRaster ) );
197  memcpy(g_auiLayerRasterToZscan[m_layerId], g_auiRasterToZscan, sizeof( g_auiRasterToZscan ) );
198  memcpy(g_auiLayerRasterToPelX[m_layerId],  g_auiRasterToPelX,  sizeof( g_auiRasterToPelX ) );
199  memcpy(g_auiLayerRasterToPelY[m_layerId],  g_auiRasterToPelY,  sizeof( g_auiRasterToPelY ) );
200#endif
201}
202
203/**
204 - Allocate coders required for wavefront for the nominated number of substreams.
205 .
206 \param iNumSubstreams Determines how much information to allocate.
207 */
208Void TEncTop::createWPPCoders(Int iNumSubstreams)
209{
210  if (m_pcSbacCoders != NULL)
211  {
212    return; // already generated.
213  }
214
215  m_iNumSubstreams         = iNumSubstreams;
216  m_pcSbacCoders           = new TEncSbac       [iNumSubstreams];
217  m_pcBinCoderCABACs       = new TEncBinCABAC   [iNumSubstreams];
218  m_pcRDGoOnSbacCoders     = new TEncSbac       [iNumSubstreams];
219  m_pcRDGoOnBinCodersCABAC = new TEncBinCABAC   [iNumSubstreams];
220  m_pcBitCounters          = new TComBitCounter [iNumSubstreams];
221  m_pcRdCosts              = new TComRdCost     [iNumSubstreams];
222
223  for ( UInt ui = 0 ; ui < iNumSubstreams; ui++ )
224  {
225    m_pcRDGoOnSbacCoders[ui].init( &m_pcRDGoOnBinCodersCABAC[ui] );
226    m_pcSbacCoders[ui].init( &m_pcBinCoderCABACs[ui] );
227  }
228  if( m_bUseSBACRD )
229  {
230    m_ppppcRDSbacCoders      = new TEncSbac***    [iNumSubstreams];
231    m_ppppcBinCodersCABAC    = new TEncBinCABAC***[iNumSubstreams];
232    for ( UInt ui = 0 ; ui < iNumSubstreams ; ui++ )
233    {
234      m_ppppcRDSbacCoders[ui]  = new TEncSbac** [g_uiMaxCUDepth+1];
235      m_ppppcBinCodersCABAC[ui]= new TEncBinCABAC** [g_uiMaxCUDepth+1];
236     
237      for ( Int iDepth = 0; iDepth < g_uiMaxCUDepth+1; iDepth++ )
238      {
239        m_ppppcRDSbacCoders[ui][iDepth]  = new TEncSbac*     [CI_NUM];
240        m_ppppcBinCodersCABAC[ui][iDepth]= new TEncBinCABAC* [CI_NUM];
241
242        for (Int iCIIdx = 0; iCIIdx < CI_NUM; iCIIdx ++ )
243        {
244          m_ppppcRDSbacCoders  [ui][iDepth][iCIIdx] = new TEncSbac;
245          m_ppppcBinCodersCABAC[ui][iDepth][iCIIdx] = new TEncBinCABAC;
246          m_ppppcRDSbacCoders  [ui][iDepth][iCIIdx]->init( m_ppppcBinCodersCABAC[ui][iDepth][iCIIdx] );
247        }
248      }
249    }
250  }
251}
252
253Void TEncTop::destroy ()
254{
255  // destroy processing unit classes
256  m_cGOPEncoder.        destroy();
257  m_cSliceEncoder.      destroy();
258  m_cCuEncoder.         destroy();
259  if (m_cSPS.getUseSAO())
260  {
261#if HM_CLEANUP_SAO
262    m_cEncSAO.destroyEncData();
263    m_cEncSAO.destroy();
264#else
265    m_cEncSAO.destroy();
266    m_cEncSAO.destroyEncBuffer();
267#endif
268  }
269  m_cLoopFilter.        destroy();
270  m_cRateCtrl.          destroy();
271  // SBAC RD
272  if( m_bUseSBACRD )
273  {
274    Int iDepth;
275    for ( iDepth = 0; iDepth < g_uiMaxCUDepth+1; iDepth++ )
276    {
277      for (Int iCIIdx = 0; iCIIdx < CI_NUM; iCIIdx ++ )
278      {
279        delete m_pppcRDSbacCoder[iDepth][iCIIdx];
280        delete m_pppcBinCoderCABAC[iDepth][iCIIdx];
281      }
282    }
283   
284    for ( iDepth = 0; iDepth < g_uiMaxCUDepth+1; iDepth++ )
285    {
286      delete [] m_pppcRDSbacCoder[iDepth];
287      delete [] m_pppcBinCoderCABAC[iDepth];
288    }
289   
290    delete [] m_pppcRDSbacCoder;
291    delete [] m_pppcBinCoderCABAC;
292
293    for ( UInt ui = 0; ui < m_iNumSubstreams; ui++ )
294    {
295      for ( iDepth = 0; iDepth < g_uiMaxCUDepth+1; iDepth++ )
296      {
297        for (Int iCIIdx = 0; iCIIdx < CI_NUM; iCIIdx ++ )
298        {
299          delete m_ppppcRDSbacCoders  [ui][iDepth][iCIIdx];
300          delete m_ppppcBinCodersCABAC[ui][iDepth][iCIIdx];
301        }
302      }
303
304      for ( iDepth = 0; iDepth < g_uiMaxCUDepth+1; iDepth++ )
305      {
306        delete [] m_ppppcRDSbacCoders  [ui][iDepth];
307        delete [] m_ppppcBinCodersCABAC[ui][iDepth];
308      }
309      delete[] m_ppppcRDSbacCoders  [ui];
310      delete[] m_ppppcBinCodersCABAC[ui];
311    }
312    delete[] m_ppppcRDSbacCoders;
313    delete[] m_ppppcBinCodersCABAC;
314  }
315  delete[] m_pcSbacCoders;
316  delete[] m_pcBinCoderCABACs;
317  delete[] m_pcRDGoOnSbacCoders; 
318  delete[] m_pcRDGoOnBinCodersCABAC;
319  delete[] m_pcBitCounters;
320  delete[] m_pcRdCosts;
321 
322#if SVC_EXTENSION
323  for(Int i=0; i<MAX_NUM_REF; i++)
324  {
325    if(m_cIlpPic[i])
326    {
327      m_cIlpPic[i]->destroy();
328      delete m_cIlpPic[i];
329      m_cIlpPic[i] = NULL;
330    }
331  }
332#else
333  // destroy ROM
334  destroyROM();
335#endif
336  return;
337}
338
339Void TEncTop::init(Bool isFieldCoding)
340{
341  // initialize SPS
342  xInitSPS();
343 
344  /* set the VPS profile information */
345  *m_cVPS.getPTL() = *m_cSPS.getPTL();
346  m_cVPS.getTimingInfo()->setTimingInfoPresentFlag       ( false );
347  // initialize PPS
348  m_cPPS.setSPS(&m_cSPS);
349  xInitPPS();
350  xInitRPS(isFieldCoding);
351
352  xInitPPSforTiles();
353
354  // initialize processing unit classes
355  m_cGOPEncoder.  init( this );
356  m_cSliceEncoder.init( this );
357  m_cCuEncoder.   init( this );
358 
359  // initialize transform & quantization class
360  m_pcCavlcCoder = getCavlcCoder();
361 
362  m_cTrQuant.init( 1 << m_uiQuadtreeTULog2MaxSize,
363                  m_useRDOQ, 
364                  m_useRDOQTS,
365                  true 
366                  ,m_useTransformSkipFast
367#if ADAPTIVE_QP_SELECTION                 
368                  , m_bUseAdaptQpSelect
369#endif
370                  );
371 
372  // initialize encoder search class
373  m_cSearch.init( this, &m_cTrQuant, m_iSearchRange, m_bipredSearchRange, m_iFastSearch, 0, &m_cEntropyCoder, &m_cRdCost, getRDSbacCoder(), getRDGoOnSbacCoder() );
374
375  m_iMaxRefPicNum = 0;
376#if SVC_EXTENSION
377  m_iSPSIdCnt ++;
378  m_iPPSIdCnt ++;
379  xInitILRP();
380#endif
381}
382
383// ====================================================================================================================
384// Public member functions
385// ====================================================================================================================
386
387Void TEncTop::deletePicBuffer()
388{
389  TComList<TComPic*>::iterator iterPic = m_cListPic.begin();
390  Int iSize = Int( m_cListPic.size() );
391 
392  for ( Int i = 0; i < iSize; i++ )
393  {
394    TComPic* pcPic = *(iterPic++);
395   
396    pcPic->destroy();
397    delete pcPic;
398    pcPic = NULL;
399  }
400}
401
402/**
403 - Application has picture buffer list with size of GOP + 1
404 - Picture buffer list acts like as ring buffer
405 - End of the list has the latest picture
406 .
407 \param   flush               cause encoder to encode a partial GOP
408 \param   pcPicYuvOrg         original YUV picture
409 \retval  rcListPicYuvRecOut  list of reconstruction YUV pictures
410 \retval  rcListBitstreamOut  list of output bitstreams
411 \retval  iNumEncoded         number of encoded pictures
412 */
413#if SVC_EXTENSION
414Void TEncTop::encode( TComPicYuv* pcPicYuvOrg, TComList<TComPicYuv*>& rcListPicYuvRecOut, std::list<AccessUnit>& accessUnitsOut, Int iPicIdInGOP )
415{
416  // compress GOP
417#if !RC_SHVC_HARMONIZATION
418  if ( m_RCEnableRateControl )
419  {
420    m_cRateCtrl.initRCGOP( m_iNumPicRcvd );
421  }
422#endif
423
424  // compress GOP
425  m_cGOPEncoder.compressGOP(iPicIdInGOP, m_iPOCLast, m_iNumPicRcvd, m_cListPic, rcListPicYuvRecOut, accessUnitsOut, false, false);
426
427#if !RC_SHVC_HARMONIZATION
428  if ( m_RCEnableRateControl )
429  {
430    m_cRateCtrl.destroyRCGOP();
431  }
432#endif
433 
434  m_uiNumAllPicCoded ++;
435}
436
437Void TEncTop::encodePrep( TComPicYuv* pcPicYuvOrg )
438{
439  if (pcPicYuvOrg) 
440  {
441    // get original YUV
442    TComPic* pcPicCurr = NULL;
443    xGetNewPicBuffer( pcPicCurr );
444    pcPicYuvOrg->copyToPic( pcPicCurr->getPicYuvOrg() );
445
446    // compute image characteristics
447    if ( getUseAdaptiveQP() )
448    {
449      m_cPreanalyzer.xPreanalyze( dynamic_cast<TEncPic*>( pcPicCurr ) );
450    }
451  }
452}
453#else
454Void TEncTop::encode(Bool flush, TComPicYuv* pcPicYuvOrg, TComList<TComPicYuv*>& rcListPicYuvRecOut, std::list<AccessUnit>& accessUnitsOut, Int& iNumEncoded )
455{
456  if (pcPicYuvOrg) {
457    // get original YUV
458    TComPic* pcPicCurr = NULL;
459    xGetNewPicBuffer( pcPicCurr );
460    pcPicYuvOrg->copyToPic( pcPicCurr->getPicYuvOrg() );
461
462    // compute image characteristics
463    if ( getUseAdaptiveQP() )
464    {
465      m_cPreanalyzer.xPreanalyze( dynamic_cast<TEncPic*>( pcPicCurr ) );
466    }
467  }
468 
469  if (!m_iNumPicRcvd || (!flush && m_iPOCLast != 0 && m_iNumPicRcvd != m_iGOPSize && m_iGOPSize))
470  {
471    iNumEncoded = 0;
472    return;
473  }
474 
475  if ( m_RCEnableRateControl )
476  {
477    m_cRateCtrl.initRCGOP( m_iNumPicRcvd );
478  }
479
480  // compress GOP
481
482  m_cGOPEncoder.compressGOP(m_iPOCLast, m_iNumPicRcvd, m_cListPic, rcListPicYuvRecOut, accessUnitsOut, false, false);
483
484  if ( m_RCEnableRateControl )
485  {
486    m_cRateCtrl.destroyRCGOP();
487  }
488 
489  iNumEncoded         = m_iNumPicRcvd;
490  m_iNumPicRcvd       = 0;
491  m_uiNumAllPicCoded += iNumEncoded;
492}
493#endif
494
495/**------------------------------------------------
496 Separate interlaced frame into two fields
497 -------------------------------------------------**/
498void separateFields(Pel* org, Pel* dstField, UInt stride, UInt width, UInt height, Bool isTop)
499{
500  if (!isTop)
501  {
502    org += stride;
503  }
504  for (Int y = 0; y < height>>1; y++)
505  {
506    for (Int x = 0; x < width; x++)
507    {
508      dstField[x] = org[x];
509    }
510   
511    dstField += stride;
512    org += stride*2;
513  }
514 
515}
516
517#if SVC_EXTENSION
518Void TEncTop::encodePrep( TComPicYuv* pcPicYuvOrg, Bool isTff )
519{
520  if (pcPicYuvOrg)
521  {
522    /* -- TOP FIELD -- */
523    /* -- Top field initialization -- */
524   
525    TComPic *pcTopField;
526    xGetNewPicBuffer( pcTopField );
527#if !HM_CLEANUP_SAO
528    pcTopField->getPicSym()->allocSaoParam(&m_cEncSAO);
529#endif
530    pcTopField->setReconMark (false);
531   
532    pcTopField->getSlice(0)->setPOC( m_iPOCLast );
533    pcTopField->getPicYuvRec()->setBorderExtension(false);
534    pcTopField->setTopField(isTff);
535   
536    Int nHeight = pcPicYuvOrg->getHeight();
537    Int nWidth = pcPicYuvOrg->getWidth();
538    Int nStride = pcPicYuvOrg->getStride();
539    Int nPadLuma = pcPicYuvOrg->getLumaMargin();
540    Int nPadChroma = pcPicYuvOrg->getChromaMargin();
541   
542    // Get pointers
543    Pel * PicBufY = pcPicYuvOrg->getBufY();
544    Pel * PicBufU = pcPicYuvOrg->getBufU();
545    Pel * PicBufV = pcPicYuvOrg->getBufV();
546   
547    Pel * pcTopFieldY =  pcTopField->getPicYuvOrg()->getLumaAddr();
548    Pel * pcTopFieldU =  pcTopField->getPicYuvOrg()->getCbAddr();
549    Pel * pcTopFieldV =  pcTopField->getPicYuvOrg()->getCrAddr();
550
551    // compute image characteristics
552    if ( getUseAdaptiveQP() )
553    {
554      m_cPreanalyzer.xPreanalyze( dynamic_cast<TEncPic*>( pcTopField ) );
555    }   
556
557    /* -- Defield -- */
558   
559    Bool isTop = isTff;
560   
561    separateFields(PicBufY + nPadLuma + nStride*nPadLuma, pcTopFieldY, nStride, nWidth, nHeight, isTop);
562    separateFields(PicBufU + nPadChroma + (nStride >> 1)*nPadChroma, pcTopFieldU, nStride >> 1, nWidth >> 1, nHeight >> 1, isTop);
563    separateFields(PicBufV + nPadChroma + (nStride >> 1)*nPadChroma, pcTopFieldV, nStride >> 1, nWidth >> 1, nHeight >> 1, isTop);
564
565    /* -- BOTTOM FIELD -- */
566    /* -- Bottom field initialization -- */
567   
568    TComPic* pcBottomField;
569    xGetNewPicBuffer( pcBottomField );
570#if !HM_CLEANUP_SAO
571    pcBottomField->getPicSym()->allocSaoParam(&m_cEncSAO);
572#endif
573    pcBottomField->setReconMark (false);
574   
575    pcBottomField->getSlice(0)->setPOC( m_iPOCLast);
576    pcBottomField->getPicYuvRec()->setBorderExtension(false);
577    pcBottomField->setTopField(!isTff);
578   
579    nHeight = pcPicYuvOrg->getHeight();
580    nWidth = pcPicYuvOrg->getWidth();
581    nStride = pcPicYuvOrg->getStride();
582    nPadLuma = pcPicYuvOrg->getLumaMargin();
583    nPadChroma = pcPicYuvOrg->getChromaMargin();
584   
585    // Get pointers
586    PicBufY = pcPicYuvOrg->getBufY();
587    PicBufU = pcPicYuvOrg->getBufU();
588    PicBufV = pcPicYuvOrg->getBufV();
589   
590    Pel * pcBottomFieldY =  pcBottomField->getPicYuvOrg()->getLumaAddr();
591    Pel * pcBottomFieldU =  pcBottomField->getPicYuvOrg()->getCbAddr();
592    Pel * pcBottomFieldV =  pcBottomField->getPicYuvOrg()->getCrAddr();
593
594    // compute image characteristics
595    if ( getUseAdaptiveQP() )
596    {
597      m_cPreanalyzer.xPreanalyze( dynamic_cast<TEncPic*>( pcBottomField ) );
598    }       
599
600    /* -- Defield -- */
601   
602    isTop = !isTff;
603   
604    separateFields(PicBufY + nPadLuma + nStride*nPadLuma, pcBottomFieldY, nStride, nWidth, nHeight, isTop);
605    separateFields(PicBufU + nPadChroma + (nStride >> 1)*nPadChroma, pcBottomFieldU, nStride >> 1, nWidth >> 1, nHeight >> 1, isTop);
606    separateFields(PicBufV + nPadChroma + (nStride >> 1)*nPadChroma, pcBottomFieldV, nStride >> 1, nWidth >> 1, nHeight >> 1, isTop);
607   
608  }
609}
610
611Void TEncTop::encode( TComPicYuv* pcPicYuvOrg, TComList<TComPicYuv*>& rcListPicYuvRecOut, std::list<AccessUnit>& accessUnitsOut, Int iPicIdInGOP, Bool isTff )
612{
613  // compress GOP
614  if (m_iPOCLast == 0) // compress field 0
615  {
616    m_cGOPEncoder.compressGOP(iPicIdInGOP, m_iPOCLast, m_iNumPicRcvd, m_cListPic, rcListPicYuvRecOut, accessUnitsOut, true, isTff);
617  }
618
619  if (pcPicYuvOrg)
620  {
621    TComPicYuv* rpcPicYuvRec = new TComPicYuv;
622    if ( rcListPicYuvRecOut.size() == (UInt)m_iGOPSize )
623    {
624      rpcPicYuvRec = rcListPicYuvRecOut.popFront();
625    }
626    else
627    {
628#if AUXILIARY_PICTURES
629      rpcPicYuvRec->create( m_iSourceWidth, m_iSourceHeight, m_chromaFormatIDC, g_uiMaxCUWidth, g_uiMaxCUHeight, g_uiMaxCUDepth );
630#else
631      rpcPicYuvRec->create( m_iSourceWidth, m_iSourceHeight, g_uiMaxCUWidth, g_uiMaxCUHeight, g_uiMaxCUDepth );
632#endif
633    }
634    rcListPicYuvRecOut.pushBack( rpcPicYuvRec );
635  }
636 
637  // compress GOP
638  m_cGOPEncoder.compressGOP(iPicIdInGOP, m_iPOCLast, m_iNumPicRcvd, m_cListPic, rcListPicYuvRecOut, accessUnitsOut, true, isTff);
639
640  m_uiNumAllPicCoded ++;
641}
642#else
643Void TEncTop::encode(Bool flush, TComPicYuv* pcPicYuvOrg, TComList<TComPicYuv*>& rcListPicYuvRecOut, std::list<AccessUnit>& accessUnitsOut, Int& iNumEncoded, Bool isTff)
644{
645  /* -- TOP FIELD -- */
646 
647  if (pcPicYuvOrg)
648  {
649   
650    /* -- Top field initialization -- */
651   
652    TComPic *pcTopField;
653    xGetNewPicBuffer( pcTopField );
654#if !HM_CLEANUP_SAO
655    pcTopField->getPicSym()->allocSaoParam(&m_cEncSAO);
656#endif
657    pcTopField->setReconMark (false);
658   
659    pcTopField->getSlice(0)->setPOC( m_iPOCLast );
660    pcTopField->getPicYuvRec()->setBorderExtension(false);
661    pcTopField->setTopField(isTff);
662   
663    Int nHeight = pcPicYuvOrg->getHeight();
664    Int nWidth = pcPicYuvOrg->getWidth();
665    Int nStride = pcPicYuvOrg->getStride();
666    Int nPadLuma = pcPicYuvOrg->getLumaMargin();
667    Int nPadChroma = pcPicYuvOrg->getChromaMargin();
668   
669    // Get pointers
670    Pel * PicBufY = pcPicYuvOrg->getBufY();
671    Pel * PicBufU = pcPicYuvOrg->getBufU();
672    Pel * PicBufV = pcPicYuvOrg->getBufV();
673   
674    Pel * pcTopFieldY =  pcTopField->getPicYuvOrg()->getLumaAddr();
675    Pel * pcTopFieldU =  pcTopField->getPicYuvOrg()->getCbAddr();
676    Pel * pcTopFieldV =  pcTopField->getPicYuvOrg()->getCrAddr();
677   
678    // compute image characteristics
679    if ( getUseAdaptiveQP() )
680    {
681      m_cPreanalyzer.xPreanalyze( dynamic_cast<TEncPic*>( pcTopField ) );
682    }
683   
684    /* -- Defield -- */
685   
686    Bool isTop = isTff;
687   
688    separateFields(PicBufY + nPadLuma + nStride*nPadLuma, pcTopFieldY, nStride, nWidth, nHeight, isTop);
689    separateFields(PicBufU + nPadChroma + (nStride >> 1)*nPadChroma, pcTopFieldU, nStride >> 1, nWidth >> 1, nHeight >> 1, isTop);
690    separateFields(PicBufV + nPadChroma + (nStride >> 1)*nPadChroma, pcTopFieldV, nStride >> 1, nWidth >> 1, nHeight >> 1, isTop);
691   
692  }
693 
694  if (m_iPOCLast == 0) // compress field 0
695  {
696    m_cGOPEncoder.compressGOP(m_iPOCLast, m_iNumPicRcvd, m_cListPic, rcListPicYuvRecOut, accessUnitsOut, true, isTff);
697  }
698 
699  /* -- BOTTOM FIELD -- */
700 
701  if (pcPicYuvOrg)
702  {
703   
704    /* -- Bottom field initialization -- */
705   
706    TComPic* pcBottomField;
707    xGetNewPicBuffer( pcBottomField );
708#if !HM_CLEANUP_SAO
709    pcBottomField->getPicSym()->allocSaoParam(&m_cEncSAO);
710#endif
711    pcBottomField->setReconMark (false);
712   
713    TComPicYuv* rpcPicYuvRec;
714    if ( rcListPicYuvRecOut.size() == (UInt)m_iGOPSize )
715    {
716      rpcPicYuvRec = rcListPicYuvRecOut.popFront();
717    }
718    else
719    {
720      rpcPicYuvRec = new TComPicYuv;
721      rpcPicYuvRec->create( m_iSourceWidth, m_iSourceHeight, g_uiMaxCUWidth, g_uiMaxCUHeight, g_uiMaxCUDepth );
722    }
723    rcListPicYuvRecOut.pushBack( rpcPicYuvRec );
724   
725    pcBottomField->getSlice(0)->setPOC( m_iPOCLast);
726    pcBottomField->getPicYuvRec()->setBorderExtension(false);
727    pcBottomField->setTopField(!isTff);
728   
729    int nHeight = pcPicYuvOrg->getHeight();
730    int nWidth = pcPicYuvOrg->getWidth();
731    int nStride = pcPicYuvOrg->getStride();
732    int nPadLuma = pcPicYuvOrg->getLumaMargin();
733    int nPadChroma = pcPicYuvOrg->getChromaMargin();
734   
735    // Get pointers
736    Pel * PicBufY = pcPicYuvOrg->getBufY();
737    Pel * PicBufU = pcPicYuvOrg->getBufU();
738    Pel * PicBufV = pcPicYuvOrg->getBufV();
739   
740    Pel * pcBottomFieldY =  pcBottomField->getPicYuvOrg()->getLumaAddr();
741    Pel * pcBottomFieldU =  pcBottomField->getPicYuvOrg()->getCbAddr();
742    Pel * pcBottomFieldV =  pcBottomField->getPicYuvOrg()->getCrAddr();
743   
744    // Compute image characteristics
745    if ( getUseAdaptiveQP() )
746    {
747      m_cPreanalyzer.xPreanalyze( dynamic_cast<TEncPic*>( pcBottomField ) );
748    }
749   
750    /* -- Defield -- */
751   
752    Bool isTop = !isTff;
753   
754    separateFields(PicBufY + nPadLuma + nStride*nPadLuma, pcBottomFieldY, nStride, nWidth, nHeight, isTop);
755    separateFields(PicBufU + nPadChroma + (nStride >> 1)*nPadChroma, pcBottomFieldU, nStride >> 1, nWidth >> 1, nHeight >> 1, isTop);
756    separateFields(PicBufV + nPadChroma + (nStride >> 1)*nPadChroma, pcBottomFieldV, nStride >> 1, nWidth >> 1, nHeight >> 1, isTop);
757   
758  }
759 
760  if ( ( !(m_iNumPicRcvd) || (!flush && m_iPOCLast != 1 && m_iNumPicRcvd != m_iGOPSize && m_iGOPSize)) )
761  {
762    iNumEncoded = 0;
763    return;
764  }
765 
766  // compress GOP
767  m_cGOPEncoder.compressGOP(m_iPOCLast, m_iNumPicRcvd, m_cListPic, rcListPicYuvRecOut, accessUnitsOut, true, isTff);
768 
769  iNumEncoded = m_iNumPicRcvd;
770  m_iNumPicRcvd = 0;
771  m_uiNumAllPicCoded += iNumEncoded;
772}
773#endif
774
775// ====================================================================================================================
776// Protected member functions
777// ====================================================================================================================
778
779/**
780 - Application has picture buffer list with size of GOP + 1
781 - Picture buffer list acts like as ring buffer
782 - End of the list has the latest picture
783 .
784 \retval rpcPic obtained picture buffer
785 */
786Void TEncTop::xGetNewPicBuffer ( TComPic*& rpcPic )
787{
788  TComSlice::sortPicList(m_cListPic);
789 
790  if (m_cListPic.size() >= (UInt)(m_iGOPSize + getMaxDecPicBuffering(MAX_TLAYER-1) + 2) )
791  {
792    TComList<TComPic*>::iterator iterPic  = m_cListPic.begin();
793    Int iSize = Int( m_cListPic.size() );
794    for ( Int i = 0; i < iSize; i++ )
795    {
796      rpcPic = *(iterPic++);
797      if(rpcPic->getSlice(0)->isReferenced() == false)
798      {
799        break;
800      }
801    }
802  }
803  else
804  {
805    if ( getUseAdaptiveQP() )
806    {
807      TEncPic* pcEPic = new TEncPic;
808
809#if SVC_EXTENSION //Temporal solution, should be modified
810      if(m_layerId > 0)
811      {
812        for(UInt i = 0; i < m_cVPS.getNumDirectRefLayers( m_layerId ); i++ )
813        {
814#if O0098_SCALED_REF_LAYER_ID
815          const Window scalEL = getSPS()->getScaledRefLayerWindowForLayer(m_cVPS.getRefLayerId(m_layerId, i));
816#else
817          const Window scalEL = getSPS()->getScaledRefLayerWindow(i);
818#endif
819          Bool zeroOffsets = ( scalEL.getWindowLeftOffset() == 0 && scalEL.getWindowRightOffset() == 0 && scalEL.getWindowTopOffset() == 0 && scalEL.getWindowBottomOffset() == 0 );
820
821#if VPS_EXTN_DIRECT_REF_LAYERS
822          TEncTop *pcEncTopBase = (TEncTop *)getRefLayerEnc( i );
823#else
824          TEncTop *pcEncTopBase = (TEncTop *)getLayerEnc( m_layerId-1 );
825#endif
826          if(m_iSourceWidth != pcEncTopBase->getSourceWidth() || m_iSourceHeight != pcEncTopBase->getSourceHeight() || !zeroOffsets )
827          {
828            pcEPic->setSpatialEnhLayerFlag( i, true );
829
830            //only for scalable extension
831#if SCALABILITY_MASK_E0104
832            assert( m_cVPS.getScalabilityMask(2) == true );
833#else
834            assert( m_cVPS.getScalabilityMask(1) == true );
835#endif
836          }
837        }
838      }
839#endif
840
841#if AUXILIARY_PICTURES
842#if SVC_UPSAMPLING
843      pcEPic->create( m_iSourceWidth, m_iSourceHeight, m_chromaFormatIDC, g_uiMaxCUWidth, g_uiMaxCUHeight, g_uiMaxCUDepth, m_cPPS.getMaxCuDQPDepth()+1 ,
844                      m_conformanceWindow, m_defaultDisplayWindow, m_numReorderPics, &m_cSPS);
845#else
846      pcEPic->create( m_iSourceWidth, m_iSourceHeight, m_chromaFormatIDC, g_uiMaxCUWidth, g_uiMaxCUHeight, g_uiMaxCUDepth, m_cPPS.getMaxCuDQPDepth()+1 ,
847                      m_conformanceWindow, m_defaultDisplayWindow, m_numReorderPics);
848#endif
849#else
850#if SVC_UPSAMPLING
851      pcEPic->create( m_iSourceWidth, m_iSourceHeight, g_uiMaxCUWidth, g_uiMaxCUHeight, g_uiMaxCUDepth, m_cPPS.getMaxCuDQPDepth()+1 ,
852                      m_conformanceWindow, m_defaultDisplayWindow, m_numReorderPics, &m_cSPS);
853#else
854      pcEPic->create( m_iSourceWidth, m_iSourceHeight, g_uiMaxCUWidth, g_uiMaxCUHeight, g_uiMaxCUDepth, m_cPPS.getMaxCuDQPDepth()+1 ,
855                      m_conformanceWindow, m_defaultDisplayWindow, m_numReorderPics);
856#endif
857#endif
858      rpcPic = pcEPic;
859    }
860    else
861    {
862      rpcPic = new TComPic;
863
864#if SVC_EXTENSION //Temporal solution, should be modified
865      if(m_layerId > 0)
866      {
867        for(UInt i = 0; i < m_cVPS.getNumDirectRefLayers( m_layerId ); i++ )
868        {
869#if O0098_SCALED_REF_LAYER_ID
870          const Window scalEL = getSPS()->getScaledRefLayerWindowForLayer(m_cVPS.getRefLayerId(m_layerId, i));
871#else
872          const Window scalEL = getSPS()->getScaledRefLayerWindow(i);
873#endif
874          Bool zeroOffsets = ( scalEL.getWindowLeftOffset() == 0 && scalEL.getWindowRightOffset() == 0 && scalEL.getWindowTopOffset() == 0 && scalEL.getWindowBottomOffset() == 0 );
875
876#if VPS_EXTN_DIRECT_REF_LAYERS
877          TEncTop *pcEncTopBase = (TEncTop *)getRefLayerEnc( i );
878#else
879          TEncTop *pcEncTopBase = (TEncTop *)getLayerEnc( m_layerId-1 );
880#endif
881          if(m_iSourceWidth != pcEncTopBase->getSourceWidth() || m_iSourceHeight != pcEncTopBase->getSourceHeight() || !zeroOffsets )
882          {
883            rpcPic->setSpatialEnhLayerFlag( i, true );
884
885            //only for scalable extension
886#if SCALABILITY_MASK_E0104
887            assert( m_cVPS.getScalabilityMask(2) == true );
888#else
889            assert( m_cVPS.getScalabilityMask(1) == true );
890#endif
891          }
892        }
893      }
894#endif
895
896#if AUXILIARY_PICTURES
897#if SVC_UPSAMPLING
898      rpcPic->create( m_iSourceWidth, m_iSourceHeight, m_chromaFormatIDC, g_uiMaxCUWidth, g_uiMaxCUHeight, g_uiMaxCUDepth, 
899                      m_conformanceWindow, m_defaultDisplayWindow, m_numReorderPics, &m_cSPS);
900#else
901      rpcPic->create( m_iSourceWidth, m_iSourceHeight, m_chromaFormatIDC, g_uiMaxCUWidth, g_uiMaxCUHeight, g_uiMaxCUDepth, 
902                      m_conformanceWindow, m_defaultDisplayWindow, m_numReorderPics);
903#endif
904#else
905#if SVC_UPSAMPLING
906      rpcPic->create( m_iSourceWidth, m_iSourceHeight, g_uiMaxCUWidth, g_uiMaxCUHeight, g_uiMaxCUDepth, 
907                      m_conformanceWindow, m_defaultDisplayWindow, m_numReorderPics, &m_cSPS);
908#else
909      rpcPic->create( m_iSourceWidth, m_iSourceHeight, g_uiMaxCUWidth, g_uiMaxCUHeight, g_uiMaxCUDepth, 
910                      m_conformanceWindow, m_defaultDisplayWindow, m_numReorderPics);
911#endif
912#endif
913    }
914#if !HM_CLEANUP_SAO
915    if (getUseSAO())
916    {
917      rpcPic->getPicSym()->allocSaoParam(&m_cEncSAO);
918    }
919#endif
920    m_cListPic.pushBack( rpcPic );
921  }
922  rpcPic->setReconMark (false);
923 
924  m_iPOCLast++;
925  m_iNumPicRcvd++;
926 
927  rpcPic->getSlice(0)->setPOC( m_iPOCLast );
928  // mark it should be extended
929  rpcPic->getPicYuvRec()->setBorderExtension(false);
930}
931
932Void TEncTop::xInitSPS()
933{
934#if SVC_EXTENSION
935  m_cSPS.setLayerId(m_layerId);
936  m_cSPS.setNumScaledRefLayerOffsets(m_numScaledRefLayerOffsets);
937  for(Int i = 0; i < m_cSPS.getNumScaledRefLayerOffsets(); i++)
938  {
939#if O0098_SCALED_REF_LAYER_ID
940    m_cSPS.setScaledRefLayerId(i, m_scaledRefLayerId[i]);
941#endif
942    m_cSPS.getScaledRefLayerWindow(i) = m_scaledRefLayerWindow[i];
943  }
944#endif //SVC_EXTENSION
945  ProfileTierLevel& profileTierLevel = *m_cSPS.getPTL()->getGeneralPTL();
946  profileTierLevel.setLevelIdc(m_level);
947  profileTierLevel.setTierFlag(m_levelTier);
948  profileTierLevel.setProfileIdc(m_profile);
949  profileTierLevel.setProfileCompatibilityFlag(m_profile, 1);
950  profileTierLevel.setProgressiveSourceFlag(m_progressiveSourceFlag);
951  profileTierLevel.setInterlacedSourceFlag(m_interlacedSourceFlag);
952  profileTierLevel.setNonPackedConstraintFlag(m_nonPackedConstraintFlag);
953  profileTierLevel.setFrameOnlyConstraintFlag(m_frameOnlyConstraintFlag);
954 
955  if (m_profile == Profile::MAIN10 && g_bitDepthY == 8 && g_bitDepthC == 8)
956  {
957    /* The above constraint is equal to Profile::MAIN */
958    profileTierLevel.setProfileCompatibilityFlag(Profile::MAIN, 1);
959  }
960  if (m_profile == Profile::MAIN)
961  {
962    /* A Profile::MAIN10 decoder can always decode Profile::MAIN */
963    profileTierLevel.setProfileCompatibilityFlag(Profile::MAIN10, 1);
964  }
965  /* XXX: should Main be marked as compatible with still picture? */
966  /* XXX: may be a good idea to refactor the above into a function
967   * that chooses the actual compatibility based upon options */
968
969  m_cSPS.setPicWidthInLumaSamples         ( m_iSourceWidth      );
970  m_cSPS.setPicHeightInLumaSamples        ( m_iSourceHeight     );
971  m_cSPS.setConformanceWindow             ( m_conformanceWindow );
972  m_cSPS.setMaxCUWidth    ( g_uiMaxCUWidth      );
973  m_cSPS.setMaxCUHeight   ( g_uiMaxCUHeight     );
974  m_cSPS.setMaxCUDepth    ( g_uiMaxCUDepth      );
975#if AUXILIARY_PICTURES
976  m_cSPS.setChromaFormatIdc( m_chromaFormatIDC);
977#endif
978
979  Int minCUSize = m_cSPS.getMaxCUWidth() >> ( m_cSPS.getMaxCUDepth()-g_uiAddCUDepth );
980  Int log2MinCUSize = 0;
981  while(minCUSize > 1)
982  {
983    minCUSize >>= 1;
984    log2MinCUSize++;
985  }
986
987  m_cSPS.setLog2MinCodingBlockSize(log2MinCUSize);
988  m_cSPS.setLog2DiffMaxMinCodingBlockSize(m_cSPS.getMaxCUDepth()-g_uiAddCUDepth);
989#if SVC_EXTENSION
990  m_cSPS.setSPSId         ( m_iSPSIdCnt       );
991#endif
992 
993  m_cSPS.setPCMLog2MinSize (m_uiPCMLog2MinSize);
994  m_cSPS.setUsePCM        ( m_usePCM           );
995  m_cSPS.setPCMLog2MaxSize( m_pcmLog2MaxSize  );
996
997  m_cSPS.setQuadtreeTULog2MaxSize( m_uiQuadtreeTULog2MaxSize );
998  m_cSPS.setQuadtreeTULog2MinSize( m_uiQuadtreeTULog2MinSize );
999  m_cSPS.setQuadtreeTUMaxDepthInter( m_uiQuadtreeTUMaxDepthInter    );
1000  m_cSPS.setQuadtreeTUMaxDepthIntra( m_uiQuadtreeTUMaxDepthIntra    );
1001 
1002  m_cSPS.setTMVPFlagsPresent(false);
1003  m_cSPS.setUseLossless   ( m_useLossless  );
1004
1005  m_cSPS.setMaxTrSize   ( 1 << m_uiQuadtreeTULog2MaxSize );
1006 
1007  Int i;
1008 
1009  for (i = 0; i < g_uiMaxCUDepth-g_uiAddCUDepth; i++ )
1010  {
1011    m_cSPS.setAMPAcc( i, m_useAMP );
1012    //m_cSPS.setAMPAcc( i, 1 );
1013  }
1014
1015  m_cSPS.setUseAMP ( m_useAMP );
1016
1017  for (i = g_uiMaxCUDepth-g_uiAddCUDepth; i < g_uiMaxCUDepth; i++ )
1018  {
1019    m_cSPS.setAMPAcc(i, 0);
1020  }
1021
1022#if REPN_FORMAT_IN_VPS
1023  m_cSPS.setBitDepthY( m_cVPS.getVpsRepFormat( m_cVPS.getVpsRepFormatIdx( m_layerId ) )->getBitDepthVpsLuma() );
1024  m_cSPS.setBitDepthC( m_cVPS.getVpsRepFormat( m_cVPS.getVpsRepFormatIdx( m_layerId ) )->getBitDepthVpsChroma()  );
1025
1026  m_cSPS.setQpBDOffsetY ( 6*(m_cVPS.getVpsRepFormat( m_cVPS.getVpsRepFormatIdx( m_layerId ) )->getBitDepthVpsLuma()  - 8) );
1027  m_cSPS.setQpBDOffsetC ( 6*(m_cVPS.getVpsRepFormat( m_cVPS.getVpsRepFormatIdx( m_layerId ) )->getBitDepthVpsChroma()  - 8) );
1028#else
1029  m_cSPS.setBitDepthY( g_bitDepthY );
1030  m_cSPS.setBitDepthC( g_bitDepthC );
1031
1032  m_cSPS.setQpBDOffsetY ( 6*(g_bitDepthY - 8) );
1033  m_cSPS.setQpBDOffsetC ( 6*(g_bitDepthC - 8) );
1034#endif
1035
1036  m_cSPS.setUseSAO( m_bUseSAO );
1037
1038  m_cSPS.setMaxTLayers( m_maxTempLayer );
1039  m_cSPS.setTemporalIdNestingFlag( ( m_maxTempLayer == 1 ) ? true : false );
1040  for ( i = 0; i < m_cSPS.getMaxTLayers(); i++ )
1041  {
1042    m_cSPS.setMaxDecPicBuffering(m_maxDecPicBuffering[i], i);
1043    m_cSPS.setNumReorderPics(m_numReorderPics[i], i);
1044  }
1045  m_cSPS.setPCMBitDepthLuma (g_uiPCMBitDepthLuma);
1046  m_cSPS.setPCMBitDepthChroma (g_uiPCMBitDepthChroma);
1047  m_cSPS.setPCMFilterDisableFlag  ( m_bPCMFilterDisableFlag );
1048
1049  m_cSPS.setScalingListFlag ( (m_useScalingListId == 0) ? 0 : 1 );
1050
1051  m_cSPS.setUseStrongIntraSmoothing( m_useStrongIntraSmoothing );
1052
1053  m_cSPS.setVuiParametersPresentFlag(getVuiParametersPresentFlag());
1054  if (m_cSPS.getVuiParametersPresentFlag())
1055  {
1056    TComVUI* pcVUI = m_cSPS.getVuiParameters();
1057    pcVUI->setAspectRatioInfoPresentFlag(getAspectRatioIdc() != -1);
1058    pcVUI->setAspectRatioIdc(getAspectRatioIdc());
1059    pcVUI->setSarWidth(getSarWidth());
1060    pcVUI->setSarHeight(getSarHeight());
1061    pcVUI->setOverscanInfoPresentFlag(getOverscanInfoPresentFlag());
1062    pcVUI->setOverscanAppropriateFlag(getOverscanAppropriateFlag());
1063    pcVUI->setVideoSignalTypePresentFlag(getVideoSignalTypePresentFlag());
1064    pcVUI->setVideoFormat(getVideoFormat());
1065    pcVUI->setVideoFullRangeFlag(getVideoFullRangeFlag());
1066    pcVUI->setColourDescriptionPresentFlag(getColourDescriptionPresentFlag());
1067    pcVUI->setColourPrimaries(getColourPrimaries());
1068    pcVUI->setTransferCharacteristics(getTransferCharacteristics());
1069    pcVUI->setMatrixCoefficients(getMatrixCoefficients());
1070    pcVUI->setChromaLocInfoPresentFlag(getChromaLocInfoPresentFlag());
1071    pcVUI->setChromaSampleLocTypeTopField(getChromaSampleLocTypeTopField());
1072    pcVUI->setChromaSampleLocTypeBottomField(getChromaSampleLocTypeBottomField());
1073    pcVUI->setNeutralChromaIndicationFlag(getNeutralChromaIndicationFlag());
1074    pcVUI->setDefaultDisplayWindow(getDefaultDisplayWindow());
1075    pcVUI->setFrameFieldInfoPresentFlag(getFrameFieldInfoPresentFlag());
1076    pcVUI->setFieldSeqFlag(false);
1077    pcVUI->setHrdParametersPresentFlag(false);
1078    pcVUI->getTimingInfo()->setPocProportionalToTimingFlag(getPocProportionalToTimingFlag());
1079    pcVUI->getTimingInfo()->setNumTicksPocDiffOneMinus1   (getNumTicksPocDiffOneMinus1()   );
1080    pcVUI->setBitstreamRestrictionFlag(getBitstreamRestrictionFlag());
1081    pcVUI->setTilesFixedStructureFlag(getTilesFixedStructureFlag());
1082    pcVUI->setMotionVectorsOverPicBoundariesFlag(getMotionVectorsOverPicBoundariesFlag());
1083    pcVUI->setMinSpatialSegmentationIdc(getMinSpatialSegmentationIdc());
1084    pcVUI->setMaxBytesPerPicDenom(getMaxBytesPerPicDenom());
1085    pcVUI->setMaxBitsPerMinCuDenom(getMaxBitsPerMinCuDenom());
1086    pcVUI->setLog2MaxMvLengthHorizontal(getLog2MaxMvLengthHorizontal());
1087    pcVUI->setLog2MaxMvLengthVertical(getLog2MaxMvLengthVertical());
1088  }
1089}
1090
1091Void TEncTop::xInitPPS()
1092{
1093#if SCALINGLIST_INFERRING
1094  m_cPPS.setLayerId( m_layerId );
1095#endif
1096
1097  m_cPPS.setConstrainedIntraPred( m_bUseConstrainedIntraPred );
1098  Bool bUseDQP = (getMaxCuDQPDepth() > 0)? true : false;
1099
1100#if REPN_FORMAT_IN_VPS
1101  Int lowestQP;
1102#if O0096_REP_FORMAT_INDEX
1103  if( m_layerId == 0 )
1104  {
1105    lowestQP = - m_cSPS.getQpBDOffsetY();
1106  }
1107  else
1108  {
1109    lowestQP = - (m_cVPS.getVpsRepFormat( m_cVPS.getVpsRepFormatIdx( m_cSPS.getUpdateRepFormatFlag() ? m_cSPS.getUpdateRepFormatIndex() : m_layerId ) )->getBitDepthVpsLuma() - 8) * 6;
1110  }
1111#else
1112  if( m_layerId == 0 || m_cSPS.getUpdateRepFormatFlag() )
1113  {
1114    lowestQP = - m_cSPS.getQpBDOffsetY();
1115  }
1116  else
1117  {
1118    lowestQP = - (m_cVPS.getVpsRepFormat( m_cVPS.getVpsRepFormatIdx( m_layerId ) )->getBitDepthVpsLuma() - 8) * 6;
1119  }
1120#endif
1121#else
1122  Int lowestQP = - m_cSPS.getQpBDOffsetY();
1123#endif
1124
1125  if(getUseLossless())
1126  {
1127    if ((getMaxCuDQPDepth() == 0) && (getMaxDeltaQP() == 0 ) && (getQP() == lowestQP) )
1128    {
1129      bUseDQP = false;
1130    }
1131    else
1132    {
1133      bUseDQP = true;
1134    }
1135  }
1136  else
1137  {
1138    if(bUseDQP == false)
1139    {
1140      if((getMaxDeltaQP() != 0 )|| getUseAdaptiveQP())
1141      {
1142        bUseDQP = true;
1143      }
1144    }
1145  }
1146
1147  if(bUseDQP)
1148  {
1149    m_cPPS.setUseDQP(true);
1150    m_cPPS.setMaxCuDQPDepth( m_iMaxCuDQPDepth );
1151    m_cPPS.setMinCuDQPSize( m_cPPS.getSPS()->getMaxCUWidth() >> ( m_cPPS.getMaxCuDQPDepth()) );
1152  }
1153  else
1154  {
1155    m_cPPS.setUseDQP(false);
1156    m_cPPS.setMaxCuDQPDepth( 0 );
1157    m_cPPS.setMinCuDQPSize( m_cPPS.getSPS()->getMaxCUWidth() >> ( m_cPPS.getMaxCuDQPDepth()) );
1158  }
1159
1160  if ( m_RCEnableRateControl )
1161  {
1162    m_cPPS.setUseDQP(true);
1163    m_cPPS.setMaxCuDQPDepth( 0 );
1164    m_cPPS.setMinCuDQPSize( m_cPPS.getSPS()->getMaxCUWidth() >> ( m_cPPS.getMaxCuDQPDepth()) );
1165  } 
1166
1167  m_cPPS.setChromaCbQpOffset( m_chromaCbQpOffset );
1168  m_cPPS.setChromaCrQpOffset( m_chromaCrQpOffset );
1169
1170  m_cPPS.setNumSubstreams(m_iWaveFrontSubstreams);
1171  m_cPPS.setEntropyCodingSyncEnabledFlag( m_iWaveFrontSynchro > 0 );
1172  m_cPPS.setTilesEnabledFlag( (m_iNumColumnsMinus1 > 0 || m_iNumRowsMinus1 > 0) );
1173  m_cPPS.setUseWP( m_useWeightedPred );
1174  m_cPPS.setWPBiPred( m_useWeightedBiPred );
1175  m_cPPS.setOutputFlagPresentFlag( false );
1176  m_cPPS.setSignHideFlag(getSignHideFlag());
1177  if ( getDeblockingFilterMetric() )
1178  {
1179    m_cPPS.setDeblockingFilterControlPresentFlag (true);
1180    m_cPPS.setDeblockingFilterOverrideEnabledFlag(true);
1181    m_cPPS.setPicDisableDeblockingFilterFlag(false);
1182    m_cPPS.setDeblockingFilterBetaOffsetDiv2(0);
1183    m_cPPS.setDeblockingFilterTcOffsetDiv2(0);
1184  } 
1185  else
1186  {
1187  m_cPPS.setDeblockingFilterControlPresentFlag (m_DeblockingFilterControlPresent );
1188  }
1189  m_cPPS.setLog2ParallelMergeLevelMinus2   (m_log2ParallelMergeLevelMinus2 );
1190  m_cPPS.setCabacInitPresentFlag(CABAC_INIT_PRESENT_FLAG);
1191  m_cPPS.setLoopFilterAcrossSlicesEnabledFlag( m_bLFCrossSliceBoundaryFlag );
1192  Int histogram[MAX_NUM_REF + 1];
1193  for( Int i = 0; i <= MAX_NUM_REF; i++ )
1194  {
1195    histogram[i]=0;
1196  }
1197  for( Int i = 0; i < getGOPSize(); i++ )
1198  {
1199    assert(getGOPEntry(i).m_numRefPicsActive >= 0 && getGOPEntry(i).m_numRefPicsActive <= MAX_NUM_REF);
1200    histogram[getGOPEntry(i).m_numRefPicsActive]++;
1201  }
1202  Int maxHist=-1;
1203  Int bestPos=0;
1204  for( Int i = 0; i <= MAX_NUM_REF; i++ )
1205  {
1206    if(histogram[i]>maxHist)
1207    {
1208      maxHist=histogram[i];
1209      bestPos=i;
1210    }
1211  }
1212  assert(bestPos <= 15);
1213  m_cPPS.setNumRefIdxL0DefaultActive(bestPos);
1214  m_cPPS.setNumRefIdxL1DefaultActive(bestPos);
1215  m_cPPS.setTransquantBypassEnableFlag(getTransquantBypassEnableFlag());
1216  m_cPPS.setUseTransformSkip( m_useTransformSkip );
1217  if (m_sliceSegmentMode)
1218  {
1219    m_cPPS.setDependentSliceSegmentsEnabledFlag( true );
1220  }
1221  if( m_cPPS.getDependentSliceSegmentsEnabledFlag() )
1222  {
1223    Int NumCtx = m_cPPS.getEntropyCodingSyncEnabledFlag()?2:1;
1224    m_cSliceEncoder.initCtxMem( NumCtx );
1225    for ( UInt st = 0; st < NumCtx; st++ )
1226    {
1227      TEncSbac* ctx = NULL;
1228      ctx = new TEncSbac;
1229      ctx->init( &m_cBinCoderCABAC );
1230      m_cSliceEncoder.setCtxMem( ctx, st );
1231    }
1232  }
1233#if SVC_EXTENSION
1234  if (!m_layerId)
1235  {
1236    m_cPPS.setListsModificationPresentFlag(false);
1237  }
1238  else
1239  {
1240    m_cPPS.setListsModificationPresentFlag(true);
1241  }
1242
1243  m_cPPS.setPPSId         ( m_iPPSIdCnt         );
1244  m_cPPS.setSPSId         ( m_iSPSIdCnt         );
1245#endif
1246#if POC_RESET_FLAG
1247  m_cPPS.setNumExtraSliceHeaderBits( 2 );
1248#endif
1249#if O0149_CROSS_LAYER_BLA_FLAG
1250  if (m_crossLayerBLAFlag)
1251  {
1252    m_cPPS.setNumExtraSliceHeaderBits( 3 );
1253  }
1254#endif
1255}
1256
1257//Function for initializing m_RPSList, a list of TComReferencePictureSet, based on the GOPEntry objects read from the config file.
1258Void TEncTop::xInitRPS(Bool isFieldCoding)
1259{
1260  TComReferencePictureSet*      rps;
1261 
1262  m_cSPS.createRPSList(getGOPSize()+m_extraRPSs+1);
1263  TComRPSList* rpsList = m_cSPS.getRPSList();
1264
1265  for( Int i = 0; i < getGOPSize()+m_extraRPSs; i++) 
1266  {
1267    GOPEntry ge = getGOPEntry(i);
1268    rps = rpsList->getReferencePictureSet(i);
1269    rps->setNumberOfPictures(ge.m_numRefPics);
1270    rps->setNumRefIdc(ge.m_numRefIdc);
1271    Int numNeg = 0;
1272    Int numPos = 0;
1273    for( Int j = 0; j < ge.m_numRefPics; j++)
1274    {
1275      rps->setDeltaPOC(j,ge.m_referencePics[j]);
1276      rps->setUsed(j,ge.m_usedByCurrPic[j]);
1277      if(ge.m_referencePics[j]>0)
1278      {
1279        numPos++;
1280      }
1281      else
1282      {
1283        numNeg++;
1284      }
1285    }
1286    rps->setNumberOfNegativePictures(numNeg);
1287    rps->setNumberOfPositivePictures(numPos);
1288
1289    // handle inter RPS intialization from the config file.
1290#if AUTO_INTER_RPS
1291    rps->setInterRPSPrediction(ge.m_interRPSPrediction > 0);  // not very clean, converting anything > 0 to true.
1292    rps->setDeltaRIdxMinus1(0);                               // index to the Reference RPS is always the previous one.
1293    TComReferencePictureSet*     RPSRef = rpsList->getReferencePictureSet(i-1);  // get the reference RPS
1294
1295    if (ge.m_interRPSPrediction == 2)  // Automatic generation of the inter RPS idc based on the RIdx provided.
1296    {
1297      Int deltaRPS = getGOPEntry(i-1).m_POC - ge.m_POC;  // the ref POC - current POC
1298      Int numRefDeltaPOC = RPSRef->getNumberOfPictures();
1299
1300      rps->setDeltaRPS(deltaRPS);           // set delta RPS
1301      rps->setNumRefIdc(numRefDeltaPOC+1);  // set the numRefIdc to the number of pictures in the reference RPS + 1.
1302      Int count=0;
1303      for (Int j = 0; j <= numRefDeltaPOC; j++ ) // cycle through pics in reference RPS.
1304      {
1305        Int RefDeltaPOC = (j<numRefDeltaPOC)? RPSRef->getDeltaPOC(j): 0;  // if it is the last decoded picture, set RefDeltaPOC = 0
1306        rps->setRefIdc(j, 0);
1307        for (Int k = 0; k < rps->getNumberOfPictures(); k++ )  // cycle through pics in current RPS.
1308        {
1309          if (rps->getDeltaPOC(k) == ( RefDeltaPOC + deltaRPS))  // if the current RPS has a same picture as the reference RPS.
1310          {
1311              rps->setRefIdc(j, (rps->getUsed(k)?1:2));
1312              count++;
1313              break;
1314          }
1315        }
1316      }
1317      if (count != rps->getNumberOfPictures())
1318      {
1319        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");
1320        rps->setInterRPSPrediction(0);
1321      }
1322    }
1323    else if (ge.m_interRPSPrediction == 1)  // inter RPS idc based on the RefIdc values provided in config file.
1324    {
1325      rps->setDeltaRPS(ge.m_deltaRPS);
1326      rps->setNumRefIdc(ge.m_numRefIdc);
1327      for (Int j = 0; j < ge.m_numRefIdc; j++ )
1328      {
1329        rps->setRefIdc(j, ge.m_refIdc[j]);
1330      }
1331#if WRITE_BACK
1332      // the folowing code overwrite the deltaPOC and Used by current values read from the config file with the ones
1333      // computed from the RefIdc.  A warning is printed if they are not identical.
1334      numNeg = 0;
1335      numPos = 0;
1336      TComReferencePictureSet      RPSTemp;  // temporary variable
1337
1338      for (Int j = 0; j < ge.m_numRefIdc; j++ )
1339      {
1340        if (ge.m_refIdc[j])
1341        {
1342          Int deltaPOC = ge.m_deltaRPS + ((j < RPSRef->getNumberOfPictures())? RPSRef->getDeltaPOC(j) : 0);
1343          RPSTemp.setDeltaPOC((numNeg+numPos),deltaPOC);
1344          RPSTemp.setUsed((numNeg+numPos),ge.m_refIdc[j]==1?1:0);
1345          if (deltaPOC<0)
1346          {
1347            numNeg++;
1348          }
1349          else
1350          {
1351            numPos++;
1352          }
1353        }
1354      }
1355      if (numNeg != rps->getNumberOfNegativePictures())
1356      {
1357        printf("Warning: number of negative pictures in RPS is different between intra and inter RPS specified in the config file.\n");
1358        rps->setNumberOfNegativePictures(numNeg);
1359        rps->setNumberOfPictures(numNeg+numPos);
1360      }
1361      if (numPos != rps->getNumberOfPositivePictures())
1362      {
1363        printf("Warning: number of positive pictures in RPS is different between intra and inter RPS specified in the config file.\n");
1364        rps->setNumberOfPositivePictures(numPos);
1365        rps->setNumberOfPictures(numNeg+numPos);
1366      }
1367      RPSTemp.setNumberOfPictures(numNeg+numPos);
1368      RPSTemp.setNumberOfNegativePictures(numNeg);
1369      RPSTemp.sortDeltaPOC();     // sort the created delta POC before comparing
1370      // check if Delta POC and Used are the same
1371      // print warning if they are not.
1372      for (Int j = 0; j < ge.m_numRefIdc; j++ )
1373      {
1374        if (RPSTemp.getDeltaPOC(j) != rps->getDeltaPOC(j))
1375        {
1376          printf("Warning: delta POC is different between intra RPS and inter RPS specified in the config file.\n");
1377          rps->setDeltaPOC(j,RPSTemp.getDeltaPOC(j));
1378        }
1379        if (RPSTemp.getUsed(j) != rps->getUsed(j))
1380        {
1381          printf("Warning: Used by Current in RPS is different between intra and inter RPS specified in the config file.\n");
1382          rps->setUsed(j,RPSTemp.getUsed(j));
1383        }
1384      }
1385#endif
1386    }
1387#else
1388    rps->setInterRPSPrediction(ge.m_interRPSPrediction);
1389    if (ge.m_interRPSPrediction)
1390    {
1391      rps->setDeltaRIdxMinus1(0);
1392      rps->setDeltaRPS(ge.m_deltaRPS);
1393      rps->setNumRefIdc(ge.m_numRefIdc);
1394      for (Int j = 0; j < ge.m_numRefIdc; j++ )
1395      {
1396        rps->setRefIdc(j, ge.m_refIdc[j]);
1397      }
1398#if WRITE_BACK
1399      // the folowing code overwrite the deltaPOC and Used by current values read from the config file with the ones
1400      // computed from the RefIdc.  This is not necessary if both are identical. Currently there is no check to see if they are identical.
1401      numNeg = 0;
1402      numPos = 0;
1403      TComReferencePictureSet*     RPSRef = m_RPSList.getReferencePictureSet(i-1);
1404
1405      for (Int j = 0; j < ge.m_numRefIdc; j++ )
1406      {
1407        if (ge.m_refIdc[j])
1408        {
1409          Int deltaPOC = ge.m_deltaRPS + ((j < RPSRef->getNumberOfPictures())? RPSRef->getDeltaPOC(j) : 0);
1410          rps->setDeltaPOC((numNeg+numPos),deltaPOC);
1411          rps->setUsed((numNeg+numPos),ge.m_refIdc[j]==1?1:0);
1412          if (deltaPOC<0)
1413          {
1414            numNeg++;
1415          }
1416          else
1417          {
1418            numPos++;
1419          }
1420        }
1421      }
1422      rps->setNumberOfNegativePictures(numNeg);
1423      rps->setNumberOfPositivePictures(numPos);
1424      rps->sortDeltaPOC();
1425#endif
1426    }
1427#endif //INTER_RPS_AUTO
1428  }
1429  //In case of field coding, we need to set special parameters for the first bottom field of the sequence, since it is not specified in the cfg file.
1430  //The position = GOPSize + extraRPSs which is (a priori) unused is reserved for this field in the RPS.
1431  if (isFieldCoding) 
1432  {
1433    rps = rpsList->getReferencePictureSet(getGOPSize()+m_extraRPSs);
1434    rps->setNumberOfPictures(1);
1435    rps->setNumberOfNegativePictures(1);
1436    rps->setNumberOfPositivePictures(0);
1437    rps->setNumberOfLongtermPictures(0);
1438    rps->setDeltaPOC(0,-1);
1439    rps->setPOC(0,0);
1440    rps->setUsed(0,true);
1441    rps->setInterRPSPrediction(false);
1442    rps->setDeltaRIdxMinus1(0);
1443    rps->setDeltaRPS(0);
1444    rps->setNumRefIdc(0);
1445}
1446}
1447
1448   // This is a function that
1449   // determines what Reference Picture Set to use
1450   // for a specific slice (with POC = POCCurr)
1451Void TEncTop::selectReferencePictureSet(TComSlice* slice, Int POCCurr, Int GOPid )
1452{
1453  slice->setRPSidx(GOPid);
1454  for(Int extraNum=m_iGOPSize; extraNum<m_extraRPSs+m_iGOPSize; extraNum++)
1455  {   
1456    if(m_uiIntraPeriod > 0 && getDecodingRefreshType() > 0)
1457    {
1458      Int POCIndex = POCCurr%m_uiIntraPeriod;
1459      if(POCIndex == 0)
1460      {
1461        POCIndex = m_uiIntraPeriod;
1462      }
1463      if(POCIndex == m_GOPList[extraNum].m_POC)
1464      {
1465        slice->setRPSidx(extraNum);
1466      }
1467    }
1468    else
1469    {
1470      if(POCCurr==m_GOPList[extraNum].m_POC)
1471      {
1472        slice->setRPSidx(extraNum);
1473      }
1474    }
1475  }
1476
1477  if(POCCurr == 1 && slice->getPic()->isField())
1478  {
1479    slice->setRPSidx(m_iGOPSize+m_extraRPSs);
1480  }
1481
1482  slice->setRPS(getSPS()->getRPSList()->getReferencePictureSet(slice->getRPSidx()));
1483  slice->getRPS()->setNumberOfPictures(slice->getRPS()->getNumberOfNegativePictures()+slice->getRPS()->getNumberOfPositivePictures());
1484}
1485
1486Int TEncTop::getReferencePictureSetIdxForSOP(TComSlice* slice, Int POCCurr, Int GOPid )
1487{
1488  int rpsIdx = GOPid;
1489
1490  for(Int extraNum=m_iGOPSize; extraNum<m_extraRPSs+m_iGOPSize; extraNum++)
1491  {   
1492    if(m_uiIntraPeriod > 0 && getDecodingRefreshType() > 0)
1493    {
1494      Int POCIndex = POCCurr%m_uiIntraPeriod;
1495      if(POCIndex == 0)
1496      {
1497        POCIndex = m_uiIntraPeriod;
1498      }
1499      if(POCIndex == m_GOPList[extraNum].m_POC)
1500      {
1501        rpsIdx = extraNum;
1502      }
1503    }
1504    else
1505    {
1506      if(POCCurr==m_GOPList[extraNum].m_POC)
1507      {
1508        rpsIdx = extraNum;
1509      }
1510    }
1511  }
1512
1513  return rpsIdx;
1514}
1515
1516Void  TEncTop::xInitPPSforTiles()
1517{
1518  m_cPPS.setUniformSpacingFlag( m_iUniformSpacingIdr );
1519  m_cPPS.setNumColumnsMinus1( m_iNumColumnsMinus1 );
1520  m_cPPS.setNumRowsMinus1( m_iNumRowsMinus1 );
1521  if( m_iUniformSpacingIdr == 0 )
1522  {
1523    m_cPPS.setColumnWidth( m_puiColumnWidth );
1524    m_cPPS.setRowHeight( m_puiRowHeight );
1525  }
1526  m_cPPS.setLoopFilterAcrossTilesEnabledFlag( m_loopFilterAcrossTilesEnabledFlag );
1527
1528  // # substreams is "per tile" when tiles are independent.
1529  if (m_iWaveFrontSynchro
1530    )
1531  {
1532    m_cPPS.setNumSubstreams(m_iWaveFrontSubstreams * (m_iNumColumnsMinus1+1));
1533  }
1534}
1535
1536Void  TEncCfg::xCheckGSParameters()
1537{
1538  Int   iWidthInCU = ( m_iSourceWidth%g_uiMaxCUWidth ) ? m_iSourceWidth/g_uiMaxCUWidth + 1 : m_iSourceWidth/g_uiMaxCUWidth;
1539  Int   iHeightInCU = ( m_iSourceHeight%g_uiMaxCUHeight ) ? m_iSourceHeight/g_uiMaxCUHeight + 1 : m_iSourceHeight/g_uiMaxCUHeight;
1540  UInt  uiCummulativeColumnWidth = 0;
1541  UInt  uiCummulativeRowHeight = 0;
1542
1543  //check the column relative parameters
1544  if( m_iNumColumnsMinus1 >= (1<<(LOG2_MAX_NUM_COLUMNS_MINUS1+1)) )
1545  {
1546    printf( "The number of columns is larger than the maximum allowed number of columns.\n" );
1547    exit( EXIT_FAILURE );
1548  }
1549
1550  if( m_iNumColumnsMinus1 >= iWidthInCU )
1551  {
1552    printf( "The current picture can not have so many columns.\n" );
1553    exit( EXIT_FAILURE );
1554  }
1555
1556  if( m_iNumColumnsMinus1 && m_iUniformSpacingIdr==0 )
1557  {
1558    for(Int i=0; i<m_iNumColumnsMinus1; i++)
1559    {
1560      uiCummulativeColumnWidth += m_puiColumnWidth[i];
1561    }
1562
1563    if( uiCummulativeColumnWidth >= iWidthInCU )
1564    {
1565      printf( "The width of the column is too large.\n" );
1566      exit( EXIT_FAILURE );
1567    }
1568  }
1569
1570  //check the row relative parameters
1571  if( m_iNumRowsMinus1 >= (1<<(LOG2_MAX_NUM_ROWS_MINUS1+1)) )
1572  {
1573    printf( "The number of rows is larger than the maximum allowed number of rows.\n" );
1574    exit( EXIT_FAILURE );
1575  }
1576
1577  if( m_iNumRowsMinus1 >= iHeightInCU )
1578  {
1579    printf( "The current picture can not have so many rows.\n" );
1580    exit( EXIT_FAILURE );
1581  }
1582
1583  if( m_iNumRowsMinus1 && m_iUniformSpacingIdr==0 )
1584  {
1585    for(Int i=0; i<m_iNumRowsMinus1; i++)
1586    {
1587      uiCummulativeRowHeight += m_puiRowHeight[i];
1588    }
1589
1590    if( uiCummulativeRowHeight >= iHeightInCU )
1591    {
1592      printf( "The height of the row is too large.\n" );
1593      exit( EXIT_FAILURE );
1594    }
1595  }
1596}
1597
1598#if SVC_EXTENSION
1599#if VPS_EXTN_DIRECT_REF_LAYERS
1600TEncTop* TEncTop::getRefLayerEnc( UInt refLayerIdc )
1601{
1602  if( m_ppcTEncTop[m_layerId]->getNumDirectRefLayers() <= 0 )
1603  {
1604    return (TEncTop *)getLayerEnc( 0 );
1605  }
1606
1607  return (TEncTop *)getLayerEnc( m_cVPS.getRefLayerId( m_layerId, refLayerIdc ) );
1608}
1609#endif
1610
1611#if !REPN_FORMAT_IN_VPS
1612Void TEncTop::xInitILRP()
1613{
1614  if(m_layerId>0)
1615  {
1616    g_bitDepthY     = m_cSPS.getBitDepthY();
1617    g_bitDepthC     = m_cSPS.getBitDepthC();
1618    g_uiMaxCUWidth  = m_cSPS.getMaxCUWidth();
1619    g_uiMaxCUHeight = m_cSPS.getMaxCUHeight();
1620    g_uiMaxCUDepth  = m_cSPS.getMaxCUDepth();
1621    g_uiAddCUDepth  = max (0, m_cSPS.getLog2MinCodingBlockSize() - (Int)m_cSPS.getQuadtreeTULog2MinSize() );
1622
1623    Int  numReorderPics[MAX_TLAYER];
1624    Window &conformanceWindow = m_cSPS.getConformanceWindow();
1625    Window defaultDisplayWindow = m_cSPS.getVuiParametersPresentFlag() ? m_cSPS.getVuiParameters()->getDefaultDisplayWindow() : Window();
1626
1627    if (m_cIlpPic[0] == NULL)
1628    {
1629      for (Int j=0; j < m_numLayer; j++) // consider to set to NumDirectRefLayers[LayerIdInVps[nuh_layer_id]]
1630      {
1631        m_cIlpPic[j] = new  TComPic;
1632#if SVC_UPSAMPLING
1633#if AUXILIARY_PICTURES
1634        m_cIlpPic[j]->create(m_iSourceWidth, m_iSourceHeight, m_chromaFormatIDC, g_uiMaxCUWidth, g_uiMaxCUHeight, g_uiMaxCUDepth, conformanceWindow, defaultDisplayWindow, numReorderPics, &m_cSPS, true);
1635#else
1636        m_cIlpPic[j]->create(m_iSourceWidth, m_iSourceHeight, g_uiMaxCUWidth, g_uiMaxCUHeight, g_uiMaxCUDepth, conformanceWindow, defaultDisplayWindow, numReorderPics, &m_cSPS, true);
1637#endif
1638#else
1639        m_cIlpPic[j]->create(m_iSourceWidth, m_iSourceHeight, g_uiMaxCUWidth, g_uiMaxCUHeight, g_uiMaxCUDepth, conformanceWindow, defaultDisplayWindow, numReorderPics, true);
1640#endif
1641        for (Int i=0; i<m_cIlpPic[j]->getPicSym()->getNumberOfCUsInFrame(); i++)
1642        {
1643          m_cIlpPic[j]->getPicSym()->getCU(i)->initCU(m_cIlpPic[j], i);
1644        }
1645      }
1646    }
1647  }
1648}
1649#else
1650Void TEncTop::xInitILRP()
1651{
1652#if O0096_REP_FORMAT_INDEX
1653  RepFormat *repFormat = m_cVPS.getVpsRepFormat( m_cVPS.getVpsRepFormatIdx( m_cSPS.getUpdateRepFormatFlag() ? m_cSPS.getUpdateRepFormatIndex() : m_layerId ) );
1654#else
1655  RepFormat *repFormat = m_cVPS.getVpsRepFormat( m_cVPS.getVpsRepFormatIdx( m_layerId ) );
1656#endif
1657  Int bitDepthY,bitDepthC,picWidth,picHeight;
1658
1659#if O0096_REP_FORMAT_INDEX
1660  bitDepthY   = repFormat->getBitDepthVpsLuma();
1661  bitDepthC   = repFormat->getBitDepthVpsChroma();
1662  picWidth    = repFormat->getPicWidthVpsInLumaSamples();
1663  picHeight   = repFormat->getPicHeightVpsInLumaSamples();
1664#else
1665  if( m_cSPS.getUpdateRepFormatFlag() )
1666  {
1667    bitDepthY   = m_cSPS.getBitDepthY();
1668    bitDepthC   = m_cSPS.getBitDepthC();
1669    picWidth    = m_cSPS.getPicWidthInLumaSamples();
1670    picHeight   = m_cSPS.getPicHeightInLumaSamples();
1671  }
1672  else
1673  {
1674    bitDepthY   = repFormat->getBitDepthVpsLuma();
1675    bitDepthC   = repFormat->getBitDepthVpsChroma();
1676    picWidth    = repFormat->getPicWidthVpsInLumaSamples();
1677    picHeight   = repFormat->getPicHeightVpsInLumaSamples();
1678  }
1679#endif
1680 
1681  if(m_layerId > 0)
1682  {
1683    g_bitDepthY     = bitDepthY;
1684    g_bitDepthC     = bitDepthC;
1685    g_uiMaxCUWidth  = m_cSPS.getMaxCUWidth();
1686    g_uiMaxCUHeight = m_cSPS.getMaxCUHeight();
1687    g_uiMaxCUDepth  = m_cSPS.getMaxCUDepth();
1688    g_uiAddCUDepth  = max (0, m_cSPS.getLog2MinCodingBlockSize() - (Int)m_cSPS.getQuadtreeTULog2MinSize() );
1689
1690    Int  numReorderPics[MAX_TLAYER];
1691    Window &conformanceWindow = m_cSPS.getConformanceWindow();
1692    Window defaultDisplayWindow = m_cSPS.getVuiParametersPresentFlag() ? m_cSPS.getVuiParameters()->getDefaultDisplayWindow() : Window();
1693
1694    if (m_cIlpPic[0] == NULL)
1695    {
1696      for (Int j=0; j < m_numDirectRefLayers; j++)
1697      {
1698        m_cIlpPic[j] = new  TComPic;
1699#if SVC_UPSAMPLING
1700#if AUXILIARY_PICTURES
1701        m_cIlpPic[j]->create(picWidth, picHeight, m_chromaFormatIDC, g_uiMaxCUWidth, g_uiMaxCUHeight, g_uiMaxCUDepth, conformanceWindow, defaultDisplayWindow, numReorderPics, &m_cSPS, true);
1702#else
1703        m_cIlpPic[j]->create(picWidth, picHeight, g_uiMaxCUWidth, g_uiMaxCUHeight, g_uiMaxCUDepth, conformanceWindow, defaultDisplayWindow, numReorderPics, &m_cSPS, true);
1704#endif
1705#else
1706        m_cIlpPic[j]->create(m_iSourceWidth, m_iSourceHeight, g_uiMaxCUWidth, g_uiMaxCUHeight, g_uiMaxCUDepth, conformanceWindow, defaultDisplayWindow, numReorderPics, true);
1707#endif
1708        for (Int i=0; i<m_cIlpPic[j]->getPicSym()->getNumberOfCUsInFrame(); i++)
1709        {
1710          m_cIlpPic[j]->getPicSym()->getCU(i)->initCU(m_cIlpPic[j], i);
1711        }
1712      }
1713    }
1714  }
1715}
1716#endif
1717
1718#if O0098_SCALED_REF_LAYER_ID
1719Window& TEncTop::getScaledRefLayerWindowForLayer(Int layerId)
1720{
1721  static Window win;
1722
1723  for (Int i = 0; i < m_numScaledRefLayerOffsets; i++)
1724  {
1725    if (layerId == m_scaledRefLayerId[i])
1726    {
1727      return m_scaledRefLayerWindow[i];
1728    }
1729  }
1730
1731  win.resetWindow();  // scaled reference layer offsets are inferred to be zero when not present
1732  return win;
1733}
1734#endif
1735
1736#endif //SVC_EXTENSION
1737//! \}
Note: See TracBrowser for help on using the repository browser.