source: 3DVCSoftware/branches/HTM-9.2-dev0/source/Lib/TLibEncoder/TEncTop.cpp @ 769

Last change on this file since 769 was 769, checked in by tech, 10 years ago

Further fixes.

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