source: SHVCSoftware/branches/SHM-5.1-dev/source/Lib/TLibEncoder/TEncTop.cpp @ 632

Last change on this file since 632 was 627, checked in by qualcomm, 12 years ago

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