source: 3DVCSoftware/branches/HTM-9.1-dev0-ZTE/source/Lib/TLibEncoder/TEncTop.cpp @ 748

Last change on this file since 748 was 748, checked in by zte, 11 years ago

JCT3V-F0131, JCT3V-F0139

  • Property svn:eol-style set to native
File size: 49.1 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 DLT_DIFF_CODING_IN_PPS
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#if H_MV_6_PS_REP_FORM_18_19_20
726  m_cSPS.setUpdateRepFormatFlag           ( false );   
727#else
728  m_cSPS.setUpdateRepFormatFlag           ( m_layerId == 0 );   
729#endif
730  m_cSPS.setSpsInferScalingListFlag       ( m_layerId > 0 && m_cVPS->getInDirectDependencyFlag( getLayerIdInVps(), 0 ) ); 
731  m_cSPS.setSpsScalingListRefLayerId      ( 0              ); 
732#if H_MV_6_PSEM_O0142_3
733  m_cSPS.setSpsExtensionFlag              ( true ); 
734  m_cSPS.setSpsExtensionTypeFlag          ( PS_EX_T_MV ,true ); 
735#if H_3D
736  m_cSPS.setSpsExtensionTypeFlag          ( PS_EX_T_3D ,true ); 
737#endif
738#endif
739#endif
740  m_cSPS.setPicWidthInLumaSamples         ( m_iSourceWidth      );
741  m_cSPS.setPicHeightInLumaSamples        ( m_iSourceHeight     );
742  m_cSPS.setConformanceWindow             ( m_conformanceWindow );
743  m_cSPS.setMaxCUWidth    ( g_uiMaxCUWidth      );
744  m_cSPS.setMaxCUHeight   ( g_uiMaxCUHeight     );
745  m_cSPS.setMaxCUDepth    ( g_uiMaxCUDepth      );
746
747  Int minCUSize = m_cSPS.getMaxCUWidth() >> ( m_cSPS.getMaxCUDepth()-g_uiAddCUDepth );
748  Int log2MinCUSize = 0;
749  while(minCUSize > 1)
750  {
751    minCUSize >>= 1;
752    log2MinCUSize++;
753  }
754
755  m_cSPS.setLog2MinCodingBlockSize(log2MinCUSize);
756  m_cSPS.setLog2DiffMaxMinCodingBlockSize(m_cSPS.getMaxCUDepth()-g_uiAddCUDepth);
757 
758  m_cSPS.setPCMLog2MinSize (m_uiPCMLog2MinSize);
759  m_cSPS.setUsePCM        ( m_usePCM           );
760  m_cSPS.setPCMLog2MaxSize( m_pcmLog2MaxSize  );
761
762  m_cSPS.setQuadtreeTULog2MaxSize( m_uiQuadtreeTULog2MaxSize );
763  m_cSPS.setQuadtreeTULog2MinSize( m_uiQuadtreeTULog2MinSize );
764  m_cSPS.setQuadtreeTUMaxDepthInter( m_uiQuadtreeTUMaxDepthInter    );
765  m_cSPS.setQuadtreeTUMaxDepthIntra( m_uiQuadtreeTUMaxDepthIntra    );
766 
767  m_cSPS.setTMVPFlagsPresent(false);
768  m_cSPS.setUseLossless   ( m_useLossless  );
769
770  m_cSPS.setMaxTrSize   ( 1 << m_uiQuadtreeTULog2MaxSize );
771 
772  Int i;
773 
774  for (i = 0; i < g_uiMaxCUDepth-g_uiAddCUDepth; i++ )
775  {
776    m_cSPS.setAMPAcc( i, m_useAMP );
777    //m_cSPS.setAMPAcc( i, 1 );
778  }
779
780  m_cSPS.setUseAMP ( m_useAMP );
781
782#if H_3D_QTLPC
783  m_cSPS.setUseQTL( m_bUseQTL );
784  m_cSPS.setUsePC ( m_bUsePC  );
785#endif
786
787  for (i = g_uiMaxCUDepth-g_uiAddCUDepth; i < g_uiMaxCUDepth; i++ )
788  {
789    m_cSPS.setAMPAcc(i, 0);
790  }
791
792  m_cSPS.setBitDepthY( g_bitDepthY );
793  m_cSPS.setBitDepthC( g_bitDepthC );
794
795  m_cSPS.setQpBDOffsetY ( 6*(g_bitDepthY - 8) );
796  m_cSPS.setQpBDOffsetC ( 6*(g_bitDepthC - 8) );
797
798  m_cSPS.setUseSAO( m_bUseSAO );
799
800  m_cSPS.setMaxTLayers( m_maxTempLayer );
801  m_cSPS.setTemporalIdNestingFlag( ( m_maxTempLayer == 1 ) ? true : false );
802  for ( i = 0; i < m_cSPS.getMaxTLayers(); i++ )
803  {
804    m_cSPS.setMaxDecPicBuffering(m_maxDecPicBuffering[i], i);
805    m_cSPS.setNumReorderPics(m_numReorderPics[i], i);
806  }
807  m_cSPS.setPCMBitDepthLuma (g_uiPCMBitDepthLuma);
808  m_cSPS.setPCMBitDepthChroma (g_uiPCMBitDepthChroma);
809  m_cSPS.setPCMFilterDisableFlag  ( m_bPCMFilterDisableFlag );
810
811  m_cSPS.setScalingListFlag ( (m_useScalingListId == 0) ? 0 : 1 );
812
813  m_cSPS.setUseStrongIntraSmoothing( m_useStrongIntraSmoothing );
814
815  m_cSPS.setVuiParametersPresentFlag(getVuiParametersPresentFlag());
816  if (m_cSPS.getVuiParametersPresentFlag())
817  {
818    TComVUI* pcVUI = m_cSPS.getVuiParameters();
819    pcVUI->setAspectRatioInfoPresentFlag(getAspectRatioIdc() != -1);
820    pcVUI->setAspectRatioIdc(getAspectRatioIdc());
821    pcVUI->setSarWidth(getSarWidth());
822    pcVUI->setSarHeight(getSarHeight());
823    pcVUI->setOverscanInfoPresentFlag(getOverscanInfoPresentFlag());
824    pcVUI->setOverscanAppropriateFlag(getOverscanAppropriateFlag());
825#if H_MV_6_PS_O0118_33
826    pcVUI->setVideoSignalTypePresentFlag(getVideoSignalTypePresentFlag() && getLayerId() == 0 );
827#else
828    pcVUI->setVideoSignalTypePresentFlag(getVideoSignalTypePresentFlag());
829#endif
830    pcVUI->setVideoFormat(getVideoFormat());
831    pcVUI->setVideoFullRangeFlag(getVideoFullRangeFlag());
832    pcVUI->setColourDescriptionPresentFlag(getColourDescriptionPresentFlag());
833    pcVUI->setColourPrimaries(getColourPrimaries());
834    pcVUI->setTransferCharacteristics(getTransferCharacteristics());
835    pcVUI->setMatrixCoefficients(getMatrixCoefficients());
836    pcVUI->setChromaLocInfoPresentFlag(getChromaLocInfoPresentFlag());
837    pcVUI->setChromaSampleLocTypeTopField(getChromaSampleLocTypeTopField());
838    pcVUI->setChromaSampleLocTypeBottomField(getChromaSampleLocTypeBottomField());
839    pcVUI->setNeutralChromaIndicationFlag(getNeutralChromaIndicationFlag());
840    pcVUI->setDefaultDisplayWindow(getDefaultDisplayWindow());
841    pcVUI->setFrameFieldInfoPresentFlag(getFrameFieldInfoPresentFlag());
842    pcVUI->setFieldSeqFlag(false);
843    pcVUI->setHrdParametersPresentFlag(false);
844    pcVUI->getTimingInfo()->setPocProportionalToTimingFlag(getPocProportionalToTimingFlag());
845    pcVUI->getTimingInfo()->setNumTicksPocDiffOneMinus1   (getNumTicksPocDiffOneMinus1()   );
846    pcVUI->setBitstreamRestrictionFlag(getBitstreamRestrictionFlag());
847    pcVUI->setTilesFixedStructureFlag(getTilesFixedStructureFlag());
848    pcVUI->setMotionVectorsOverPicBoundariesFlag(getMotionVectorsOverPicBoundariesFlag());
849    pcVUI->setMinSpatialSegmentationIdc(getMinSpatialSegmentationIdc());
850    pcVUI->setMaxBytesPerPicDenom(getMaxBytesPerPicDenom());
851    pcVUI->setMaxBitsPerMinCuDenom(getMaxBitsPerMinCuDenom());
852    pcVUI->setLog2MaxMvLengthHorizontal(getLog2MaxMvLengthHorizontal());
853    pcVUI->setLog2MaxMvLengthVertical(getLog2MaxMvLengthVertical());
854  }
855#if H_3D
856#if !QC_DEPTH_IV_MRG_F0125
857  if ( !m_isDepth )
858#endif
859  {
860    m_cSPS.initCamParaSPS           ( m_viewIndex, m_uiCamParPrecision, m_bCamParInSliceHeader, m_aaiCodedScale, m_aaiCodedOffset );
861  }
862#endif
863}
864
865Void TEncTop::xInitPPS()
866{
867#if H_MV
868  m_cPPS.setLayerId( getLayerId() );
869  if( getVPS()->getNumDirectRefLayers( getLayerId() ) > 0 )
870  {
871    m_cPPS.setListsModificationPresentFlag( true );
872  }
873  m_cPPS.setPPSId( getLayerIdInVps() );
874  m_cPPS.setSPSId( getLayerIdInVps() );
875#endif
876
877#if DLT_DIFF_CODING_IN_PPS
878  m_cPPS.setDLT( getDLT() );
879#endif
880
881  m_cPPS.setConstrainedIntraPred( m_bUseConstrainedIntraPred );
882  Bool bUseDQP = (getMaxCuDQPDepth() > 0)? true : false;
883
884  Int lowestQP = - m_cSPS.getQpBDOffsetY();
885
886  if(getUseLossless())
887  {
888    if ((getMaxCuDQPDepth() == 0) && (getMaxDeltaQP() == 0 ) && (getQP() == lowestQP) )
889    {
890      bUseDQP = false;
891    }
892    else
893    {
894      bUseDQP = true;
895    }
896  }
897  else
898  {
899    if(bUseDQP == false)
900    {
901      if((getMaxDeltaQP() != 0 )|| getUseAdaptiveQP())
902      {
903        bUseDQP = true;
904      }
905    }
906  }
907
908  if(bUseDQP)
909  {
910    m_cPPS.setUseDQP(true);
911    m_cPPS.setMaxCuDQPDepth( m_iMaxCuDQPDepth );
912    m_cPPS.setMinCuDQPSize( m_cPPS.getSPS()->getMaxCUWidth() >> ( m_cPPS.getMaxCuDQPDepth()) );
913  }
914  else
915  {
916    m_cPPS.setUseDQP(false);
917    m_cPPS.setMaxCuDQPDepth( 0 );
918    m_cPPS.setMinCuDQPSize( m_cPPS.getSPS()->getMaxCUWidth() >> ( m_cPPS.getMaxCuDQPDepth()) );
919  }
920
921#if RATE_CONTROL_LAMBDA_DOMAIN
922  if ( m_RCEnableRateControl )
923  {
924    m_cPPS.setUseDQP(true);
925    m_cPPS.setMaxCuDQPDepth( 0 );
926    m_cPPS.setMinCuDQPSize( m_cPPS.getSPS()->getMaxCUWidth() >> ( m_cPPS.getMaxCuDQPDepth()) );
927  }
928#endif
929#if !RATE_CONTROL_LAMBDA_DOMAIN && KWU_FIX_URQ
930  if ( m_enableRateCtrl )
931  {
932    m_cPPS.setUseDQP(true);
933    m_cPPS.setMaxCuDQPDepth( 0 );
934    m_cPPS.setMinCuDQPSize( m_cPPS.getSPS()->getMaxCUWidth() >> ( m_cPPS.getMaxCuDQPDepth()) );
935  } 
936#endif
937
938  m_cPPS.setChromaCbQpOffset( m_chromaCbQpOffset );
939  m_cPPS.setChromaCrQpOffset( m_chromaCrQpOffset );
940
941  m_cPPS.setNumSubstreams(m_iWaveFrontSubstreams);
942  m_cPPS.setEntropyCodingSyncEnabledFlag( m_iWaveFrontSynchro > 0 );
943  m_cPPS.setTilesEnabledFlag( (m_iNumColumnsMinus1 > 0 || m_iNumRowsMinus1 > 0) );
944  m_cPPS.setUseWP( m_useWeightedPred );
945  m_cPPS.setWPBiPred( m_useWeightedBiPred );
946  m_cPPS.setOutputFlagPresentFlag( false );
947#if H_MV
948#if H_MV_6_RALS_O0149_11
949  m_cPPS.setNumExtraSliceHeaderBits( 3 ); 
950#else
951  m_cPPS.setNumExtraSliceHeaderBits( 2 ); 
952#endif
953#endif
954  m_cPPS.setSignHideFlag(getSignHideFlag());
955  if ( getDeblockingFilterMetric() )
956  {
957    m_cPPS.setDeblockingFilterControlPresentFlag (true);
958    m_cPPS.setDeblockingFilterOverrideEnabledFlag(true);
959    m_cPPS.setPicDisableDeblockingFilterFlag(false);
960    m_cPPS.setDeblockingFilterBetaOffsetDiv2(0);
961    m_cPPS.setDeblockingFilterTcOffsetDiv2(0);
962  } 
963  else
964  {
965    m_cPPS.setDeblockingFilterControlPresentFlag (m_DeblockingFilterControlPresent );
966  }
967  m_cPPS.setLog2ParallelMergeLevelMinus2   (m_log2ParallelMergeLevelMinus2 );
968  m_cPPS.setCabacInitPresentFlag(CABAC_INIT_PRESENT_FLAG);
969  m_cPPS.setLoopFilterAcrossSlicesEnabledFlag( m_bLFCrossSliceBoundaryFlag );
970  Int histogram[MAX_NUM_REF + 1];
971  for( Int i = 0; i <= MAX_NUM_REF; i++ )
972  {
973    histogram[i]=0;
974  }
975  for( Int i = 0; i < getGOPSize(); i++ )
976  {
977    assert(getGOPEntry(i).m_numRefPicsActive >= 0 && getGOPEntry(i).m_numRefPicsActive <= MAX_NUM_REF);
978    histogram[getGOPEntry(i).m_numRefPicsActive]++;
979  }
980  Int maxHist=-1;
981  Int bestPos=0;
982  for( Int i = 0; i <= MAX_NUM_REF; i++ )
983  {
984    if(histogram[i]>maxHist)
985    {
986      maxHist=histogram[i];
987      bestPos=i;
988    }
989  }
990  assert(bestPos <= 15);
991  m_cPPS.setNumRefIdxL0DefaultActive(bestPos);
992  m_cPPS.setNumRefIdxL1DefaultActive(bestPos);
993  m_cPPS.setTransquantBypassEnableFlag(getTransquantBypassEnableFlag());
994  m_cPPS.setUseTransformSkip( m_useTransformSkip );
995  if (m_sliceSegmentMode)
996  {
997    m_cPPS.setDependentSliceSegmentsEnabledFlag( true );
998  }
999  if( m_cPPS.getDependentSliceSegmentsEnabledFlag() )
1000  {
1001    Int NumCtx = m_cPPS.getEntropyCodingSyncEnabledFlag()?2:1;
1002    m_cSliceEncoder.initCtxMem( NumCtx );
1003    for ( UInt st = 0; st < NumCtx; st++ )
1004    {
1005      TEncSbac* ctx = NULL;
1006      ctx = new TEncSbac;
1007      ctx->init( &m_cBinCoderCABAC );
1008      m_cSliceEncoder.setCtxMem( ctx, st );
1009    }
1010  }
1011#if H_3D
1012  if( m_cSPS.hasCamParInSliceHeader() )
1013  {
1014    m_cPPS.setSliceHeaderExtensionPresentFlag( true ); 
1015  }
1016#endif
1017}
1018
1019//Function for initializing m_RPSList, a list of TComReferencePictureSet, based on the GOPEntry objects read from the config file.
1020Void TEncTop::xInitRPS(Bool isFieldCoding)
1021{
1022  TComReferencePictureSet*      rps;
1023 
1024  m_cSPS.createRPSList(getGOPSize()+m_extraRPSs+1);
1025  TComRPSList* rpsList = m_cSPS.getRPSList();
1026
1027  for( Int i = 0; i < getGOPSize()+m_extraRPSs; i++) 
1028  {
1029    GOPEntry ge = getGOPEntry(i);
1030    rps = rpsList->getReferencePictureSet(i);
1031    rps->setNumberOfPictures(ge.m_numRefPics);
1032    rps->setNumRefIdc(ge.m_numRefIdc);
1033    Int numNeg = 0;
1034    Int numPos = 0;
1035    for( Int j = 0; j < ge.m_numRefPics; j++)
1036    {
1037      rps->setDeltaPOC(j,ge.m_referencePics[j]);
1038      rps->setUsed(j,ge.m_usedByCurrPic[j]);
1039      if(ge.m_referencePics[j]>0)
1040      {
1041        numPos++;
1042      }
1043      else
1044      {
1045        numNeg++;
1046      }
1047    }
1048    rps->setNumberOfNegativePictures(numNeg);
1049    rps->setNumberOfPositivePictures(numPos);
1050
1051    // handle inter RPS intialization from the config file.
1052#if AUTO_INTER_RPS
1053    rps->setInterRPSPrediction(ge.m_interRPSPrediction > 0);  // not very clean, converting anything > 0 to true.
1054    rps->setDeltaRIdxMinus1(0);                               // index to the Reference RPS is always the previous one.
1055    TComReferencePictureSet*     RPSRef = rpsList->getReferencePictureSet(i-1);  // get the reference RPS
1056
1057    if (ge.m_interRPSPrediction == 2)  // Automatic generation of the inter RPS idc based on the RIdx provided.
1058    {
1059      Int deltaRPS = getGOPEntry(i-1).m_POC - ge.m_POC;  // the ref POC - current POC
1060      Int numRefDeltaPOC = RPSRef->getNumberOfPictures();
1061
1062      rps->setDeltaRPS(deltaRPS);           // set delta RPS
1063      rps->setNumRefIdc(numRefDeltaPOC+1);  // set the numRefIdc to the number of pictures in the reference RPS + 1.
1064      Int count=0;
1065      for (Int j = 0; j <= numRefDeltaPOC; j++ ) // cycle through pics in reference RPS.
1066      {
1067        Int RefDeltaPOC = (j<numRefDeltaPOC)? RPSRef->getDeltaPOC(j): 0;  // if it is the last decoded picture, set RefDeltaPOC = 0
1068        rps->setRefIdc(j, 0);
1069        for (Int k = 0; k < rps->getNumberOfPictures(); k++ )  // cycle through pics in current RPS.
1070        {
1071          if (rps->getDeltaPOC(k) == ( RefDeltaPOC + deltaRPS))  // if the current RPS has a same picture as the reference RPS.
1072          {
1073              rps->setRefIdc(j, (rps->getUsed(k)?1:2));
1074              count++;
1075              break;
1076          }
1077        }
1078      }
1079      if (count != rps->getNumberOfPictures())
1080      {
1081        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");
1082        rps->setInterRPSPrediction(0);
1083      }
1084    }
1085    else if (ge.m_interRPSPrediction == 1)  // inter RPS idc based on the RefIdc values provided in config file.
1086    {
1087      rps->setDeltaRPS(ge.m_deltaRPS);
1088      rps->setNumRefIdc(ge.m_numRefIdc);
1089      for (Int j = 0; j < ge.m_numRefIdc; j++ )
1090      {
1091        rps->setRefIdc(j, ge.m_refIdc[j]);
1092      }
1093#if WRITE_BACK
1094      // the folowing code overwrite the deltaPOC and Used by current values read from the config file with the ones
1095      // computed from the RefIdc.  A warning is printed if they are not identical.
1096      numNeg = 0;
1097      numPos = 0;
1098      TComReferencePictureSet      RPSTemp;  // temporary variable
1099
1100      for (Int j = 0; j < ge.m_numRefIdc; j++ )
1101      {
1102        if (ge.m_refIdc[j])
1103        {
1104          Int deltaPOC = ge.m_deltaRPS + ((j < RPSRef->getNumberOfPictures())? RPSRef->getDeltaPOC(j) : 0);
1105          RPSTemp.setDeltaPOC((numNeg+numPos),deltaPOC);
1106          RPSTemp.setUsed((numNeg+numPos),ge.m_refIdc[j]==1?1:0);
1107          if (deltaPOC<0)
1108          {
1109            numNeg++;
1110          }
1111          else
1112          {
1113            numPos++;
1114          }
1115        }
1116      }
1117      if (numNeg != rps->getNumberOfNegativePictures())
1118      {
1119        printf("Warning: number of negative pictures in RPS is different between intra and inter RPS specified in the config file.\n");
1120        rps->setNumberOfNegativePictures(numNeg);
1121        rps->setNumberOfPictures(numNeg+numPos);
1122      }
1123      if (numPos != rps->getNumberOfPositivePictures())
1124      {
1125        printf("Warning: number of positive pictures in RPS is different between intra and inter RPS specified in the config file.\n");
1126        rps->setNumberOfPositivePictures(numPos);
1127        rps->setNumberOfPictures(numNeg+numPos);
1128      }
1129      RPSTemp.setNumberOfPictures(numNeg+numPos);
1130      RPSTemp.setNumberOfNegativePictures(numNeg);
1131      RPSTemp.sortDeltaPOC();     // sort the created delta POC before comparing
1132      // check if Delta POC and Used are the same
1133      // print warning if they are not.
1134      for (Int j = 0; j < ge.m_numRefIdc; j++ )
1135      {
1136        if (RPSTemp.getDeltaPOC(j) != rps->getDeltaPOC(j))
1137        {
1138          printf("Warning: delta POC is different between intra RPS and inter RPS specified in the config file.\n");
1139          rps->setDeltaPOC(j,RPSTemp.getDeltaPOC(j));
1140        }
1141        if (RPSTemp.getUsed(j) != rps->getUsed(j))
1142        {
1143          printf("Warning: Used by Current in RPS is different between intra and inter RPS specified in the config file.\n");
1144          rps->setUsed(j,RPSTemp.getUsed(j));
1145        }
1146      }
1147#endif
1148    }
1149#else
1150    rps->setInterRPSPrediction(ge.m_interRPSPrediction);
1151    if (ge.m_interRPSPrediction)
1152    {
1153      rps->setDeltaRIdxMinus1(0);
1154      rps->setDeltaRPS(ge.m_deltaRPS);
1155      rps->setNumRefIdc(ge.m_numRefIdc);
1156      for (Int j = 0; j < ge.m_numRefIdc; j++ )
1157      {
1158        rps->setRefIdc(j, ge.m_refIdc[j]);
1159      }
1160#if WRITE_BACK
1161      // the folowing code overwrite the deltaPOC and Used by current values read from the config file with the ones
1162      // computed from the RefIdc.  This is not necessary if both are identical. Currently there is no check to see if they are identical.
1163      numNeg = 0;
1164      numPos = 0;
1165      TComReferencePictureSet*     RPSRef = m_RPSList.getReferencePictureSet(i-1);
1166
1167      for (Int j = 0; j < ge.m_numRefIdc; j++ )
1168      {
1169        if (ge.m_refIdc[j])
1170        {
1171          Int deltaPOC = ge.m_deltaRPS + ((j < RPSRef->getNumberOfPictures())? RPSRef->getDeltaPOC(j) : 0);
1172          rps->setDeltaPOC((numNeg+numPos),deltaPOC);
1173          rps->setUsed((numNeg+numPos),ge.m_refIdc[j]==1?1:0);
1174          if (deltaPOC<0)
1175          {
1176            numNeg++;
1177          }
1178          else
1179          {
1180            numPos++;
1181          }
1182        }
1183      }
1184      rps->setNumberOfNegativePictures(numNeg);
1185      rps->setNumberOfPositivePictures(numPos);
1186      rps->sortDeltaPOC();
1187#endif
1188    }
1189#endif //INTER_RPS_AUTO
1190  }
1191  //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.
1192  //The position = GOPSize + extraRPSs which is (a priori) unused is reserved for this field in the RPS.
1193  if (isFieldCoding) 
1194  {
1195    rps = rpsList->getReferencePictureSet(getGOPSize()+m_extraRPSs);
1196    rps->setNumberOfPictures(1);
1197    rps->setNumberOfNegativePictures(1);
1198    rps->setNumberOfPositivePictures(0);
1199    rps->setNumberOfLongtermPictures(0);
1200    rps->setDeltaPOC(0,-1);
1201    rps->setPOC(0,0);
1202    rps->setUsed(0,true);
1203    rps->setInterRPSPrediction(false);
1204    rps->setDeltaRIdxMinus1(0);
1205    rps->setDeltaRPS(0);
1206    rps->setNumRefIdc(0);
1207}
1208}
1209
1210   // This is a function that
1211   // determines what Reference Picture Set to use
1212   // for a specific slice (with POC = POCCurr)
1213Void TEncTop::selectReferencePictureSet(TComSlice* slice, Int POCCurr, Int GOPid )
1214{
1215#if H_MV
1216  if( slice->getRapPicFlag() == true && getLayerId() > 0 && POCCurr == 0 )
1217  {
1218    TComReferencePictureSet* rps = slice->getLocalRPS();
1219    rps->setNumberOfNegativePictures(0);
1220    rps->setNumberOfPositivePictures(0);
1221    rps->setNumberOfLongtermPictures(0);
1222    rps->setNumberOfPictures(0);
1223    slice->setRPS(rps);
1224  }
1225  else
1226  {
1227#endif
1228  slice->setRPSidx(GOPid);
1229
1230  for(Int extraNum=m_iGOPSize; extraNum<m_extraRPSs+m_iGOPSize; extraNum++)
1231  {   
1232    if(m_uiIntraPeriod > 0 && getDecodingRefreshType() > 0)
1233    {
1234      Int POCIndex = POCCurr%m_uiIntraPeriod;
1235      if(POCIndex == 0)
1236      {
1237        POCIndex = m_uiIntraPeriod;
1238      }
1239      if(POCIndex == m_GOPList[extraNum].m_POC)
1240      {
1241        slice->setRPSidx(extraNum);
1242      }
1243    }
1244    else
1245    {
1246      if(POCCurr==m_GOPList[extraNum].m_POC)
1247      {
1248        slice->setRPSidx(extraNum);
1249      }
1250    }
1251  }
1252  if(POCCurr == 1 && slice->getPic()->isField())
1253  {
1254    slice->setRPSidx(m_iGOPSize+m_extraRPSs);
1255  }
1256
1257  slice->setRPS(getSPS()->getRPSList()->getReferencePictureSet(slice->getRPSidx()));
1258  slice->getRPS()->setNumberOfPictures(slice->getRPS()->getNumberOfNegativePictures()+slice->getRPS()->getNumberOfPositivePictures());
1259#if H_MV
1260  }
1261#endif
1262
1263}
1264
1265Int TEncTop::getReferencePictureSetIdxForSOP(TComSlice* slice, Int POCCurr, Int GOPid )
1266{
1267  int rpsIdx = GOPid;
1268
1269  for(Int extraNum=m_iGOPSize; extraNum<m_extraRPSs+m_iGOPSize; extraNum++)
1270  {   
1271    if(m_uiIntraPeriod > 0 && getDecodingRefreshType() > 0)
1272    {
1273      Int POCIndex = POCCurr%m_uiIntraPeriod;
1274      if(POCIndex == 0)
1275      {
1276        POCIndex = m_uiIntraPeriod;
1277      }
1278      if(POCIndex == m_GOPList[extraNum].m_POC)
1279      {
1280        rpsIdx = extraNum;
1281      }
1282    }
1283    else
1284    {
1285      if(POCCurr==m_GOPList[extraNum].m_POC)
1286      {
1287        rpsIdx = extraNum;
1288      }
1289    }
1290  }
1291
1292  return rpsIdx;
1293}
1294
1295Void  TEncTop::xInitPPSforTiles()
1296{
1297  m_cPPS.setUniformSpacingFlag( m_iUniformSpacingIdr );
1298  m_cPPS.setNumColumnsMinus1( m_iNumColumnsMinus1 );
1299  m_cPPS.setNumRowsMinus1( m_iNumRowsMinus1 );
1300  if( m_iUniformSpacingIdr == 0 )
1301  {
1302    m_cPPS.setColumnWidth( m_puiColumnWidth );
1303    m_cPPS.setRowHeight( m_puiRowHeight );
1304  }
1305  m_cPPS.setLoopFilterAcrossTilesEnabledFlag( m_loopFilterAcrossTilesEnabledFlag );
1306
1307  // # substreams is "per tile" when tiles are independent.
1308  if (m_iWaveFrontSynchro
1309    )
1310  {
1311    m_cPPS.setNumSubstreams(m_iWaveFrontSubstreams * (m_iNumColumnsMinus1+1));
1312  }
1313}
1314
1315Void  TEncCfg::xCheckGSParameters()
1316{
1317  Int   iWidthInCU = ( m_iSourceWidth%g_uiMaxCUWidth ) ? m_iSourceWidth/g_uiMaxCUWidth + 1 : m_iSourceWidth/g_uiMaxCUWidth;
1318  Int   iHeightInCU = ( m_iSourceHeight%g_uiMaxCUHeight ) ? m_iSourceHeight/g_uiMaxCUHeight + 1 : m_iSourceHeight/g_uiMaxCUHeight;
1319  UInt  uiCummulativeColumnWidth = 0;
1320  UInt  uiCummulativeRowHeight = 0;
1321
1322  //check the column relative parameters
1323  if( m_iNumColumnsMinus1 >= (1<<(LOG2_MAX_NUM_COLUMNS_MINUS1+1)) )
1324  {
1325    printf( "The number of columns is larger than the maximum allowed number of columns.\n" );
1326    exit( EXIT_FAILURE );
1327  }
1328
1329  if( m_iNumColumnsMinus1 >= iWidthInCU )
1330  {
1331    printf( "The current picture can not have so many columns.\n" );
1332    exit( EXIT_FAILURE );
1333  }
1334
1335  if( m_iNumColumnsMinus1 && m_iUniformSpacingIdr==0 )
1336  {
1337    for(Int i=0; i<m_iNumColumnsMinus1; i++)
1338    {
1339      uiCummulativeColumnWidth += m_puiColumnWidth[i];
1340    }
1341
1342    if( uiCummulativeColumnWidth >= iWidthInCU )
1343    {
1344      printf( "The width of the column is too large.\n" );
1345      exit( EXIT_FAILURE );
1346    }
1347  }
1348
1349  //check the row relative parameters
1350  if( m_iNumRowsMinus1 >= (1<<(LOG2_MAX_NUM_ROWS_MINUS1+1)) )
1351  {
1352    printf( "The number of rows is larger than the maximum allowed number of rows.\n" );
1353    exit( EXIT_FAILURE );
1354  }
1355
1356  if( m_iNumRowsMinus1 >= iHeightInCU )
1357  {
1358    printf( "The current picture can not have so many rows.\n" );
1359    exit( EXIT_FAILURE );
1360  }
1361
1362  if( m_iNumRowsMinus1 && m_iUniformSpacingIdr==0 )
1363  {
1364    for(Int i=0; i<m_iNumRowsMinus1; i++)
1365      uiCummulativeRowHeight += m_puiRowHeight[i];
1366
1367    if( uiCummulativeRowHeight >= iHeightInCU )
1368    {
1369      printf( "The height of the row is too large.\n" );
1370      exit( EXIT_FAILURE );
1371    }
1372  }
1373}
1374#if H_MV
1375Void TEncTop::printSummary( Int numAllPicCoded, Bool isField )
1376{
1377  assert ( !isField ); // Multiview and field coding need to be further unified
1378  assert (numAllPicCoded == m_cAnalyzeAll.getNumPic());
1379
1380  //--CFG_KDY
1381  m_cAnalyzeAll.setFrmRate( getFrameRate() );
1382  m_cAnalyzeI.setFrmRate( getFrameRate() );
1383  m_cAnalyzeP.setFrmRate( getFrameRate() );
1384  m_cAnalyzeB.setFrmRate( getFrameRate() );
1385
1386  //-- all
1387  printf( "\n\nSUMMARY ------------------------------------------- LayerId %2d\n", m_layerId );
1388
1389  m_cAnalyzeAll.printOut('a');
1390
1391  printf( "\n\nI Slices--------------------------------------------------------\n" );
1392  m_cAnalyzeI.printOut('i');
1393
1394  printf( "\n\nP Slices--------------------------------------------------------\n" );
1395  m_cAnalyzeP.printOut('p');
1396
1397  printf( "\n\nB Slices--------------------------------------------------------\n" );
1398  m_cAnalyzeB.printOut('b');
1399
1400#if _SUMMARY_OUT_
1401  m_cAnalyzeAll.printSummaryOut();
1402#endif
1403#if _SUMMARY_PIC_
1404  m_cAnalyzeI.printSummary('I');
1405  m_cAnalyzeP.printSummary('P');
1406  m_cAnalyzeB.printSummary('B');
1407#endif
1408}
1409
1410Int TEncTop::getFrameId(Int iGOPid) 
1411{
1412  if(m_iPOCLast == 0)
1413  {
1414    return(0 );
1415  }
1416  else
1417  {
1418    return m_iPOCLast -m_iNumPicRcvd+ getGOPEntry(iGOPid).m_POC ;
1419  }
1420}
1421
1422TComPic* TEncTop::getPic( Int poc )
1423{
1424  TComList<TComPic*>* listPic = getListPic();
1425  TComPic* pcPic = NULL;
1426  for(TComList<TComPic*>::iterator it=listPic->begin(); it!=listPic->end(); it++)
1427  {
1428    if( (*it)->getPOC() == poc )
1429    {
1430      pcPic = *it ;
1431      break ;
1432    }
1433  }
1434  return pcPic;
1435}
1436#endif
1437
1438#if H_3D_VSO
1439Void TEncTop::setupRenModel( Int iPoc, Int iEncViewIdx, Int iEncContent, Int iHorOffset )
1440{
1441  TRenModel* rendererModel = m_cRdCost.getRenModel(); 
1442  rendererModel->setupPart( iHorOffset, std::min( (Int) g_uiMaxCUHeight, (Int) ( m_iSourceHeight - iHorOffset ) )) ; 
1443 
1444  Int iEncViewSIdx = m_cameraParameters->getBaseId2SortedId()[ iEncViewIdx ];
1445
1446  // setup base views
1447  Int iNumOfBV = m_renderModelParameters->getNumOfBaseViewsForView( iEncViewSIdx, iEncContent );
1448
1449  for (Int iCurView = 0; iCurView < iNumOfBV; iCurView++ )
1450  {
1451    Int iBaseViewSIdx;
1452    Int iVideoDistMode;
1453    Int iDepthDistMode;
1454
1455    m_renderModelParameters->getBaseViewData( iEncViewSIdx, iEncContent, iCurView, iBaseViewSIdx, iVideoDistMode, iDepthDistMode );
1456
1457    AOT( iVideoDistMode < 0 || iVideoDistMode > 2 );
1458
1459    Int iBaseViewIdx = m_cameraParameters->getBaseSortedId2Id()[ iBaseViewSIdx ];
1460
1461    TComPicYuv* pcPicYuvVideoRec  = m_ivPicLists->getPicYuv( iBaseViewIdx, false, iPoc, true  );
1462    TComPicYuv* pcPicYuvDepthRec  = m_ivPicLists->getPicYuv( iBaseViewIdx, true , iPoc, true  );
1463    TComPicYuv* pcPicYuvVideoOrg  = m_ivPicLists->getPicYuv( iBaseViewIdx, false, iPoc, false );
1464    TComPicYuv* pcPicYuvDepthOrg  = m_ivPicLists->getPicYuv( iBaseViewIdx, true , iPoc, false );   
1465
1466    TComPicYuv* pcPicYuvVideoRef  = ( iVideoDistMode == 2 ) ? pcPicYuvVideoOrg  : NULL;
1467    TComPicYuv* pcPicYuvDepthRef  = ( iDepthDistMode == 2 ) ? pcPicYuvDepthOrg  : NULL;
1468
1469    TComPicYuv* pcPicYuvVideoTest = ( iVideoDistMode == 0 ) ? pcPicYuvVideoOrg  : pcPicYuvVideoRec;
1470    TComPicYuv* pcPicYuvDepthTest = ( iDepthDistMode == 0 ) ? pcPicYuvDepthOrg  : pcPicYuvDepthRec;
1471
1472    AOT( (iVideoDistMode == 2) != (pcPicYuvVideoRef != NULL) );
1473    AOT( (iDepthDistMode == 2) != (pcPicYuvDepthRef != NULL) );
1474    AOT( pcPicYuvDepthTest == NULL );
1475    AOT( pcPicYuvVideoTest == NULL );
1476
1477    rendererModel->setBaseView( iBaseViewSIdx, pcPicYuvVideoTest, pcPicYuvDepthTest, pcPicYuvVideoRef, pcPicYuvDepthRef );
1478  }
1479
1480  rendererModel->setErrorMode( iEncViewSIdx, iEncContent, 0 );
1481  // setup virtual views
1482  Int iNumOfSV  = m_renderModelParameters->getNumOfModelsForView( iEncViewSIdx, iEncContent );
1483  for (Int iCurView = 0; iCurView < iNumOfSV; iCurView++ )
1484  {
1485    Int iOrgRefBaseViewSIdx;
1486    Int iLeftBaseViewSIdx;
1487    Int iRightBaseViewSIdx;
1488    Int iSynthViewRelNum;
1489    Int iModelNum;
1490    Int iBlendMode;
1491    m_renderModelParameters->getSingleModelData(iEncViewSIdx, iEncContent, iCurView, iModelNum, iBlendMode,iLeftBaseViewSIdx, iRightBaseViewSIdx, iOrgRefBaseViewSIdx, iSynthViewRelNum );
1492
1493    Int iLeftBaseViewIdx    = -1;
1494    Int iRightBaseViewIdx   = -1;
1495
1496    TComPicYuv* pcPicYuvOrgRef  = NULL;
1497    Int**      ppiShiftLUTLeft  = NULL;
1498    Int**      ppiShiftLUTRight = NULL;
1499    Int**      ppiBaseShiftLUTLeft  = NULL;
1500    Int**      ppiBaseShiftLUTRight = NULL;
1501
1502
1503    Int        iDistToLeft      = -1;
1504
1505    Int iSynthViewIdx = m_cameraParameters->synthRelNum2Idx( iSynthViewRelNum );
1506
1507    if ( iLeftBaseViewSIdx != -1 )
1508    {
1509      iLeftBaseViewIdx   = m_cameraParameters->getBaseSortedId2Id()   [ iLeftBaseViewSIdx ];
1510      ppiShiftLUTLeft    = m_cameraParameters->getSynthViewShiftLUTI()[ iLeftBaseViewIdx  ][ iSynthViewIdx  ];
1511    }
1512
1513    if ( iRightBaseViewSIdx != -1 )
1514    {
1515      iRightBaseViewIdx  = m_cameraParameters->getBaseSortedId2Id()   [iRightBaseViewSIdx ];
1516      ppiShiftLUTRight   = m_cameraParameters->getSynthViewShiftLUTI()[ iRightBaseViewIdx ][ iSynthViewIdx ];
1517    }
1518
1519    if ( iRightBaseViewSIdx != -1 && iLeftBaseViewSIdx != -1 )
1520    {
1521      iDistToLeft          = m_cameraParameters->getRelDistLeft(  iSynthViewIdx , iLeftBaseViewIdx, iRightBaseViewIdx);
1522      ppiBaseShiftLUTLeft  = m_cameraParameters->getBaseViewShiftLUTI() [ iLeftBaseViewIdx  ][ iRightBaseViewIdx ];
1523      ppiBaseShiftLUTRight = m_cameraParameters->getBaseViewShiftLUTI() [ iRightBaseViewIdx ][ iLeftBaseViewIdx  ];
1524
1525    }
1526
1527    if ( iOrgRefBaseViewSIdx != -1 )
1528    {
1529      pcPicYuvOrgRef = m_ivPicLists->getPicYuv(  m_cameraParameters->getBaseSortedId2Id()[ iOrgRefBaseViewSIdx ] , false, iPoc, false );
1530      AOF ( pcPicYuvOrgRef );
1531    }
1532
1533    rendererModel->setSingleModel( iModelNum, ppiShiftLUTLeft, ppiBaseShiftLUTLeft, ppiShiftLUTRight, ppiBaseShiftLUTRight, iDistToLeft, pcPicYuvOrgRef );
1534  }
1535}
1536#endif
1537//! \}
Note: See TracBrowser for help on using the repository browser.