source: 3DVCSoftware/branches/HTM-8.2-dev0-Cleanup/source/Lib/TLibEncoder/TEncGOP.cpp @ 651

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

Update to HM 12.0.

  • Property svn:eol-style set to native
File size: 122.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     TEncGOP.cpp
35    \brief    GOP encoder class
36*/
37
38#include <list>
39#include <algorithm>
40#include <functional>
41
42#include "TEncTop.h"
43#include "TEncGOP.h"
44#include "TEncAnalyze.h"
45#include "libmd5/MD5.h"
46#include "TLibCommon/SEI.h"
47#include "TLibCommon/NAL.h"
48#include "NALwrite.h"
49#include <time.h>
50#include <math.h>
51
52using namespace std;
53//! \ingroup TLibEncoder
54//! \{
55
56// ====================================================================================================================
57// Constructor / destructor / initialization / destroy
58// ====================================================================================================================
59Int getLSB(Int poc, Int maxLSB)
60{
61  if (poc >= 0)
62  {
63    return poc % maxLSB;
64  }
65  else
66  {
67    return (maxLSB - ((-poc) % maxLSB)) % maxLSB;
68  }
69}
70
71TEncGOP::TEncGOP()
72{
73  m_iLastIDR            = 0;
74  m_iGopSize            = 0;
75  m_iNumPicCoded        = 0; //Niko
76  m_bFirst              = true;
77 
78  m_pcCfg               = NULL;
79  m_pcSliceEncoder      = NULL;
80  m_pcListPic           = NULL;
81 
82  m_pcEntropyCoder      = NULL;
83  m_pcCavlcCoder        = NULL;
84  m_pcSbacCoder         = NULL;
85  m_pcBinCABAC          = NULL;
86 
87  m_bSeqFirst           = true;
88 
89  m_bRefreshPending     = 0;
90  m_pocCRA            = 0;
91  m_numLongTermRefPicSPS = 0;
92  ::memset(m_ltRefPicPocLsbSps, 0, sizeof(m_ltRefPicPocLsbSps));
93  ::memset(m_ltRefPicUsedByCurrPicFlag, 0, sizeof(m_ltRefPicUsedByCurrPicFlag));
94  m_cpbRemovalDelay   = 0;
95  m_lastBPSEI         = 0;
96  xResetNonNestedSEIPresentFlags();
97  xResetNestedSEIPresentFlags();
98#if H_MV
99  m_layerId      = 0;
100  m_viewId       = 0;
101  m_pocLastCoded = -1; 
102#if H_3D
103  m_viewIndex  =   0; 
104  m_isDepth = false;
105#endif
106#endif
107  return;
108}
109
110TEncGOP::~TEncGOP()
111{
112}
113
114/** Create list to contain pointers to LCU start addresses of slice.
115 */
116Void  TEncGOP::create()
117{
118  m_bLongtermTestPictureHasBeenCoded = 0;
119  m_bLongtermTestPictureHasBeenCoded2 = 0;
120}
121
122Void  TEncGOP::destroy()
123{
124}
125
126Void TEncGOP::init ( TEncTop* pcTEncTop )
127{
128  m_pcEncTop     = pcTEncTop;
129  m_pcCfg                = pcTEncTop;
130  m_pcSliceEncoder       = pcTEncTop->getSliceEncoder();
131  m_pcListPic            = pcTEncTop->getListPic();
132 
133  m_pcEntropyCoder       = pcTEncTop->getEntropyCoder();
134  m_pcCavlcCoder         = pcTEncTop->getCavlcCoder();
135  m_pcSbacCoder          = pcTEncTop->getSbacCoder();
136  m_pcBinCABAC           = pcTEncTop->getBinCABAC();
137  m_pcLoopFilter         = pcTEncTop->getLoopFilter();
138  m_pcBitCounter         = pcTEncTop->getBitCounter();
139 
140  //--Adaptive Loop filter
141  m_pcSAO                = pcTEncTop->getSAO();
142  m_pcRateCtrl           = pcTEncTop->getRateCtrl();
143  m_lastBPSEI          = 0;
144  m_totalCoded         = 0;
145
146#if H_MV
147  m_ivPicLists           = pcTEncTop->getIvPicLists(); 
148  m_layerId              = pcTEncTop->getLayerId();
149  m_viewId               = pcTEncTop->getViewId();
150#if H_3D
151  m_viewIndex            = pcTEncTop->getViewIndex();
152  m_isDepth              = pcTEncTop->getIsDepth();
153#endif
154#endif
155
156#if KWU_FIX_URQ
157  m_pcRateCtrl           = pcTEncTop->getRateCtrl();
158#endif
159}
160
161SEIActiveParameterSets* TEncGOP::xCreateSEIActiveParameterSets (TComSPS *sps)
162{
163  SEIActiveParameterSets *seiActiveParameterSets = new SEIActiveParameterSets(); 
164  seiActiveParameterSets->activeVPSId = m_pcCfg->getVPS()->getVPSId(); 
165  seiActiveParameterSets->m_fullRandomAccessFlag = false;
166  seiActiveParameterSets->m_noParamSetUpdateFlag = false;
167  seiActiveParameterSets->numSpsIdsMinus1 = 0;
168  seiActiveParameterSets->activeSeqParamSetId.resize(seiActiveParameterSets->numSpsIdsMinus1 + 1); 
169  seiActiveParameterSets->activeSeqParamSetId[0] = sps->getSPSId();
170  return seiActiveParameterSets;
171}
172
173SEIFramePacking* TEncGOP::xCreateSEIFramePacking()
174{
175  SEIFramePacking *seiFramePacking = new SEIFramePacking();
176  seiFramePacking->m_arrangementId = m_pcCfg->getFramePackingArrangementSEIId();
177  seiFramePacking->m_arrangementCancelFlag = 0;
178  seiFramePacking->m_arrangementType = m_pcCfg->getFramePackingArrangementSEIType();
179  assert((seiFramePacking->m_arrangementType > 2) && (seiFramePacking->m_arrangementType < 6) );
180  seiFramePacking->m_quincunxSamplingFlag = m_pcCfg->getFramePackingArrangementSEIQuincunx();
181  seiFramePacking->m_contentInterpretationType = m_pcCfg->getFramePackingArrangementSEIInterpretation();
182  seiFramePacking->m_spatialFlippingFlag = 0;
183  seiFramePacking->m_frame0FlippedFlag = 0;
184  seiFramePacking->m_fieldViewsFlag = (seiFramePacking->m_arrangementType == 2);
185  seiFramePacking->m_currentFrameIsFrame0Flag = ((seiFramePacking->m_arrangementType == 5) && m_iNumPicCoded&1);
186  seiFramePacking->m_frame0SelfContainedFlag = 0;
187  seiFramePacking->m_frame1SelfContainedFlag = 0;
188  seiFramePacking->m_frame0GridPositionX = 0;
189  seiFramePacking->m_frame0GridPositionY = 0;
190  seiFramePacking->m_frame1GridPositionX = 0;
191  seiFramePacking->m_frame1GridPositionY = 0;
192  seiFramePacking->m_arrangementReservedByte = 0;
193  seiFramePacking->m_arrangementPersistenceFlag = true;
194  seiFramePacking->m_upsampledAspectRatio = 0;
195  return seiFramePacking;
196}
197
198SEIDisplayOrientation* TEncGOP::xCreateSEIDisplayOrientation()
199{
200  SEIDisplayOrientation *seiDisplayOrientation = new SEIDisplayOrientation();
201  seiDisplayOrientation->cancelFlag = false;
202  seiDisplayOrientation->horFlip = false;
203  seiDisplayOrientation->verFlip = false;
204  seiDisplayOrientation->anticlockwiseRotation = m_pcCfg->getDisplayOrientationSEIAngle();
205  return seiDisplayOrientation;
206}
207
208SEIToneMappingInfo*  TEncGOP::xCreateSEIToneMappingInfo()
209{
210  SEIToneMappingInfo *seiToneMappingInfo = new SEIToneMappingInfo();
211  seiToneMappingInfo->m_toneMapId = m_pcCfg->getTMISEIToneMapId();
212  seiToneMappingInfo->m_toneMapCancelFlag = m_pcCfg->getTMISEIToneMapCancelFlag();
213  seiToneMappingInfo->m_toneMapPersistenceFlag = m_pcCfg->getTMISEIToneMapPersistenceFlag();
214
215  seiToneMappingInfo->m_codedDataBitDepth = m_pcCfg->getTMISEICodedDataBitDepth();
216  assert(seiToneMappingInfo->m_codedDataBitDepth >= 8 && seiToneMappingInfo->m_codedDataBitDepth <= 14);
217  seiToneMappingInfo->m_targetBitDepth = m_pcCfg->getTMISEITargetBitDepth();
218  assert( seiToneMappingInfo->m_targetBitDepth >= 1 && seiToneMappingInfo->m_targetBitDepth <= 17 );
219  seiToneMappingInfo->m_modelId = m_pcCfg->getTMISEIModelID();
220  assert(seiToneMappingInfo->m_modelId >=0 &&seiToneMappingInfo->m_modelId<=4);
221
222  switch( seiToneMappingInfo->m_modelId)
223  {
224  case 0:
225    {
226      seiToneMappingInfo->m_minValue = m_pcCfg->getTMISEIMinValue();
227      seiToneMappingInfo->m_maxValue = m_pcCfg->getTMISEIMaxValue();
228      break;
229    }
230  case 1:
231    {
232      seiToneMappingInfo->m_sigmoidMidpoint = m_pcCfg->getTMISEISigmoidMidpoint();
233      seiToneMappingInfo->m_sigmoidWidth = m_pcCfg->getTMISEISigmoidWidth();
234      break;
235    }
236  case 2:
237    {
238      UInt num = 1u<<(seiToneMappingInfo->m_targetBitDepth);
239      seiToneMappingInfo->m_startOfCodedInterval.resize(num);
240      Int* ptmp = m_pcCfg->getTMISEIStartOfCodedInterva();
241      if(ptmp)
242      {
243        for(int i=0; i<num;i++)
244        {
245          seiToneMappingInfo->m_startOfCodedInterval[i] = ptmp[i];
246        }
247      }
248      break;
249    }
250  case 3:
251    {
252      seiToneMappingInfo->m_numPivots = m_pcCfg->getTMISEINumPivots();
253      seiToneMappingInfo->m_codedPivotValue.resize(seiToneMappingInfo->m_numPivots);
254      seiToneMappingInfo->m_targetPivotValue.resize(seiToneMappingInfo->m_numPivots);
255      Int* ptmpcoded = m_pcCfg->getTMISEICodedPivotValue();
256      Int* ptmptarget = m_pcCfg->getTMISEITargetPivotValue();
257      if(ptmpcoded&&ptmptarget)
258      {
259        for(int i=0; i<(seiToneMappingInfo->m_numPivots);i++)
260        {
261          seiToneMappingInfo->m_codedPivotValue[i]=ptmpcoded[i];
262          seiToneMappingInfo->m_targetPivotValue[i]=ptmptarget[i];
263         }
264       }
265       break;
266     }
267  case 4:
268     {
269       seiToneMappingInfo->m_cameraIsoSpeedIdc = m_pcCfg->getTMISEICameraIsoSpeedIdc();
270       seiToneMappingInfo->m_cameraIsoSpeedValue = m_pcCfg->getTMISEICameraIsoSpeedValue();
271       assert( seiToneMappingInfo->m_cameraIsoSpeedValue !=0 );
272       seiToneMappingInfo->m_exposureCompensationValueSignFlag = m_pcCfg->getTMISEIExposureCompensationValueSignFlag();
273       seiToneMappingInfo->m_exposureCompensationValueNumerator = m_pcCfg->getTMISEIExposureCompensationValueNumerator();
274       seiToneMappingInfo->m_exposureCompensationValueDenomIdc = m_pcCfg->getTMISEIExposureCompensationValueDenomIdc();
275       seiToneMappingInfo->m_refScreenLuminanceWhite = m_pcCfg->getTMISEIRefScreenLuminanceWhite();
276       seiToneMappingInfo->m_extendedRangeWhiteLevel = m_pcCfg->getTMISEIExtendedRangeWhiteLevel();
277       assert( seiToneMappingInfo->m_extendedRangeWhiteLevel >= 100 );
278       seiToneMappingInfo->m_nominalBlackLevelLumaCodeValue = m_pcCfg->getTMISEINominalBlackLevelLumaCodeValue();
279       seiToneMappingInfo->m_nominalWhiteLevelLumaCodeValue = m_pcCfg->getTMISEINominalWhiteLevelLumaCodeValue();
280       assert( seiToneMappingInfo->m_nominalWhiteLevelLumaCodeValue > seiToneMappingInfo->m_nominalBlackLevelLumaCodeValue );
281       seiToneMappingInfo->m_extendedWhiteLevelLumaCodeValue = m_pcCfg->getTMISEIExtendedWhiteLevelLumaCodeValue();
282       assert( seiToneMappingInfo->m_extendedWhiteLevelLumaCodeValue >= seiToneMappingInfo->m_nominalWhiteLevelLumaCodeValue );
283       break;
284    }
285  default:
286    {
287      assert(!"Undefined SEIToneMapModelId");
288      break;
289    }
290  }
291  return seiToneMappingInfo;
292}
293
294Void TEncGOP::xCreateLeadingSEIMessages (/*SEIMessages seiMessages,*/ AccessUnit &accessUnit, TComSPS *sps)
295{
296  OutputNALUnit nalu(NAL_UNIT_PREFIX_SEI);
297
298  if(m_pcCfg->getActiveParameterSetsSEIEnabled())
299  {
300    SEIActiveParameterSets *sei = xCreateSEIActiveParameterSets (sps);
301
302    //nalu = NALUnit(NAL_UNIT_SEI);
303    m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
304    m_seiWriter.writeSEImessage(nalu.m_Bitstream, *sei, sps); 
305    writeRBSPTrailingBits(nalu.m_Bitstream);
306    accessUnit.push_back(new NALUnitEBSP(nalu));
307    delete sei;
308    m_activeParameterSetSEIPresentInAU = true;
309  }
310
311  if(m_pcCfg->getFramePackingArrangementSEIEnabled())
312  {
313    SEIFramePacking *sei = xCreateSEIFramePacking ();
314
315    nalu = NALUnit(NAL_UNIT_PREFIX_SEI);
316    m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
317    m_seiWriter.writeSEImessage(nalu.m_Bitstream, *sei, sps);
318    writeRBSPTrailingBits(nalu.m_Bitstream);
319    accessUnit.push_back(new NALUnitEBSP(nalu));
320    delete sei;
321  }
322  if (m_pcCfg->getDisplayOrientationSEIAngle())
323  {
324    SEIDisplayOrientation *sei = xCreateSEIDisplayOrientation();
325
326    nalu = NALUnit(NAL_UNIT_PREFIX_SEI); 
327    m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
328    m_seiWriter.writeSEImessage(nalu.m_Bitstream, *sei, sps); 
329    writeRBSPTrailingBits(nalu.m_Bitstream);
330    accessUnit.push_back(new NALUnitEBSP(nalu));
331    delete sei;
332  }
333  if(m_pcCfg->getToneMappingInfoSEIEnabled())
334  {
335    SEIToneMappingInfo *sei = xCreateSEIToneMappingInfo ();
336     
337    nalu = NALUnit(NAL_UNIT_PREFIX_SEI); 
338    m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
339    m_seiWriter.writeSEImessage(nalu.m_Bitstream, *sei, sps); 
340    writeRBSPTrailingBits(nalu.m_Bitstream);
341    accessUnit.push_back(new NALUnitEBSP(nalu));
342    delete sei;
343  }
344}
345
346// ====================================================================================================================
347// Public member functions
348// ====================================================================================================================
349#if H_MV
350Void TEncGOP::initGOP( Int iPOCLast, Int iNumPicRcvd, TComList<TComPic*>& rcListPic, TComList<TComPicYuv*>& rcListPicYuvRecOut, std::list<AccessUnit>& accessUnitsInGOP)
351{
352  xInitGOP( iPOCLast, iNumPicRcvd, rcListPic, rcListPicYuvRecOut );
353  m_iNumPicCoded = 0;
354}
355#endif
356#if H_MV
357Void TEncGOP::compressPicInGOP( Int iPOCLast, Int iNumPicRcvd, TComList<TComPic*>& rcListPic, TComList<TComPicYuv*>& rcListPicYuvRecOut, std::list<AccessUnit>& accessUnitsInGOP, Int iGOPid, bool isField, bool isTff)
358#else
359Void TEncGOP::compressGOP( Int iPOCLast, Int iNumPicRcvd, TComList<TComPic*>& rcListPic, TComList<TComPicYuv*>& rcListPicYuvRecOut, std::list<AccessUnit>& accessUnitsInGOP, bool isField, bool isTff)
360#endif
361{
362  TComPic*        pcPic;
363  TComPicYuv*     pcPicYuvRecOut;
364  TComSlice*      pcSlice;
365  TComOutputBitstream  *pcBitstreamRedirect;
366  pcBitstreamRedirect = new TComOutputBitstream;
367  AccessUnit::iterator  itLocationToPushSliceHeaderNALU; // used to store location where NALU containing slice header is to be inserted
368  UInt                  uiOneBitstreamPerSliceLength = 0;
369  TEncSbac* pcSbacCoders = NULL;
370  TComOutputBitstream* pcSubstreamsOut = NULL;
371
372#if !H_MV
373  xInitGOP( iPOCLast, iNumPicRcvd, rcListPic, rcListPicYuvRecOut, isField );
374
375 
376  m_iNumPicCoded = 0;
377#endif
378  SEIPictureTiming pictureTimingSEI;
379  Bool writeSOP = m_pcCfg->getSOPDescriptionSEIEnabled();
380  // Initialize Scalable Nesting SEI with single layer values
381  SEIScalableNesting scalableNestingSEI;
382  scalableNestingSEI.m_bitStreamSubsetFlag           = 1;      // If the nested SEI messages are picture buffereing SEI mesages, picure timing SEI messages or sub-picture timing SEI messages, bitstream_subset_flag shall be equal to 1
383  scalableNestingSEI.m_nestingOpFlag                 = 0;
384  scalableNestingSEI.m_nestingNumOpsMinus1           = 0;      //nesting_num_ops_minus1
385  scalableNestingSEI.m_allLayersFlag                 = 0;
386  scalableNestingSEI.m_nestingNoOpMaxTemporalIdPlus1 = 6 + 1;  //nesting_no_op_max_temporal_id_plus1
387  scalableNestingSEI.m_nestingNumLayersMinus1        = 1 - 1;  //nesting_num_layers_minus1
388  scalableNestingSEI.m_nestingLayerId[0]             = 0;
389  scalableNestingSEI.m_callerOwnsSEIs                = true;
390  Int picSptDpbOutputDuDelay = 0;
391  UInt *accumBitsDU = NULL;
392  UInt *accumNalsDU = NULL;
393  SEIDecodingUnitInfo decodingUnitInfoSEI;
394#if !H_MV
395  for ( Int iGOPid=0; iGOPid < m_iGopSize; iGOPid++ )
396#endif
397  {
398    UInt uiColDir = 1;
399    //-- For time output for each slice
400    long iBeforeTime = clock();
401
402    //select uiColDir
403    Int iCloseLeft=1, iCloseRight=-1;
404    for(Int i = 0; i<m_pcCfg->getGOPEntry(iGOPid).m_numRefPics; i++) 
405    {
406      Int iRef = m_pcCfg->getGOPEntry(iGOPid).m_referencePics[i];
407      if(iRef>0&&(iRef<iCloseRight||iCloseRight==-1))
408      {
409        iCloseRight=iRef;
410      }
411      else if(iRef<0&&(iRef>iCloseLeft||iCloseLeft==1))
412      {
413        iCloseLeft=iRef;
414      }
415    }
416    if(iCloseRight>-1)
417    {
418      iCloseRight=iCloseRight+m_pcCfg->getGOPEntry(iGOPid).m_POC-1;
419    }
420    if(iCloseLeft<1) 
421    {
422      iCloseLeft=iCloseLeft+m_pcCfg->getGOPEntry(iGOPid).m_POC-1;
423      while(iCloseLeft<0)
424      {
425        iCloseLeft+=m_iGopSize;
426      }
427    }
428    Int iLeftQP=0, iRightQP=0;
429    for(Int i=0; i<m_iGopSize; i++)
430    {
431      if(m_pcCfg->getGOPEntry(i).m_POC==(iCloseLeft%m_iGopSize)+1)
432      {
433        iLeftQP= m_pcCfg->getGOPEntry(i).m_QPOffset;
434      }
435      if (m_pcCfg->getGOPEntry(i).m_POC==(iCloseRight%m_iGopSize)+1)
436      {
437        iRightQP=m_pcCfg->getGOPEntry(i).m_QPOffset;
438      }
439    }
440    if(iCloseRight>-1&&iRightQP<iLeftQP)
441    {
442      uiColDir=0;
443    }
444
445    /////////////////////////////////////////////////////////////////////////////////////////////////// Initial to start encoding
446    Int iTimeOffset;
447    Int pocCurr;
448   
449    if(iPOCLast == 0) //case first frame or first top field
450    {
451      pocCurr=0;
452      iTimeOffset = 1;
453    }
454    else if(iPOCLast == 1 && isField) //case first bottom field, just like the first frame, the poc computation is not right anymore, we set the right value
455    {
456      pocCurr = 1;
457      iTimeOffset = 1;
458    }
459    else
460    {
461      pocCurr = iPOCLast - iNumPicRcvd + m_pcCfg->getGOPEntry(iGOPid).m_POC - isField;
462      iTimeOffset = m_pcCfg->getGOPEntry(iGOPid).m_POC;
463    }
464    if(pocCurr>=m_pcCfg->getFramesToBeEncoded())
465    {
466#if H_MV
467      delete pcBitstreamRedirect;
468      return;
469#else
470      continue;
471#endif
472    }
473
474    if( getNalUnitType(pocCurr, m_iLastIDR) == NAL_UNIT_CODED_SLICE_IDR_W_RADL || getNalUnitType(pocCurr, m_iLastIDR) == NAL_UNIT_CODED_SLICE_IDR_N_LP )
475    {
476      m_iLastIDR = pocCurr;
477    }       
478    // start a new access unit: create an entry in the list of output access units
479    accessUnitsInGOP.push_back(AccessUnit());
480    AccessUnit& accessUnit = accessUnitsInGOP.back();
481    xGetBuffer( rcListPic, rcListPicYuvRecOut, iNumPicRcvd, iTimeOffset, pcPic, pcPicYuvRecOut, pocCurr, isField);
482
483    //  Slice data initialization
484    pcPic->clearSliceBuffer();
485    assert(pcPic->getNumAllocatedSlice() == 1);
486    m_pcSliceEncoder->setSliceIdx(0);
487    pcPic->setCurrSliceIdx(0);
488
489
490#if H_MV
491    m_pcSliceEncoder->initEncSlice ( pcPic, iPOCLast, pocCurr, iNumPicRcvd, iGOPid, pcSlice, m_pcEncTop->getVPS(), m_pcEncTop->getSPS(), m_pcEncTop->getPPS(), getLayerId(), isField  );     
492#else
493    m_pcSliceEncoder->initEncSlice ( pcPic, iPOCLast, pocCurr, iNumPicRcvd, iGOPid, pcSlice, m_pcEncTop->getSPS(), m_pcEncTop->getPPS(), isField  );
494#endif
495   
496    //Set Frame/Field coding
497    pcSlice->getPic()->setField(isField);
498
499    pcSlice->setLastIDR(m_iLastIDR);
500    pcSlice->setSliceIdx(0);
501#if H_MV
502    pcSlice->setRefPicSetInterLayer ( &m_refPicSetInterLayer0, &m_refPicSetInterLayer1 ); 
503    pcPic  ->setLayerId     ( getLayerId()   );
504    pcPic  ->setViewId      ( getViewId()    );   
505#if !H_3D
506    pcSlice->setLayerId     ( getLayerId() );
507    pcSlice->setViewId      ( getViewId()  );   
508    pcSlice->setVPS         ( m_pcEncTop->getVPS() );
509#else
510    pcPic  ->setViewIndex   ( getViewIndex() ); 
511    pcPic  ->setIsDepth( getIsDepth() );
512    pcSlice->setCamparaSlice( pcPic->getCodedScale(), pcPic->getCodedOffset() );   
513#endif
514#endif
515    //set default slice level flag to the same as SPS level flag
516    pcSlice->setLFCrossSliceBoundaryFlag(  pcSlice->getPPS()->getLoopFilterAcrossSlicesEnabledFlag()  );
517    pcSlice->setScalingList ( m_pcEncTop->getScalingList()  );
518    if(m_pcEncTop->getUseScalingListId() == SCALING_LIST_OFF)
519    {
520      m_pcEncTop->getTrQuant()->setFlatScalingList();
521      m_pcEncTop->getTrQuant()->setUseScalingList(false);
522      m_pcEncTop->getSPS()->setScalingListPresentFlag(false);
523      m_pcEncTop->getPPS()->setScalingListPresentFlag(false);
524    }
525    else if(m_pcEncTop->getUseScalingListId() == SCALING_LIST_DEFAULT)
526    {
527      pcSlice->setDefaultScalingList ();
528      m_pcEncTop->getSPS()->setScalingListPresentFlag(false);
529      m_pcEncTop->getPPS()->setScalingListPresentFlag(false);
530      m_pcEncTop->getTrQuant()->setScalingList(pcSlice->getScalingList());
531      m_pcEncTop->getTrQuant()->setUseScalingList(true);
532    }
533    else if(m_pcEncTop->getUseScalingListId() == SCALING_LIST_FILE_READ)
534    {
535      if(pcSlice->getScalingList()->xParseScalingList(m_pcCfg->getScalingListFile()))
536      {
537        pcSlice->setDefaultScalingList ();
538      }
539      pcSlice->getScalingList()->checkDcOfMatrix();
540      m_pcEncTop->getSPS()->setScalingListPresentFlag(pcSlice->checkDefaultScalingList());
541      m_pcEncTop->getPPS()->setScalingListPresentFlag(false);
542      m_pcEncTop->getTrQuant()->setScalingList(pcSlice->getScalingList());
543      m_pcEncTop->getTrQuant()->setUseScalingList(true);
544    }
545    else
546    {
547      printf("error : ScalingList == %d no support\n",m_pcEncTop->getUseScalingListId());
548      assert(0);
549    }
550
551#if H_MV
552    // Set the nal unit type
553    pcSlice->setNalUnitType(getNalUnitType(pocCurr, m_iLastIDR));
554    if( pcSlice->getSliceType() == B_SLICE )
555    {
556      if( m_pcCfg->getGOPEntry( ( pcSlice->getRapPicFlag() && getLayerId() > 0 ) ? MAX_GOP : iGOPid ).m_sliceType == 'P' ) 
557      { 
558        pcSlice->setSliceType( P_SLICE );
559      }
560    }
561#else
562    if(pcSlice->getSliceType()==B_SLICE&&m_pcCfg->getGOPEntry(iGOPid).m_sliceType=='P')
563    {
564      pcSlice->setSliceType(P_SLICE);
565    }
566    // Set the nal unit type
567    pcSlice->setNalUnitType(getNalUnitType(pocCurr, m_iLastIDR));
568#endif
569    if(pcSlice->getTemporalLayerNonReferenceFlag())
570    {
571      if (pcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_TRAIL_R &&
572          !(m_iGopSize == 1 && pcSlice->getSliceType() == I_SLICE))
573        // Add this condition to avoid POC issues with encoder_intra_main.cfg configuration (see #1127 in bug tracker)
574      {
575        pcSlice->setNalUnitType(NAL_UNIT_CODED_SLICE_TRAIL_N);
576      }
577      if(pcSlice->getNalUnitType()==NAL_UNIT_CODED_SLICE_RADL_R)
578      {
579        pcSlice->setNalUnitType(NAL_UNIT_CODED_SLICE_RADL_N);
580      }
581      if(pcSlice->getNalUnitType()==NAL_UNIT_CODED_SLICE_RASL_R)
582      {
583        pcSlice->setNalUnitType(NAL_UNIT_CODED_SLICE_RASL_N);
584      }
585    }
586
587    // Do decoding refresh marking if any
588    pcSlice->decodingRefreshMarking(m_pocCRA, m_bRefreshPending, rcListPic);
589    m_pcEncTop->selectReferencePictureSet(pcSlice, pocCurr, iGOPid);
590    pcSlice->getRPS()->setNumberOfLongtermPictures(0);
591
592#if FIX1071
593    if ((pcSlice->checkThatAllRefPicsAreAvailable(rcListPic, pcSlice->getRPS(), false) != 0) || (pcSlice->isIRAP()))
594    {
595      pcSlice->createExplicitReferencePictureSetFromReference(rcListPic, pcSlice->getRPS(), pcSlice->isIRAP());
596    }
597#else
598    if(pcSlice->checkThatAllRefPicsAreAvailable(rcListPic, pcSlice->getRPS(), false) != 0)
599    {
600      pcSlice->createExplicitReferencePictureSetFromReference(rcListPic, pcSlice->getRPS());
601    }
602#endif
603    pcSlice->applyReferencePictureSet(rcListPic, pcSlice->getRPS());
604
605    if(pcSlice->getTLayer() > 0)
606    {
607      if(pcSlice->isTemporalLayerSwitchingPoint(rcListPic) || pcSlice->getSPS()->getTemporalIdNestingFlag())
608      {
609        if(pcSlice->getTemporalLayerNonReferenceFlag())
610        {
611          pcSlice->setNalUnitType(NAL_UNIT_CODED_SLICE_TSA_N);
612        }
613        else
614        {
615          pcSlice->setNalUnitType(NAL_UNIT_CODED_SLICE_TLA_R);
616        }
617      }
618      else if(pcSlice->isStepwiseTemporalLayerSwitchingPointCandidate(rcListPic))
619      {
620        Bool isSTSA=true;
621        for(Int ii=iGOPid+1;(ii<m_pcCfg->getGOPSize() && isSTSA==true);ii++)
622        {
623          Int lTid= m_pcCfg->getGOPEntry(ii).m_temporalId;
624          if(lTid==pcSlice->getTLayer()) 
625          {
626            TComReferencePictureSet* nRPS = pcSlice->getSPS()->getRPSList()->getReferencePictureSet(ii);
627            for(Int jj=0;jj<nRPS->getNumberOfPictures();jj++)
628            {
629              if(nRPS->getUsed(jj)) 
630              {
631                Int tPoc=m_pcCfg->getGOPEntry(ii).m_POC+nRPS->getDeltaPOC(jj);
632                Int kk=0;
633                for(kk=0;kk<m_pcCfg->getGOPSize();kk++)
634                {
635                  if(m_pcCfg->getGOPEntry(kk).m_POC==tPoc)
636                    break;
637                }
638                Int tTid=m_pcCfg->getGOPEntry(kk).m_temporalId;
639                if(tTid >= pcSlice->getTLayer())
640                {
641                  isSTSA=false;
642                  break;
643                }
644              }
645            }
646          }
647        }
648        if(isSTSA==true)
649        {   
650          if(pcSlice->getTemporalLayerNonReferenceFlag())
651          {
652            pcSlice->setNalUnitType(NAL_UNIT_CODED_SLICE_STSA_N);
653          }
654          else
655          {
656            pcSlice->setNalUnitType(NAL_UNIT_CODED_SLICE_STSA_R);
657          }
658        }
659      }
660    }
661    arrangeLongtermPicturesInRPS(pcSlice, rcListPic);
662    TComRefPicListModification* refPicListModification = pcSlice->getRefPicListModification();
663    refPicListModification->setRefPicListModificationFlagL0(0);
664    refPicListModification->setRefPicListModificationFlagL1(0);
665#if H_MV
666    if ( pcSlice->getPPS()->getNumExtraSliceHeaderBits() > 1 )
667    {
668      // Some more sophisticated algorithm to determine discardable_flag might be added here.
669      pcSlice->setDiscardableFlag           ( false );     
670    }   
671
672    TComVPS*           vps = pcSlice->getVPS();     
673    Int numDirectRefLayers = vps    ->getNumDirectRefLayers( getLayerId() ); 
674    GOPEntry gopEntry      = m_pcCfg->getGOPEntry( (pcSlice->getRapPicFlag() && getLayerId() > 0) ? MAX_GOP : iGOPid );     
675   
676    if ( getLayerId() > 0 && !vps->getAllRefLayersActiveFlag() && numDirectRefLayers > 0 )
677    {         
678      pcSlice->setInterLayerPredEnabledFlag ( gopEntry.m_numActiveRefLayerPics > 0 );     
679      if ( pcSlice->getInterLayerPredEnabledFlag() && numDirectRefLayers > 1 )
680      {
681        if ( !vps->getMaxOneActiveRefLayerFlag() )
682        {   
683          pcSlice->setNumInterLayerRefPicsMinus1( gopEntry.m_numActiveRefLayerPics - 1 ); 
684        }
685        if ( gopEntry.m_numActiveRefLayerPics != vps->getNumDirectRefLayers( getLayerId() ) )
686        {       
687          for (Int i = 0; i < gopEntry.m_numActiveRefLayerPics; i++ )
688          {
689            pcSlice->setInterLayerPredLayerIdc( i, gopEntry.m_interLayerPredLayerIdc[ i ] ); 
690          }
691        }
692      }
693    }
694    assert( pcSlice->getNumActiveRefLayerPics() == gopEntry.m_numActiveRefLayerPics ); 
695   
696    pcSlice->createInterLayerReferencePictureSet( m_ivPicLists, m_refPicSetInterLayer0, m_refPicSetInterLayer1 ); 
697    pcSlice->setNumRefIdx(REF_PIC_LIST_0,min(gopEntry.m_numRefPicsActive,( pcSlice->getRPS()->getNumberOfPictures() + (Int) m_refPicSetInterLayer0.size() + (Int) m_refPicSetInterLayer1.size()) ) );
698    pcSlice->setNumRefIdx(REF_PIC_LIST_1,min(gopEntry.m_numRefPicsActive,( pcSlice->getRPS()->getNumberOfPictures() + (Int) m_refPicSetInterLayer0.size() + (Int) m_refPicSetInterLayer1.size()) ) );
699
700    std::vector< TComPic* >    tempRefPicLists[2];
701    std::vector< Bool     >    usedAsLongTerm [2];
702    Int       numPocTotalCurr;
703
704    pcSlice->getTempRefPicLists( rcListPic, m_refPicSetInterLayer0, m_refPicSetInterLayer1, tempRefPicLists, usedAsLongTerm, numPocTotalCurr, true );
705   
706
707    xSetRefPicListModificationsMv( tempRefPicLists, pcSlice, iGOPid );   
708#else
709    pcSlice->setNumRefIdx(REF_PIC_LIST_0,min(m_pcCfg->getGOPEntry(iGOPid).m_numRefPicsActive,pcSlice->getRPS()->getNumberOfPictures()));
710    pcSlice->setNumRefIdx(REF_PIC_LIST_1,min(m_pcCfg->getGOPEntry(iGOPid).m_numRefPicsActive,pcSlice->getRPS()->getNumberOfPictures()));
711#endif
712
713#if ADAPTIVE_QP_SELECTION
714    pcSlice->setTrQuant( m_pcEncTop->getTrQuant() );
715#endif     
716
717    //  Set reference list
718#if H_MV   
719    pcSlice->setRefPicList( tempRefPicLists, usedAsLongTerm, numPocTotalCurr ); 
720#else
721    pcSlice->setRefPicList ( rcListPic );
722#endif
723 
724#if H_3D_ARP
725    //GT: This seems to be broken when layerId in vps is not equal to layerId in nuh
726    pcSlice->setARPStepNum();
727    if(pcSlice->getARPStepNum() > 1)
728    {
729      for(Int iLayerId = 0; iLayerId < getLayerId(); iLayerId ++ )
730      {
731        Int  iViewIdx =   pcSlice->getVPS()->getViewIndex(iLayerId);
732        Bool bIsDepth = ( pcSlice->getVPS()->getDepthId  ( iLayerId ) == 1 );
733        if( iViewIdx<getViewIndex() && !bIsDepth )
734        {
735          pcSlice->setBaseViewRefPicList( m_ivPicLists->getPicList( iLayerId ), iViewIdx );
736        }
737      }
738    }
739#endif
740#if H_3D
741    pcSlice->setIvPicLists( m_ivPicLists );         
742#if H_3D_IV_MERGE   
743    assert( !m_pcEncTop->getIsDepth() || ( pcSlice->getTexturePic() != 0 ) );
744#endif   
745#endif
746    //  Slice info. refinement
747#if H_MV
748    if ( pcSlice->getSliceType() == B_SLICE )
749    {
750      if( m_pcCfg->getGOPEntry( ( pcSlice->getRapPicFlag() == true && getLayerId() > 0 ) ? MAX_GOP : iGOPid ).m_sliceType == 'P' ) 
751      { 
752        pcSlice->setSliceType( P_SLICE ); 
753      }
754    }
755#else
756    if ( (pcSlice->getSliceType() == B_SLICE) && (pcSlice->getNumRefIdx(REF_PIC_LIST_1) == 0) )
757    {
758      pcSlice->setSliceType ( P_SLICE );
759    }
760#endif
761    if (pcSlice->getSliceType() == B_SLICE)
762    {
763      pcSlice->setColFromL0Flag(1-uiColDir);
764      Bool bLowDelay = true;
765      Int  iCurrPOC  = pcSlice->getPOC();
766      Int iRefIdx = 0;
767
768      for (iRefIdx = 0; iRefIdx < pcSlice->getNumRefIdx(REF_PIC_LIST_0) && bLowDelay; iRefIdx++)
769      {
770        if ( pcSlice->getRefPic(REF_PIC_LIST_0, iRefIdx)->getPOC() > iCurrPOC )
771        {
772          bLowDelay = false;
773        }
774      }
775      for (iRefIdx = 0; iRefIdx < pcSlice->getNumRefIdx(REF_PIC_LIST_1) && bLowDelay; iRefIdx++)
776      {
777        if ( pcSlice->getRefPic(REF_PIC_LIST_1, iRefIdx)->getPOC() > iCurrPOC )
778        {
779          bLowDelay = false;
780        }
781      }
782
783      pcSlice->setCheckLDC(bLowDelay); 
784    }
785    else
786    {
787      pcSlice->setCheckLDC(true); 
788    }
789
790    uiColDir = 1-uiColDir;
791
792    //-------------------------------------------------------------
793    pcSlice->setRefPOCList();
794
795    pcSlice->setList1IdxToList0Idx();
796#if H_3D_TMVP
797    if(pcSlice->getLayerId())
798      pcSlice->generateAlterRefforTMVP();
799#endif
800    if (m_pcEncTop->getTMVPModeId() == 2)
801    {
802      if (iGOPid == 0) // first picture in SOP (i.e. forward B)
803      {
804        pcSlice->setEnableTMVPFlag(0);
805      }
806      else
807      {
808        // Note: pcSlice->getColFromL0Flag() is assumed to be always 0 and getcolRefIdx() is always 0.
809        pcSlice->setEnableTMVPFlag(1);
810      }
811      pcSlice->getSPS()->setTMVPFlagsPresent(1);
812    }
813    else if (m_pcEncTop->getTMVPModeId() == 1)
814    {
815      pcSlice->getSPS()->setTMVPFlagsPresent(1);
816      pcSlice->setEnableTMVPFlag(1);
817    }
818    else
819    {
820      pcSlice->getSPS()->setTMVPFlagsPresent(0);
821      pcSlice->setEnableTMVPFlag(0);
822    }
823#if H_MV
824    if( pcSlice->getIdrPicFlag() )
825    {
826      pcSlice->setEnableTMVPFlag(0);
827    }
828#endif
829
830#if H_3D_VSO
831  // Should be moved to TEncTop !!!
832  Bool bUseVSO = m_pcEncTop->getUseVSO();
833 
834  TComRdCost* pcRdCost = m_pcEncTop->getRdCost();   
835
836  pcRdCost->setUseVSO( bUseVSO );
837
838  // SAIT_VSO_EST_A0033
839  pcRdCost->setUseEstimatedVSD( m_pcEncTop->getUseEstimatedVSD() );
840
841  if ( bUseVSO )
842  {
843    Int iVSOMode = m_pcEncTop->getVSOMode();
844    pcRdCost->setVSOMode( iVSOMode  );
845    pcRdCost->setAllowNegDist( m_pcEncTop->getAllowNegDist() );
846
847    // SAIT_VSO_EST_A0033
848#if H_3D_FCO
849    Bool flagRec;
850    flagRec =  ((m_pcEncTop->getIvPicLists()->getPicYuv( pcSlice->getViewIndex(), false, pcSlice->getPOC(), true) == NULL) ? false: true);
851    pcRdCost->setVideoRecPicYuv( m_pcEncTop->getIvPicLists()->getPicYuv( pcSlice->getViewIndex(), false, pcSlice->getPOC(), flagRec ) );
852    pcRdCost->setDepthPicYuv   ( m_pcEncTop->getIvPicLists()->getPicYuv( pcSlice->getViewIndex(), true, pcSlice->getPOC(), false ) );
853#else
854    pcRdCost->setVideoRecPicYuv( m_pcEncTop->getIvPicLists()->getPicYuv( pcSlice->getViewIndex(), false , pcSlice->getPOC(), true ) );
855    pcRdCost->setDepthPicYuv   ( m_pcEncTop->getIvPicLists()->getPicYuv( pcSlice->getViewIndex(), true  , pcSlice->getPOC(), false ) );
856#endif
857
858    // LGE_WVSO_A0119
859    Bool bUseWVSO  = m_pcEncTop->getUseWVSO();
860    pcRdCost->setUseWVSO( bUseWVSO );
861
862  }
863#endif
864    /////////////////////////////////////////////////////////////////////////////////////////////////// Compress a slice
865    //  Slice compression
866    if (m_pcCfg->getUseASR())
867    {
868      m_pcSliceEncoder->setSearchRange(pcSlice);
869    }
870
871    Bool bGPBcheck=false;
872    if ( pcSlice->getSliceType() == B_SLICE)
873    {
874      if ( pcSlice->getNumRefIdx(RefPicList( 0 ) ) == pcSlice->getNumRefIdx(RefPicList( 1 ) ) )
875      {
876        bGPBcheck=true;
877        Int i;
878        for ( i=0; i < pcSlice->getNumRefIdx(RefPicList( 1 ) ); i++ )
879        {
880          if ( pcSlice->getRefPOC(RefPicList(1), i) != pcSlice->getRefPOC(RefPicList(0), i) ) 
881          {
882            bGPBcheck=false;
883            break;
884          }
885        }
886      }
887    }
888    if(bGPBcheck)
889    {
890      pcSlice->setMvdL1ZeroFlag(true);
891    }
892    else
893    {
894      pcSlice->setMvdL1ZeroFlag(false);
895    }
896    pcPic->getSlice(pcSlice->getSliceIdx())->setMvdL1ZeroFlag(pcSlice->getMvdL1ZeroFlag());
897
898#if RATE_CONTROL_LAMBDA_DOMAIN
899    Double lambda            = 0.0;
900    Int actualHeadBits       = 0;
901    Int actualTotalBits      = 0;
902    Int estimatedBits        = 0;
903    Int tmpBitsBeforeWriting = 0;
904    if ( m_pcCfg->getUseRateCtrl() )
905    {
906      Int frameLevel = m_pcRateCtrl->getRCSeq()->getGOPID2Level( iGOPid );
907      if ( pcPic->getSlice(0)->getSliceType() == I_SLICE )
908      {
909        frameLevel = 0;
910      }
911      m_pcRateCtrl->initRCPic( frameLevel );
912
913#if KWU_RC_MADPRED_E0227
914      if(m_pcCfg->getLayerId() != 0)
915      {
916        m_pcRateCtrl->getRCPic()->setIVPic( m_pcEncTop->getEncTop()->getTEncTop(0)->getRateCtrl()->getRCPic() );
917      }
918#endif
919
920      estimatedBits = m_pcRateCtrl->getRCPic()->getTargetBits();
921
922      Int sliceQP = m_pcCfg->getInitialQP();
923      if ( ( pcSlice->getPOC() == 0 && m_pcCfg->getInitialQP() > 0 ) || ( frameLevel == 0 && m_pcCfg->getForceIntraQP() ) ) // QP is specified
924      {
925        Int    NumberBFrames = ( m_pcCfg->getGOPSize() - 1 );
926        Double dLambda_scale = 1.0 - Clip3( 0.0, 0.5, 0.05*(Double)NumberBFrames );
927        Double dQPFactor     = 0.57*dLambda_scale;
928        Int    SHIFT_QP      = 12;
929        Int    bitdepth_luma_qp_scale = 0;
930        Double qp_temp = (Double) sliceQP + bitdepth_luma_qp_scale - SHIFT_QP;
931        lambda = dQPFactor*pow( 2.0, qp_temp/3.0 );
932      }
933      else if ( frameLevel == 0 )   // intra case, but use the model
934      {
935#if RATE_CONTROL_INTRA
936        m_pcSliceEncoder->calCostSliceI(pcPic);
937#endif
938        if ( m_pcCfg->getIntraPeriod() != 1 )   // do not refine allocated bits for all intra case
939        {
940          Int bits = m_pcRateCtrl->getRCSeq()->getLeftAverageBits();
941#if RATE_CONTROL_INTRA
942          bits = m_pcRateCtrl->getRCPic()->getRefineBitsForIntra( bits );
943#else
944          bits = m_pcRateCtrl->getRCSeq()->getRefineBitsForIntra( bits );
945#endif
946          if ( bits < 200 )
947          {
948            bits = 200;
949          }
950          m_pcRateCtrl->getRCPic()->setTargetBits( bits );
951        }
952
953        list<TEncRCPic*> listPreviousPicture = m_pcRateCtrl->getPicList();
954#if RATE_CONTROL_INTRA
955        m_pcRateCtrl->getRCPic()->getLCUInitTargetBits();
956        lambda  = m_pcRateCtrl->getRCPic()->estimatePicLambda( listPreviousPicture, pcSlice->getSliceType());
957#else
958        lambda  = m_pcRateCtrl->getRCPic()->estimatePicLambda( listPreviousPicture );
959#endif
960        sliceQP = m_pcRateCtrl->getRCPic()->estimatePicQP( lambda, listPreviousPicture );
961      }
962      else    // normal case
963      {
964#if KWU_RC_MADPRED_E0227
965        if(m_pcRateCtrl->getLayerID() != 0)
966        {
967          list<TEncRCPic*> listPreviousPicture = m_pcRateCtrl->getPicList();
968          lambda  = m_pcRateCtrl->getRCPic()->estimatePicLambdaIV( listPreviousPicture, pcSlice->getPOC() );
969          sliceQP = m_pcRateCtrl->getRCPic()->estimatePicQP( lambda, listPreviousPicture );
970        }
971        else
972        {
973#endif
974        list<TEncRCPic*> listPreviousPicture = m_pcRateCtrl->getPicList();
975#if RATE_CONTROL_INTRA
976        lambda  = m_pcRateCtrl->getRCPic()->estimatePicLambda( listPreviousPicture, pcSlice->getSliceType());
977#else
978        lambda  = m_pcRateCtrl->getRCPic()->estimatePicLambda( listPreviousPicture );
979#endif
980        sliceQP = m_pcRateCtrl->getRCPic()->estimatePicQP( lambda, listPreviousPicture );
981#if KWU_RC_MADPRED_E0227
982        }
983#endif
984      }
985
986      sliceQP = Clip3( -pcSlice->getSPS()->getQpBDOffsetY(), MAX_QP, sliceQP );
987      m_pcRateCtrl->getRCPic()->setPicEstQP( sliceQP );
988
989      m_pcSliceEncoder->resetQP( pcPic, sliceQP, lambda );
990    }
991#endif
992
993    UInt uiNumSlices = 1;
994
995    UInt uiInternalAddress = pcPic->getNumPartInCU()-4;
996    UInt uiExternalAddress = pcPic->getPicSym()->getNumberOfCUsInFrame()-1;
997    UInt uiPosX = ( uiExternalAddress % pcPic->getFrameWidthInCU() ) * g_uiMaxCUWidth+ g_auiRasterToPelX[ g_auiZscanToRaster[uiInternalAddress] ];
998    UInt uiPosY = ( uiExternalAddress / pcPic->getFrameWidthInCU() ) * g_uiMaxCUHeight+ g_auiRasterToPelY[ g_auiZscanToRaster[uiInternalAddress] ];
999    UInt uiWidth = pcSlice->getSPS()->getPicWidthInLumaSamples();
1000    UInt uiHeight = pcSlice->getSPS()->getPicHeightInLumaSamples();
1001    while(uiPosX>=uiWidth||uiPosY>=uiHeight) 
1002    {
1003      uiInternalAddress--;
1004      uiPosX = ( uiExternalAddress % pcPic->getFrameWidthInCU() ) * g_uiMaxCUWidth+ g_auiRasterToPelX[ g_auiZscanToRaster[uiInternalAddress] ];
1005      uiPosY = ( uiExternalAddress / pcPic->getFrameWidthInCU() ) * g_uiMaxCUHeight+ g_auiRasterToPelY[ g_auiZscanToRaster[uiInternalAddress] ];
1006    }
1007    uiInternalAddress++;
1008    if(uiInternalAddress==pcPic->getNumPartInCU()) 
1009    {
1010      uiInternalAddress = 0;
1011      uiExternalAddress++;
1012    }
1013    UInt uiRealEndAddress = uiExternalAddress*pcPic->getNumPartInCU()+uiInternalAddress;
1014
1015    UInt uiCummulativeTileWidth;
1016    UInt uiCummulativeTileHeight;
1017    Int  p, j;
1018    UInt uiEncCUAddr;
1019
1020    //set NumColumnsMinus1 and NumRowsMinus1
1021    pcPic->getPicSym()->setNumColumnsMinus1( pcSlice->getPPS()->getNumColumnsMinus1() );
1022    pcPic->getPicSym()->setNumRowsMinus1( pcSlice->getPPS()->getNumRowsMinus1() );
1023
1024    //create the TComTileArray
1025    pcPic->getPicSym()->xCreateTComTileArray();
1026
1027    if( pcSlice->getPPS()->getUniformSpacingFlag() == 1 )
1028    {
1029      //set the width for each tile
1030      for(j=0; j < pcPic->getPicSym()->getNumRowsMinus1()+1; j++)
1031      {
1032        for(p=0; p < pcPic->getPicSym()->getNumColumnsMinus1()+1; p++)
1033        {
1034          pcPic->getPicSym()->getTComTile( j * (pcPic->getPicSym()->getNumColumnsMinus1()+1) + p )->
1035            setTileWidth( (p+1)*pcPic->getPicSym()->getFrameWidthInCU()/(pcPic->getPicSym()->getNumColumnsMinus1()+1) 
1036            - (p*pcPic->getPicSym()->getFrameWidthInCU())/(pcPic->getPicSym()->getNumColumnsMinus1()+1) );
1037        }
1038      }
1039
1040      //set the height for each tile
1041      for(j=0; j < pcPic->getPicSym()->getNumColumnsMinus1()+1; j++)
1042      {
1043        for(p=0; p < pcPic->getPicSym()->getNumRowsMinus1()+1; p++)
1044        {
1045          pcPic->getPicSym()->getTComTile( p * (pcPic->getPicSym()->getNumColumnsMinus1()+1) + j )->
1046            setTileHeight( (p+1)*pcPic->getPicSym()->getFrameHeightInCU()/(pcPic->getPicSym()->getNumRowsMinus1()+1) 
1047            - (p*pcPic->getPicSym()->getFrameHeightInCU())/(pcPic->getPicSym()->getNumRowsMinus1()+1) );   
1048        }
1049      }
1050    }
1051    else
1052    {
1053      //set the width for each tile
1054      for(j=0; j < pcPic->getPicSym()->getNumRowsMinus1()+1; j++)
1055      {
1056        uiCummulativeTileWidth = 0;
1057        for(p=0; p < pcPic->getPicSym()->getNumColumnsMinus1(); p++)
1058        {
1059          pcPic->getPicSym()->getTComTile( j * (pcPic->getPicSym()->getNumColumnsMinus1()+1) + p )->setTileWidth( pcSlice->getPPS()->getColumnWidth(p) );
1060          uiCummulativeTileWidth += pcSlice->getPPS()->getColumnWidth(p);
1061        }
1062        pcPic->getPicSym()->getTComTile(j * (pcPic->getPicSym()->getNumColumnsMinus1()+1) + p)->setTileWidth( pcPic->getPicSym()->getFrameWidthInCU()-uiCummulativeTileWidth );
1063      }
1064
1065      //set the height for each tile
1066      for(j=0; j < pcPic->getPicSym()->getNumColumnsMinus1()+1; j++)
1067      {
1068        uiCummulativeTileHeight = 0;
1069        for(p=0; p < pcPic->getPicSym()->getNumRowsMinus1(); p++)
1070        {
1071          pcPic->getPicSym()->getTComTile( p * (pcPic->getPicSym()->getNumColumnsMinus1()+1) + j )->setTileHeight( pcSlice->getPPS()->getRowHeight(p) );
1072          uiCummulativeTileHeight += pcSlice->getPPS()->getRowHeight(p);
1073        }
1074        pcPic->getPicSym()->getTComTile(p * (pcPic->getPicSym()->getNumColumnsMinus1()+1) + j)->setTileHeight( pcPic->getPicSym()->getFrameHeightInCU()-uiCummulativeTileHeight );
1075      }
1076    }
1077    //intialize each tile of the current picture
1078    pcPic->getPicSym()->xInitTiles();
1079
1080    // Allocate some coders, now we know how many tiles there are.
1081    Int iNumSubstreams = pcSlice->getPPS()->getNumSubstreams();
1082
1083    //generate the Coding Order Map and Inverse Coding Order Map
1084    for(p=0, uiEncCUAddr=0; p<pcPic->getPicSym()->getNumberOfCUsInFrame(); p++, uiEncCUAddr = pcPic->getPicSym()->xCalculateNxtCUAddr(uiEncCUAddr))
1085    {
1086      pcPic->getPicSym()->setCUOrderMap(p, uiEncCUAddr);
1087      pcPic->getPicSym()->setInverseCUOrderMap(uiEncCUAddr, p);
1088    }
1089    pcPic->getPicSym()->setCUOrderMap(pcPic->getPicSym()->getNumberOfCUsInFrame(), pcPic->getPicSym()->getNumberOfCUsInFrame());   
1090    pcPic->getPicSym()->setInverseCUOrderMap(pcPic->getPicSym()->getNumberOfCUsInFrame(), pcPic->getPicSym()->getNumberOfCUsInFrame());
1091
1092    // Allocate some coders, now we know how many tiles there are.
1093    m_pcEncTop->createWPPCoders(iNumSubstreams);
1094    pcSbacCoders = m_pcEncTop->getSbacCoders();
1095    pcSubstreamsOut = new TComOutputBitstream[iNumSubstreams];
1096
1097    UInt startCUAddrSliceIdx = 0; // used to index "m_uiStoredStartCUAddrForEncodingSlice" containing locations of slice boundaries
1098    UInt startCUAddrSlice    = 0; // used to keep track of current slice's starting CU addr.
1099    pcSlice->setSliceCurStartCUAddr( startCUAddrSlice ); // Setting "start CU addr" for current slice
1100    m_storedStartCUAddrForEncodingSlice.clear();
1101
1102    UInt startCUAddrSliceSegmentIdx = 0; // used to index "m_uiStoredStartCUAddrForEntropyEncodingSlice" containing locations of slice boundaries
1103    UInt startCUAddrSliceSegment    = 0; // used to keep track of current Dependent slice's starting CU addr.
1104    pcSlice->setSliceSegmentCurStartCUAddr( startCUAddrSliceSegment ); // Setting "start CU addr" for current Dependent slice
1105
1106    m_storedStartCUAddrForEncodingSliceSegment.clear();
1107    UInt nextCUAddr = 0;
1108    m_storedStartCUAddrForEncodingSlice.push_back (nextCUAddr);
1109    startCUAddrSliceIdx++;
1110    m_storedStartCUAddrForEncodingSliceSegment.push_back(nextCUAddr);
1111    startCUAddrSliceSegmentIdx++;
1112#if H_3D_NBDV
1113      if(pcSlice->getViewIndex() && !pcSlice->getIsDepth()) //Notes from QC: this condition shall be changed once the configuration is completed, e.g. in pcSlice->getSPS()->getMultiviewMvPredMode() || ARP in prev. HTM. Remove this comment once it is done.
1114      {
1115        Int iColPoc = pcSlice->getRefPOC(RefPicList(1-pcSlice->getColFromL0Flag()), pcSlice->getColRefIdx());
1116        pcPic->setNumDdvCandPics(pcPic->getDisCandRefPictures(iColPoc));
1117      }
1118#endif
1119#if H_3D
1120      pcSlice->setDepthToDisparityLUTs(); 
1121
1122#endif
1123
1124#if H_3D_NBDV
1125      if(pcSlice->getViewIndex() && !pcSlice->getIsDepth() && !pcSlice->isIntra()) //Notes from QC: this condition shall be changed once the configuration is completed, e.g. in pcSlice->getSPS()->getMultiviewMvPredMode() || ARP in prev. HTM. Remove this comment once it is done.
1126      {
1127        pcPic->checkTemporalIVRef();
1128      }
1129
1130      if(pcSlice->getIsDepth())
1131      {
1132        pcPic->checkTextureRef();
1133      }
1134#endif
1135    while(nextCUAddr<uiRealEndAddress) // determine slice boundaries
1136    {
1137      pcSlice->setNextSlice       ( false );
1138      pcSlice->setNextSliceSegment( false );
1139      assert(pcPic->getNumAllocatedSlice() == startCUAddrSliceIdx);
1140      m_pcSliceEncoder->precompressSlice( pcPic );
1141      m_pcSliceEncoder->compressSlice   ( pcPic );
1142
1143      Bool bNoBinBitConstraintViolated = (!pcSlice->isNextSlice() && !pcSlice->isNextSliceSegment());
1144      if (pcSlice->isNextSlice() || (bNoBinBitConstraintViolated && m_pcCfg->getSliceMode()==FIXED_NUMBER_OF_LCU))
1145      {
1146        startCUAddrSlice = pcSlice->getSliceCurEndCUAddr();
1147        // Reconstruction slice
1148        m_storedStartCUAddrForEncodingSlice.push_back(startCUAddrSlice);
1149        startCUAddrSliceIdx++;
1150        // Dependent slice
1151        if (startCUAddrSliceSegmentIdx>0 && m_storedStartCUAddrForEncodingSliceSegment[startCUAddrSliceSegmentIdx-1] != startCUAddrSlice)
1152        {
1153          m_storedStartCUAddrForEncodingSliceSegment.push_back(startCUAddrSlice);
1154          startCUAddrSliceSegmentIdx++;
1155        }
1156
1157        if (startCUAddrSlice < uiRealEndAddress)
1158        {
1159          pcPic->allocateNewSlice();         
1160          pcPic->setCurrSliceIdx                  ( startCUAddrSliceIdx-1 );
1161          m_pcSliceEncoder->setSliceIdx           ( startCUAddrSliceIdx-1 );
1162          pcSlice = pcPic->getSlice               ( startCUAddrSliceIdx-1 );
1163          pcSlice->copySliceInfo                  ( pcPic->getSlice(0)      );
1164          pcSlice->setSliceIdx                    ( startCUAddrSliceIdx-1 );
1165          pcSlice->setSliceCurStartCUAddr         ( startCUAddrSlice      );
1166          pcSlice->setSliceSegmentCurStartCUAddr  ( startCUAddrSlice      );
1167          pcSlice->setSliceBits(0);
1168          uiNumSlices ++;
1169        }
1170      }
1171      else if (pcSlice->isNextSliceSegment() || (bNoBinBitConstraintViolated && m_pcCfg->getSliceSegmentMode()==FIXED_NUMBER_OF_LCU))
1172      {
1173        startCUAddrSliceSegment                                                     = pcSlice->getSliceSegmentCurEndCUAddr();
1174        m_storedStartCUAddrForEncodingSliceSegment.push_back(startCUAddrSliceSegment);
1175        startCUAddrSliceSegmentIdx++;
1176        pcSlice->setSliceSegmentCurStartCUAddr( startCUAddrSliceSegment );
1177      }
1178      else
1179      {
1180        startCUAddrSlice                                                            = pcSlice->getSliceCurEndCUAddr();
1181        startCUAddrSliceSegment                                                     = pcSlice->getSliceSegmentCurEndCUAddr();
1182      }       
1183
1184      nextCUAddr = (startCUAddrSlice > startCUAddrSliceSegment) ? startCUAddrSlice : startCUAddrSliceSegment;
1185    }
1186    m_storedStartCUAddrForEncodingSlice.push_back( pcSlice->getSliceCurEndCUAddr());
1187    startCUAddrSliceIdx++;
1188    m_storedStartCUAddrForEncodingSliceSegment.push_back(pcSlice->getSliceCurEndCUAddr());
1189    startCUAddrSliceSegmentIdx++;
1190
1191    pcSlice = pcPic->getSlice(0);
1192
1193    // SAO parameter estimation using non-deblocked pixels for LCU bottom and right boundary areas
1194    if( m_pcCfg->getSaoLcuBasedOptimization() && m_pcCfg->getSaoLcuBoundary() )
1195    {
1196      m_pcSAO->resetStats();
1197      m_pcSAO->calcSaoStatsCu_BeforeDblk( pcPic );
1198    }
1199
1200    //-- Loop filter
1201    Bool bLFCrossTileBoundary = pcSlice->getPPS()->getLoopFilterAcrossTilesEnabledFlag();
1202    m_pcLoopFilter->setCfg(bLFCrossTileBoundary);
1203    if ( m_pcCfg->getDeblockingFilterMetric() )
1204    {
1205      dblMetric(pcPic, uiNumSlices);
1206    }
1207    m_pcLoopFilter->loopFilterPic( pcPic );
1208
1209    pcSlice = pcPic->getSlice(0);
1210    if(pcSlice->getSPS()->getUseSAO())
1211    {
1212      std::vector<Bool> LFCrossSliceBoundaryFlag;
1213      for(Int s=0; s< uiNumSlices; s++)
1214      {
1215        LFCrossSliceBoundaryFlag.push_back(  ((uiNumSlices==1)?true:pcPic->getSlice(s)->getLFCrossSliceBoundaryFlag()) );
1216      }
1217      m_storedStartCUAddrForEncodingSlice.resize(uiNumSlices+1);
1218      pcPic->createNonDBFilterInfo(m_storedStartCUAddrForEncodingSlice, 0, &LFCrossSliceBoundaryFlag ,pcPic->getPicSym()->getNumTiles() ,bLFCrossTileBoundary);
1219    }
1220
1221
1222    pcSlice = pcPic->getSlice(0);
1223
1224    if(pcSlice->getSPS()->getUseSAO())
1225    {
1226      m_pcSAO->createPicSaoInfo(pcPic);
1227    }
1228
1229    /////////////////////////////////////////////////////////////////////////////////////////////////// File writing
1230    // Set entropy coder
1231    m_pcEntropyCoder->setEntropyCoder   ( m_pcCavlcCoder, pcSlice );
1232
1233    /* write various header sets. */
1234    if ( m_bSeqFirst )
1235    {
1236      OutputNALUnit nalu(NAL_UNIT_VPS);
1237#if H_MV
1238      if( getLayerId() == 0 )
1239      {
1240#endif
1241      m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
1242      m_pcEntropyCoder->encodeVPS(m_pcEncTop->getVPS());
1243      writeRBSPTrailingBits(nalu.m_Bitstream);
1244      accessUnit.push_back(new NALUnitEBSP(nalu));
1245#if RATE_CONTROL_LAMBDA_DOMAIN
1246      actualTotalBits += UInt(accessUnit.back()->m_nalUnitData.str().size()) * 8;
1247#endif
1248
1249#if H_MV
1250      }
1251      nalu = NALUnit(NAL_UNIT_SPS, 0, getLayerId());
1252#else
1253      nalu = NALUnit(NAL_UNIT_SPS);
1254#endif
1255      m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
1256      if (m_bSeqFirst)
1257      {
1258        pcSlice->getSPS()->setNumLongTermRefPicSPS(m_numLongTermRefPicSPS);
1259        for (Int k = 0; k < m_numLongTermRefPicSPS; k++)
1260        {
1261          pcSlice->getSPS()->setLtRefPicPocLsbSps(k, m_ltRefPicPocLsbSps[k]);
1262          pcSlice->getSPS()->setUsedByCurrPicLtSPSFlag(k, m_ltRefPicUsedByCurrPicFlag[k]);
1263        }
1264      }
1265      if( m_pcCfg->getPictureTimingSEIEnabled() || m_pcCfg->getDecodingUnitInfoSEIEnabled() )
1266      {
1267        UInt maxCU = m_pcCfg->getSliceArgument() >> ( pcSlice->getSPS()->getMaxCUDepth() << 1);
1268        UInt numDU = ( m_pcCfg->getSliceMode() == 1 ) ? ( pcPic->getNumCUsInFrame() / maxCU ) : ( 0 );
1269        if( pcPic->getNumCUsInFrame() % maxCU != 0 || numDU == 0 )
1270        {
1271          numDU ++;
1272        }
1273        pcSlice->getSPS()->getVuiParameters()->getHrdParameters()->setNumDU( numDU );
1274        pcSlice->getSPS()->setHrdParameters( m_pcCfg->getFrameRate(), numDU, m_pcCfg->getTargetBitrate(), ( m_pcCfg->getIntraPeriod() > 0 ) );
1275      }
1276      if( m_pcCfg->getBufferingPeriodSEIEnabled() || m_pcCfg->getPictureTimingSEIEnabled() || m_pcCfg->getDecodingUnitInfoSEIEnabled() )
1277      {
1278        pcSlice->getSPS()->getVuiParameters()->setHrdParametersPresentFlag( true );
1279      }
1280#if !H_3D
1281      m_pcEntropyCoder->encodeSPS(pcSlice->getSPS());
1282#else
1283      m_pcEntropyCoder->encodeSPS(pcSlice->getSPS(), pcSlice->getViewIndex(), pcSlice->getIsDepth() );
1284#endif
1285      writeRBSPTrailingBits(nalu.m_Bitstream);
1286      accessUnit.push_back(new NALUnitEBSP(nalu));
1287#if RATE_CONTROL_LAMBDA_DOMAIN
1288      actualTotalBits += UInt(accessUnit.back()->m_nalUnitData.str().size()) * 8;
1289#endif
1290
1291#if H_MV
1292      nalu = NALUnit(NAL_UNIT_PPS, 0, getLayerId());
1293#else
1294      nalu = NALUnit(NAL_UNIT_PPS);
1295#endif
1296      m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
1297      m_pcEntropyCoder->encodePPS(pcSlice->getPPS());
1298      writeRBSPTrailingBits(nalu.m_Bitstream);
1299      accessUnit.push_back(new NALUnitEBSP(nalu));
1300#if RATE_CONTROL_LAMBDA_DOMAIN
1301      actualTotalBits += UInt(accessUnit.back()->m_nalUnitData.str().size()) * 8;
1302#endif
1303
1304      xCreateLeadingSEIMessages(accessUnit, pcSlice->getSPS());
1305
1306      m_bSeqFirst = false;
1307    }
1308
1309    if (writeSOP) // write SOP description SEI (if enabled) at the beginning of GOP
1310    {
1311      Int SOPcurrPOC = pocCurr;
1312
1313      OutputNALUnit nalu(NAL_UNIT_PREFIX_SEI);
1314      m_pcEntropyCoder->setEntropyCoder(m_pcCavlcCoder, pcSlice);
1315      m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
1316
1317      SEISOPDescription SOPDescriptionSEI;
1318      SOPDescriptionSEI.m_sopSeqParameterSetId = pcSlice->getSPS()->getSPSId();
1319
1320      UInt i = 0;
1321      UInt prevEntryId = iGOPid;
1322      for (j = iGOPid; j < m_iGopSize; j++)
1323      {
1324        Int deltaPOC = m_pcCfg->getGOPEntry(j).m_POC - m_pcCfg->getGOPEntry(prevEntryId).m_POC;
1325        if ((SOPcurrPOC + deltaPOC) < m_pcCfg->getFramesToBeEncoded())
1326        {
1327          SOPcurrPOC += deltaPOC;
1328          SOPDescriptionSEI.m_sopDescVclNaluType[i] = getNalUnitType(SOPcurrPOC, m_iLastIDR);
1329          SOPDescriptionSEI.m_sopDescTemporalId[i] = m_pcCfg->getGOPEntry(j).m_temporalId;
1330          SOPDescriptionSEI.m_sopDescStRpsIdx[i] = m_pcEncTop->getReferencePictureSetIdxForSOP(pcSlice, SOPcurrPOC, j);
1331          SOPDescriptionSEI.m_sopDescPocDelta[i] = deltaPOC;
1332
1333          prevEntryId = j;
1334          i++;
1335        }
1336      }
1337
1338      SOPDescriptionSEI.m_numPicsInSopMinus1 = i - 1;
1339
1340      m_seiWriter.writeSEImessage( nalu.m_Bitstream, SOPDescriptionSEI, pcSlice->getSPS());
1341      writeRBSPTrailingBits(nalu.m_Bitstream);
1342      accessUnit.push_back(new NALUnitEBSP(nalu));
1343
1344      writeSOP = false;
1345    }
1346
1347    if( ( m_pcCfg->getPictureTimingSEIEnabled() || m_pcCfg->getDecodingUnitInfoSEIEnabled() ) &&
1348        ( pcSlice->getSPS()->getVuiParametersPresentFlag() ) &&
1349        ( ( pcSlice->getSPS()->getVuiParameters()->getHrdParameters()->getNalHrdParametersPresentFlag() ) 
1350       || ( pcSlice->getSPS()->getVuiParameters()->getHrdParameters()->getVclHrdParametersPresentFlag() ) ) )
1351    {
1352      if( pcSlice->getSPS()->getVuiParameters()->getHrdParameters()->getSubPicCpbParamsPresentFlag() )
1353      {
1354        UInt numDU = pcSlice->getSPS()->getVuiParameters()->getHrdParameters()->getNumDU();
1355        pictureTimingSEI.m_numDecodingUnitsMinus1     = ( numDU - 1 );
1356        pictureTimingSEI.m_duCommonCpbRemovalDelayFlag = false;
1357
1358        if( pictureTimingSEI.m_numNalusInDuMinus1 == NULL )
1359        {
1360          pictureTimingSEI.m_numNalusInDuMinus1       = new UInt[ numDU ];
1361        }
1362        if( pictureTimingSEI.m_duCpbRemovalDelayMinus1  == NULL )
1363        {
1364          pictureTimingSEI.m_duCpbRemovalDelayMinus1  = new UInt[ numDU ];
1365        }
1366        if( accumBitsDU == NULL )
1367        {
1368          accumBitsDU                                  = new UInt[ numDU ];
1369        }
1370        if( accumNalsDU == NULL )
1371        {
1372          accumNalsDU                                  = new UInt[ numDU ];
1373        }
1374      }
1375      pictureTimingSEI.m_auCpbRemovalDelay = std::min<Int>(std::max<Int>(1, m_totalCoded - m_lastBPSEI), static_cast<Int>(pow(2, static_cast<double>(pcSlice->getSPS()->getVuiParameters()->getHrdParameters()->getCpbRemovalDelayLengthMinus1()+1)))); // Syntax element signalled as minus, hence the .
1376      pictureTimingSEI.m_picDpbOutputDelay = pcSlice->getSPS()->getNumReorderPics(0) + pcSlice->getPOC() - m_totalCoded;
1377      Int factor = pcSlice->getSPS()->getVuiParameters()->getHrdParameters()->getTickDivisorMinus2() + 2;
1378      pictureTimingSEI.m_picDpbOutputDuDelay = factor * pictureTimingSEI.m_picDpbOutputDelay;
1379      if( m_pcCfg->getDecodingUnitInfoSEIEnabled() )
1380      {
1381        picSptDpbOutputDuDelay = factor * pictureTimingSEI.m_picDpbOutputDelay;
1382      }
1383    }
1384
1385    if( ( m_pcCfg->getBufferingPeriodSEIEnabled() ) && ( pcSlice->getSliceType() == I_SLICE ) &&
1386        ( pcSlice->getSPS()->getVuiParametersPresentFlag() ) && 
1387        ( ( pcSlice->getSPS()->getVuiParameters()->getHrdParameters()->getNalHrdParametersPresentFlag() ) 
1388       || ( pcSlice->getSPS()->getVuiParameters()->getHrdParameters()->getVclHrdParametersPresentFlag() ) ) )
1389    {
1390      OutputNALUnit nalu(NAL_UNIT_PREFIX_SEI);
1391      m_pcEntropyCoder->setEntropyCoder(m_pcCavlcCoder, pcSlice);
1392      m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
1393
1394      SEIBufferingPeriod sei_buffering_period;
1395     
1396      UInt uiInitialCpbRemovalDelay = (90000/2);                      // 0.5 sec
1397      sei_buffering_period.m_initialCpbRemovalDelay      [0][0]     = uiInitialCpbRemovalDelay;
1398      sei_buffering_period.m_initialCpbRemovalDelayOffset[0][0]     = uiInitialCpbRemovalDelay;
1399      sei_buffering_period.m_initialCpbRemovalDelay      [0][1]     = uiInitialCpbRemovalDelay;
1400      sei_buffering_period.m_initialCpbRemovalDelayOffset[0][1]     = uiInitialCpbRemovalDelay;
1401
1402      Double dTmp = (Double)pcSlice->getSPS()->getVuiParameters()->getTimingInfo()->getNumUnitsInTick() / (Double)pcSlice->getSPS()->getVuiParameters()->getTimingInfo()->getTimeScale();
1403
1404      UInt uiTmp = (UInt)( dTmp * 90000.0 ); 
1405      uiInitialCpbRemovalDelay -= uiTmp;
1406      uiInitialCpbRemovalDelay -= uiTmp / ( pcSlice->getSPS()->getVuiParameters()->getHrdParameters()->getTickDivisorMinus2() + 2 );
1407      sei_buffering_period.m_initialAltCpbRemovalDelay      [0][0]  = uiInitialCpbRemovalDelay;
1408      sei_buffering_period.m_initialAltCpbRemovalDelayOffset[0][0]  = uiInitialCpbRemovalDelay;
1409      sei_buffering_period.m_initialAltCpbRemovalDelay      [0][1]  = uiInitialCpbRemovalDelay;
1410      sei_buffering_period.m_initialAltCpbRemovalDelayOffset[0][1]  = uiInitialCpbRemovalDelay;
1411
1412      sei_buffering_period.m_rapCpbParamsPresentFlag              = 0;
1413      //for the concatenation, it can be set to one during splicing.
1414      sei_buffering_period.m_concatenationFlag = 0;
1415      //since the temporal layer HRD is not ready, we assumed it is fixed
1416      sei_buffering_period.m_auCpbRemovalDelayDelta = 1;
1417      sei_buffering_period.m_cpbDelayOffset = 0;
1418      sei_buffering_period.m_dpbDelayOffset = 0;
1419
1420      m_seiWriter.writeSEImessage( nalu.m_Bitstream, sei_buffering_period, pcSlice->getSPS());
1421      writeRBSPTrailingBits(nalu.m_Bitstream);
1422      {
1423      UInt seiPositionInAu = xGetFirstSeiLocation(accessUnit);
1424      UInt offsetPosition = m_activeParameterSetSEIPresentInAU;   // Insert BP SEI after APS SEI
1425      AccessUnit::iterator it;
1426      for(j = 0, it = accessUnit.begin(); j < seiPositionInAu + offsetPosition; j++)
1427      {
1428        it++;
1429      }
1430      accessUnit.insert(it, new NALUnitEBSP(nalu));
1431      m_bufferingPeriodSEIPresentInAU = true;
1432      }
1433
1434      if (m_pcCfg->getScalableNestingSEIEnabled())
1435      {
1436        OutputNALUnit naluTmp(NAL_UNIT_PREFIX_SEI);
1437        m_pcEntropyCoder->setEntropyCoder(m_pcCavlcCoder, pcSlice);
1438        m_pcEntropyCoder->setBitstream(&naluTmp.m_Bitstream);
1439        scalableNestingSEI.m_nestedSEIs.clear();
1440        scalableNestingSEI.m_nestedSEIs.push_back(&sei_buffering_period);
1441        m_seiWriter.writeSEImessage( naluTmp.m_Bitstream, scalableNestingSEI, pcSlice->getSPS());
1442        writeRBSPTrailingBits(naluTmp.m_Bitstream);
1443        UInt seiPositionInAu = xGetFirstSeiLocation(accessUnit);
1444        UInt offsetPosition = m_activeParameterSetSEIPresentInAU + m_bufferingPeriodSEIPresentInAU + m_pictureTimingSEIPresentInAU;   // Insert BP SEI after non-nested APS, BP and PT SEIs
1445        AccessUnit::iterator it;
1446        for(j = 0, it = accessUnit.begin(); j < seiPositionInAu + offsetPosition; j++)
1447        {
1448          it++;
1449        }
1450        accessUnit.insert(it, new NALUnitEBSP(naluTmp));
1451        m_nestedBufferingPeriodSEIPresentInAU = true;
1452      }
1453
1454      m_lastBPSEI = m_totalCoded;
1455      m_cpbRemovalDelay = 0;
1456    }
1457    m_cpbRemovalDelay ++;
1458    if( ( m_pcEncTop->getRecoveryPointSEIEnabled() ) && ( pcSlice->getSliceType() == I_SLICE ) )
1459    {
1460      if( m_pcEncTop->getGradualDecodingRefreshInfoEnabled() && !pcSlice->getRapPicFlag() )
1461      {
1462        // Gradual decoding refresh SEI
1463        OutputNALUnit nalu(NAL_UNIT_PREFIX_SEI);
1464        m_pcEntropyCoder->setEntropyCoder(m_pcCavlcCoder, pcSlice);
1465        m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
1466
1467        SEIGradualDecodingRefreshInfo seiGradualDecodingRefreshInfo;
1468        seiGradualDecodingRefreshInfo.m_gdrForegroundFlag = true; // Indicating all "foreground"
1469
1470        m_seiWriter.writeSEImessage( nalu.m_Bitstream, seiGradualDecodingRefreshInfo, pcSlice->getSPS() );
1471        writeRBSPTrailingBits(nalu.m_Bitstream);
1472        accessUnit.push_back(new NALUnitEBSP(nalu));
1473      }
1474    // Recovery point SEI
1475      OutputNALUnit nalu(NAL_UNIT_PREFIX_SEI);
1476      m_pcEntropyCoder->setEntropyCoder(m_pcCavlcCoder, pcSlice);
1477      m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
1478
1479      SEIRecoveryPoint sei_recovery_point;
1480      sei_recovery_point.m_recoveryPocCnt    = 0;
1481      sei_recovery_point.m_exactMatchingFlag = ( pcSlice->getPOC() == 0 ) ? (true) : (false);
1482      sei_recovery_point.m_brokenLinkFlag    = false;
1483
1484      m_seiWriter.writeSEImessage( nalu.m_Bitstream, sei_recovery_point, pcSlice->getSPS() );
1485      writeRBSPTrailingBits(nalu.m_Bitstream);
1486      accessUnit.push_back(new NALUnitEBSP(nalu));
1487    }
1488
1489    /* use the main bitstream buffer for storing the marshalled picture */
1490    m_pcEntropyCoder->setBitstream(NULL);
1491
1492    startCUAddrSliceIdx = 0;
1493    startCUAddrSlice    = 0; 
1494
1495    startCUAddrSliceSegmentIdx = 0;
1496    startCUAddrSliceSegment    = 0; 
1497    nextCUAddr                 = 0;
1498    pcSlice = pcPic->getSlice(startCUAddrSliceIdx);
1499
1500    Int processingState = (pcSlice->getSPS()->getUseSAO())?(EXECUTE_INLOOPFILTER):(ENCODE_SLICE);
1501    Bool skippedSlice=false;
1502    while (nextCUAddr < uiRealEndAddress) // Iterate over all slices
1503    {
1504      switch(processingState)
1505      {
1506      case ENCODE_SLICE:
1507        {
1508          pcSlice->setNextSlice       ( false );
1509          pcSlice->setNextSliceSegment( false );
1510          if (nextCUAddr == m_storedStartCUAddrForEncodingSlice[startCUAddrSliceIdx])
1511          {
1512            pcSlice = pcPic->getSlice(startCUAddrSliceIdx);
1513            if(startCUAddrSliceIdx > 0 && pcSlice->getSliceType()!= I_SLICE)
1514            {
1515              pcSlice->checkColRefIdx(startCUAddrSliceIdx, pcPic);
1516            }
1517            pcPic->setCurrSliceIdx(startCUAddrSliceIdx);
1518            m_pcSliceEncoder->setSliceIdx(startCUAddrSliceIdx);
1519            assert(startCUAddrSliceIdx == pcSlice->getSliceIdx());
1520            // Reconstruction slice
1521            pcSlice->setSliceCurStartCUAddr( nextCUAddr );  // to be used in encodeSlice() + context restriction
1522            pcSlice->setSliceCurEndCUAddr  ( m_storedStartCUAddrForEncodingSlice[startCUAddrSliceIdx+1 ] );
1523            // Dependent slice
1524            pcSlice->setSliceSegmentCurStartCUAddr( nextCUAddr );  // to be used in encodeSlice() + context restriction
1525            pcSlice->setSliceSegmentCurEndCUAddr  ( m_storedStartCUAddrForEncodingSliceSegment[startCUAddrSliceSegmentIdx+1 ] );
1526
1527            pcSlice->setNextSlice       ( true );
1528
1529            startCUAddrSliceIdx++;
1530            startCUAddrSliceSegmentIdx++;
1531          } 
1532          else if (nextCUAddr == m_storedStartCUAddrForEncodingSliceSegment[startCUAddrSliceSegmentIdx])
1533          {
1534            // Dependent slice
1535            pcSlice->setSliceSegmentCurStartCUAddr( nextCUAddr );  // to be used in encodeSlice() + context restriction
1536            pcSlice->setSliceSegmentCurEndCUAddr  ( m_storedStartCUAddrForEncodingSliceSegment[startCUAddrSliceSegmentIdx+1 ] );
1537
1538            pcSlice->setNextSliceSegment( true );
1539
1540            startCUAddrSliceSegmentIdx++;
1541          }
1542
1543          pcSlice->setRPS(pcPic->getSlice(0)->getRPS());
1544          pcSlice->setRPSidx(pcPic->getSlice(0)->getRPSidx());
1545          UInt uiDummyStartCUAddr;
1546          UInt uiDummyBoundingCUAddr;
1547          m_pcSliceEncoder->xDetermineStartAndBoundingCUAddr(uiDummyStartCUAddr,uiDummyBoundingCUAddr,pcPic,true);
1548
1549          uiInternalAddress = pcPic->getPicSym()->getPicSCUAddr(pcSlice->getSliceSegmentCurEndCUAddr()-1) % pcPic->getNumPartInCU();
1550          uiExternalAddress = pcPic->getPicSym()->getPicSCUAddr(pcSlice->getSliceSegmentCurEndCUAddr()-1) / pcPic->getNumPartInCU();
1551          uiPosX = ( uiExternalAddress % pcPic->getFrameWidthInCU() ) * g_uiMaxCUWidth+ g_auiRasterToPelX[ g_auiZscanToRaster[uiInternalAddress] ];
1552          uiPosY = ( uiExternalAddress / pcPic->getFrameWidthInCU() ) * g_uiMaxCUHeight+ g_auiRasterToPelY[ g_auiZscanToRaster[uiInternalAddress] ];
1553          uiWidth = pcSlice->getSPS()->getPicWidthInLumaSamples();
1554          uiHeight = pcSlice->getSPS()->getPicHeightInLumaSamples();
1555          while(uiPosX>=uiWidth||uiPosY>=uiHeight)
1556          {
1557            uiInternalAddress--;
1558            uiPosX = ( uiExternalAddress % pcPic->getFrameWidthInCU() ) * g_uiMaxCUWidth+ g_auiRasterToPelX[ g_auiZscanToRaster[uiInternalAddress] ];
1559            uiPosY = ( uiExternalAddress / pcPic->getFrameWidthInCU() ) * g_uiMaxCUHeight+ g_auiRasterToPelY[ g_auiZscanToRaster[uiInternalAddress] ];
1560          }
1561          uiInternalAddress++;
1562          if(uiInternalAddress==pcPic->getNumPartInCU())
1563          {
1564            uiInternalAddress = 0;
1565            uiExternalAddress = pcPic->getPicSym()->getCUOrderMap(pcPic->getPicSym()->getInverseCUOrderMap(uiExternalAddress)+1);
1566          }
1567          UInt endAddress = pcPic->getPicSym()->getPicSCUEncOrder(uiExternalAddress*pcPic->getNumPartInCU()+uiInternalAddress);
1568          if(endAddress<=pcSlice->getSliceSegmentCurStartCUAddr()) 
1569          {
1570            UInt boundingAddrSlice, boundingAddrSliceSegment;
1571            boundingAddrSlice          = m_storedStartCUAddrForEncodingSlice[startCUAddrSliceIdx];         
1572            boundingAddrSliceSegment = m_storedStartCUAddrForEncodingSliceSegment[startCUAddrSliceSegmentIdx];         
1573            nextCUAddr               = min(boundingAddrSlice, boundingAddrSliceSegment);
1574            if(pcSlice->isNextSlice())
1575            {
1576              skippedSlice=true;
1577            }
1578            continue;
1579          }
1580          if(skippedSlice) 
1581          {
1582            pcSlice->setNextSlice       ( true );
1583            pcSlice->setNextSliceSegment( false );
1584          }
1585          skippedSlice=false;
1586          pcSlice->allocSubstreamSizes( iNumSubstreams );
1587          for ( UInt ui = 0 ; ui < iNumSubstreams; ui++ )
1588          {
1589            pcSubstreamsOut[ui].clear();
1590          }
1591
1592          m_pcEntropyCoder->setEntropyCoder   ( m_pcCavlcCoder, pcSlice );
1593          m_pcEntropyCoder->resetEntropy      ();
1594          /* start slice NALunit */
1595#if H_MV
1596          OutputNALUnit nalu( pcSlice->getNalUnitType(), pcSlice->getTLayer(), getLayerId() );
1597#else
1598          OutputNALUnit nalu( pcSlice->getNalUnitType(), pcSlice->getTLayer() );
1599#endif
1600          Bool sliceSegment = (!pcSlice->isNextSlice());
1601          if (!sliceSegment)
1602          {
1603            uiOneBitstreamPerSliceLength = 0; // start of a new slice
1604          }
1605          m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
1606#if RATE_CONTROL_LAMBDA_DOMAIN
1607          tmpBitsBeforeWriting = m_pcEntropyCoder->getNumberOfWrittenBits();
1608#endif
1609          m_pcEntropyCoder->encodeSliceHeader(pcSlice);
1610#if RATE_CONTROL_LAMBDA_DOMAIN
1611          actualHeadBits += ( m_pcEntropyCoder->getNumberOfWrittenBits() - tmpBitsBeforeWriting );
1612#endif
1613
1614          // is it needed?
1615          {
1616            if (!sliceSegment)
1617            {
1618              pcBitstreamRedirect->writeAlignOne();
1619            }
1620            else
1621            {
1622              // We've not completed our slice header info yet, do the alignment later.
1623            }
1624            m_pcSbacCoder->init( (TEncBinIf*)m_pcBinCABAC );
1625            m_pcEntropyCoder->setEntropyCoder ( m_pcSbacCoder, pcSlice );
1626            m_pcEntropyCoder->resetEntropy    ();
1627            for ( UInt ui = 0 ; ui < pcSlice->getPPS()->getNumSubstreams() ; ui++ )
1628            {
1629              m_pcEntropyCoder->setEntropyCoder ( &pcSbacCoders[ui], pcSlice );
1630              m_pcEntropyCoder->resetEntropy    ();
1631            }
1632          }
1633
1634          if(pcSlice->isNextSlice())
1635          {
1636            // set entropy coder for writing
1637            m_pcSbacCoder->init( (TEncBinIf*)m_pcBinCABAC );
1638            {
1639              for ( UInt ui = 0 ; ui < pcSlice->getPPS()->getNumSubstreams() ; ui++ )
1640              {
1641                m_pcEntropyCoder->setEntropyCoder ( &pcSbacCoders[ui], pcSlice );
1642                m_pcEntropyCoder->resetEntropy    ();
1643              }
1644              pcSbacCoders[0].load(m_pcSbacCoder);
1645              m_pcEntropyCoder->setEntropyCoder ( &pcSbacCoders[0], pcSlice );  //ALF is written in substream #0 with CABAC coder #0 (see ALF param encoding below)
1646            }
1647            m_pcEntropyCoder->resetEntropy    ();
1648            // File writing
1649            if (!sliceSegment)
1650            {
1651              m_pcEntropyCoder->setBitstream(pcBitstreamRedirect);
1652            }
1653            else
1654            {
1655              m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
1656            }
1657            // for now, override the TILES_DECODER setting in order to write substreams.
1658            m_pcEntropyCoder->setBitstream    ( &pcSubstreamsOut[0] );
1659
1660          }
1661          pcSlice->setFinalized(true);
1662
1663          m_pcSbacCoder->load( &pcSbacCoders[0] );
1664
1665          pcSlice->setTileOffstForMultES( uiOneBitstreamPerSliceLength );
1666            pcSlice->setTileLocationCount ( 0 );
1667          m_pcSliceEncoder->encodeSlice(pcPic, pcSubstreamsOut);
1668
1669          {
1670            // Construct the final bitstream by flushing and concatenating substreams.
1671            // The final bitstream is either nalu.m_Bitstream or pcBitstreamRedirect;
1672            UInt* puiSubstreamSizes = pcSlice->getSubstreamSizes();
1673            UInt uiTotalCodedSize = 0; // for padding calcs.
1674            UInt uiNumSubstreamsPerTile = iNumSubstreams;
1675            if (iNumSubstreams > 1)
1676            {
1677              uiNumSubstreamsPerTile /= pcPic->getPicSym()->getNumTiles();
1678            }
1679            for ( UInt ui = 0 ; ui < iNumSubstreams; ui++ )
1680            {
1681              // Flush all substreams -- this includes empty ones.
1682              // Terminating bit and flush.
1683              m_pcEntropyCoder->setEntropyCoder   ( &pcSbacCoders[ui], pcSlice );
1684              m_pcEntropyCoder->setBitstream      (  &pcSubstreamsOut[ui] );
1685              m_pcEntropyCoder->encodeTerminatingBit( 1 );
1686              m_pcEntropyCoder->encodeSliceFinish();
1687
1688              pcSubstreamsOut[ui].writeByteAlignment();   // Byte-alignment in slice_data() at end of sub-stream
1689              // Byte alignment is necessary between tiles when tiles are independent.
1690              uiTotalCodedSize += pcSubstreamsOut[ui].getNumberOfWrittenBits();
1691
1692              Bool bNextSubstreamInNewTile = ((ui+1) < iNumSubstreams)&& ((ui+1)%uiNumSubstreamsPerTile == 0);
1693              if (bNextSubstreamInNewTile)
1694              {
1695                pcSlice->setTileLocation(ui/uiNumSubstreamsPerTile, pcSlice->getTileOffstForMultES()+(uiTotalCodedSize>>3));
1696              }
1697              if (ui+1 < pcSlice->getPPS()->getNumSubstreams())
1698              {
1699                puiSubstreamSizes[ui] = pcSubstreamsOut[ui].getNumberOfWrittenBits() + (pcSubstreamsOut[ui].countStartCodeEmulations()<<3);
1700              }
1701            }
1702
1703            // Complete the slice header info.
1704            m_pcEntropyCoder->setEntropyCoder   ( m_pcCavlcCoder, pcSlice );
1705            m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
1706            m_pcEntropyCoder->encodeTilesWPPEntryPoint( pcSlice );
1707
1708            // Substreams...
1709            TComOutputBitstream *pcOut = pcBitstreamRedirect;
1710          Int offs = 0;
1711          Int nss = pcSlice->getPPS()->getNumSubstreams();
1712          if (pcSlice->getPPS()->getEntropyCodingSyncEnabledFlag())
1713          {
1714            // 1st line present for WPP.
1715            offs = pcSlice->getSliceSegmentCurStartCUAddr()/pcSlice->getPic()->getNumPartInCU()/pcSlice->getPic()->getFrameWidthInCU();
1716            nss  = pcSlice->getNumEntryPointOffsets()+1;
1717          }
1718          for ( UInt ui = 0 ; ui < nss; ui++ )
1719          {
1720            pcOut->addSubstream(&pcSubstreamsOut[ui+offs]);
1721            }
1722          }
1723
1724          UInt boundingAddrSlice, boundingAddrSliceSegment;
1725          boundingAddrSlice        = m_storedStartCUAddrForEncodingSlice[startCUAddrSliceIdx];         
1726          boundingAddrSliceSegment = m_storedStartCUAddrForEncodingSliceSegment[startCUAddrSliceSegmentIdx];         
1727          nextCUAddr               = min(boundingAddrSlice, boundingAddrSliceSegment);
1728          // If current NALU is the first NALU of slice (containing slice header) and more NALUs exist (due to multiple dependent slices) then buffer it.
1729          // If current NALU is the last NALU of slice and a NALU was buffered, then (a) Write current NALU (b) Update an write buffered NALU at approproate location in NALU list.
1730          Bool bNALUAlignedWrittenToList    = false; // used to ensure current NALU is not written more than once to the NALU list.
1731          xAttachSliceDataToNalUnit(nalu, pcBitstreamRedirect);
1732          accessUnit.push_back(new NALUnitEBSP(nalu));
1733#if RATE_CONTROL_LAMBDA_DOMAIN
1734          actualTotalBits += UInt(accessUnit.back()->m_nalUnitData.str().size()) * 8;
1735#endif
1736          bNALUAlignedWrittenToList = true; 
1737          uiOneBitstreamPerSliceLength += nalu.m_Bitstream.getNumberOfWrittenBits(); // length of bitstream after byte-alignment
1738
1739          if (!bNALUAlignedWrittenToList)
1740          {
1741            {
1742              nalu.m_Bitstream.writeAlignZero();
1743            }
1744            accessUnit.push_back(new NALUnitEBSP(nalu));
1745            uiOneBitstreamPerSliceLength += nalu.m_Bitstream.getNumberOfWrittenBits() + 24; // length of bitstream after byte-alignment + 3 byte startcode 0x000001
1746          }
1747
1748          if( ( m_pcCfg->getPictureTimingSEIEnabled() || m_pcCfg->getDecodingUnitInfoSEIEnabled() ) &&
1749              ( pcSlice->getSPS()->getVuiParametersPresentFlag() ) &&
1750              ( ( pcSlice->getSPS()->getVuiParameters()->getHrdParameters()->getNalHrdParametersPresentFlag() ) 
1751             || ( pcSlice->getSPS()->getVuiParameters()->getHrdParameters()->getVclHrdParametersPresentFlag() ) ) &&
1752              ( pcSlice->getSPS()->getVuiParameters()->getHrdParameters()->getSubPicCpbParamsPresentFlag() ) )
1753          {
1754              UInt numNalus = 0;
1755            UInt numRBSPBytes = 0;
1756            for (AccessUnit::const_iterator it = accessUnit.begin(); it != accessUnit.end(); it++)
1757            {
1758              UInt numRBSPBytes_nal = UInt((*it)->m_nalUnitData.str().size());
1759              if ((*it)->m_nalUnitType != NAL_UNIT_PREFIX_SEI && (*it)->m_nalUnitType != NAL_UNIT_SUFFIX_SEI)
1760              {
1761                numRBSPBytes += numRBSPBytes_nal;
1762                numNalus ++;
1763              }
1764            }
1765            accumBitsDU[ pcSlice->getSliceIdx() ] = ( numRBSPBytes << 3 );
1766            accumNalsDU[ pcSlice->getSliceIdx() ] = numNalus;   // SEI not counted for bit count; hence shouldn't be counted for # of NALUs - only for consistency
1767          }
1768          processingState = ENCODE_SLICE;
1769          }
1770          break;
1771        case EXECUTE_INLOOPFILTER:
1772          {
1773            // set entropy coder for RD
1774            m_pcEntropyCoder->setEntropyCoder ( m_pcSbacCoder, pcSlice );
1775            if ( pcSlice->getSPS()->getUseSAO() )
1776            {
1777              m_pcEntropyCoder->resetEntropy();
1778              m_pcEntropyCoder->setBitstream( m_pcBitCounter );
1779              m_pcSAO->startSaoEnc(pcPic, m_pcEntropyCoder, m_pcEncTop->getRDSbacCoder(), m_pcEncTop->getRDGoOnSbacCoder());
1780              SAOParam& cSaoParam = *pcSlice->getPic()->getPicSym()->getSaoParam();
1781
1782#if SAO_CHROMA_LAMBDA
1783#if SAO_ENCODING_CHOICE
1784              m_pcSAO->SAOProcess(&cSaoParam, pcPic->getSlice(0)->getLambdaLuma(), pcPic->getSlice(0)->getLambdaChroma(), pcPic->getSlice(0)->getDepth());
1785#else
1786              m_pcSAO->SAOProcess(&cSaoParam, pcPic->getSlice(0)->getLambdaLuma(), pcPic->getSlice(0)->getLambdaChroma());
1787#endif
1788#else
1789              m_pcSAO->SAOProcess(&cSaoParam, pcPic->getSlice(0)->getLambda());
1790#endif
1791              m_pcSAO->endSaoEnc();
1792              m_pcSAO->PCMLFDisableProcess(pcPic);
1793            }
1794#if SAO_RDO
1795            m_pcEntropyCoder->setEntropyCoder ( m_pcCavlcCoder, pcSlice );
1796#endif
1797            processingState = ENCODE_SLICE;
1798
1799            for(Int s=0; s< uiNumSlices; s++)
1800            {
1801              if (pcSlice->getSPS()->getUseSAO())
1802              {
1803                pcPic->getSlice(s)->setSaoEnabledFlag((pcSlice->getPic()->getPicSym()->getSaoParam()->bSaoFlag[0]==1)?true:false);
1804              }
1805            }
1806          }
1807          break;
1808        default:
1809          {
1810            printf("Not a supported encoding state\n");
1811            assert(0);
1812            exit(-1);
1813          }
1814        }
1815      } // end iteration over slices
1816
1817      if(pcSlice->getSPS()->getUseSAO())
1818      {
1819        if(pcSlice->getSPS()->getUseSAO())
1820        {
1821          m_pcSAO->destroyPicSaoInfo();
1822        }
1823        pcPic->destroyNonDBFilterInfo();
1824      }
1825#if H_3D
1826      pcPic->compressMotion(2); 
1827#endif
1828#if !H_3D
1829      pcPic->compressMotion(); 
1830#endif
1831#if H_MV
1832      m_pocLastCoded = pcPic->getPOC();
1833#endif
1834
1835      //-- For time output for each slice
1836      Double dEncTime = (Double)(clock()-iBeforeTime) / CLOCKS_PER_SEC;
1837
1838      const Char* digestStr = NULL;
1839      if (m_pcCfg->getDecodedPictureHashSEIEnabled())
1840      {
1841        /* calculate MD5sum for entire reconstructed picture */
1842        SEIDecodedPictureHash sei_recon_picture_digest;
1843        if(m_pcCfg->getDecodedPictureHashSEIEnabled() == 1)
1844        {
1845          sei_recon_picture_digest.method = SEIDecodedPictureHash::MD5;
1846          calcMD5(*pcPic->getPicYuvRec(), sei_recon_picture_digest.digest);
1847          digestStr = digestToString(sei_recon_picture_digest.digest, 16);
1848        }
1849        else if(m_pcCfg->getDecodedPictureHashSEIEnabled() == 2)
1850        {
1851          sei_recon_picture_digest.method = SEIDecodedPictureHash::CRC;
1852          calcCRC(*pcPic->getPicYuvRec(), sei_recon_picture_digest.digest);
1853          digestStr = digestToString(sei_recon_picture_digest.digest, 2);
1854        }
1855        else if(m_pcCfg->getDecodedPictureHashSEIEnabled() == 3)
1856        {
1857          sei_recon_picture_digest.method = SEIDecodedPictureHash::CHECKSUM;
1858          calcChecksum(*pcPic->getPicYuvRec(), sei_recon_picture_digest.digest);
1859          digestStr = digestToString(sei_recon_picture_digest.digest, 4);
1860        }
1861#if H_MV
1862        OutputNALUnit nalu(NAL_UNIT_SUFFIX_SEI, pcSlice->getTLayer(), getLayerId() );
1863#else
1864        OutputNALUnit nalu(NAL_UNIT_SUFFIX_SEI, pcSlice->getTLayer());
1865#endif
1866
1867        /* write the SEI messages */
1868        m_pcEntropyCoder->setEntropyCoder(m_pcCavlcCoder, pcSlice);
1869        m_seiWriter.writeSEImessage(nalu.m_Bitstream, sei_recon_picture_digest, pcSlice->getSPS());
1870        writeRBSPTrailingBits(nalu.m_Bitstream);
1871
1872        accessUnit.insert(accessUnit.end(), new NALUnitEBSP(nalu));
1873      }
1874      if (m_pcCfg->getTemporalLevel0IndexSEIEnabled())
1875      {
1876        SEITemporalLevel0Index sei_temporal_level0_index;
1877        if (pcSlice->getRapPicFlag())
1878        {
1879          m_tl0Idx = 0;
1880          m_rapIdx = (m_rapIdx + 1) & 0xFF;
1881        }
1882        else
1883        {
1884          m_tl0Idx = (m_tl0Idx + (pcSlice->getTLayer() ? 0 : 1)) & 0xFF;
1885        }
1886        sei_temporal_level0_index.tl0Idx = m_tl0Idx;
1887        sei_temporal_level0_index.rapIdx = m_rapIdx;
1888
1889        OutputNALUnit nalu(NAL_UNIT_PREFIX_SEI); 
1890
1891        /* write the SEI messages */
1892        m_pcEntropyCoder->setEntropyCoder(m_pcCavlcCoder, pcSlice);
1893        m_seiWriter.writeSEImessage(nalu.m_Bitstream, sei_temporal_level0_index, pcSlice->getSPS());
1894        writeRBSPTrailingBits(nalu.m_Bitstream);
1895
1896        /* insert the SEI message NALUnit before any Slice NALUnits */
1897        AccessUnit::iterator it = find_if(accessUnit.begin(), accessUnit.end(), mem_fun(&NALUnit::isSlice));
1898        accessUnit.insert(it, new NALUnitEBSP(nalu));
1899      }
1900
1901      xCalculateAddPSNR( pcPic, pcPic->getPicYuvRec(), accessUnit, dEncTime );
1902
1903    //In case of field coding, compute the interlaced PSNR for both fields
1904    if (isField && ((!pcPic->isTopField() && isTff) || (pcPic->isTopField() && !isTff)))
1905    {
1906      //get complementary top field
1907      TComPic* pcPicTop;
1908      TComList<TComPic*>::iterator   iterPic = rcListPic.begin();
1909      while ((*iterPic)->getPOC() != pcPic->getPOC()-1)
1910      {
1911        iterPic ++;
1912      }
1913      pcPicTop = *(iterPic);
1914      xCalculateInterlacedAddPSNR(pcPicTop, pcPic, pcPicTop->getPicYuvRec(), pcPic->getPicYuvRec(), accessUnit, dEncTime );
1915    }
1916   
1917      if (digestStr)
1918      {
1919        if(m_pcCfg->getDecodedPictureHashSEIEnabled() == 1)
1920        {
1921          printf(" [MD5:%s]", digestStr);
1922        }
1923        else if(m_pcCfg->getDecodedPictureHashSEIEnabled() == 2)
1924        {
1925          printf(" [CRC:%s]", digestStr);
1926        }
1927        else if(m_pcCfg->getDecodedPictureHashSEIEnabled() == 3)
1928        {
1929          printf(" [Checksum:%s]", digestStr);
1930        }
1931      }
1932#if RATE_CONTROL_LAMBDA_DOMAIN
1933      if ( m_pcCfg->getUseRateCtrl() )
1934      {
1935#if !M0036_RC_IMPROVEMENT
1936        Double effectivePercentage = m_pcRateCtrl->getRCPic()->getEffectivePercentage();
1937#endif
1938        Double avgQP     = m_pcRateCtrl->getRCPic()->calAverageQP();
1939        Double avgLambda = m_pcRateCtrl->getRCPic()->calAverageLambda();
1940        if ( avgLambda < 0.0 )
1941        {
1942          avgLambda = lambda;
1943        }
1944#if M0036_RC_IMPROVEMENT
1945#if RATE_CONTROL_INTRA
1946        m_pcRateCtrl->getRCPic()->updateAfterPicture( actualHeadBits, actualTotalBits, avgQP, avgLambda, pcSlice->getSliceType());
1947#else
1948        m_pcRateCtrl->getRCPic()->updateAfterPicture( actualHeadBits, actualTotalBits, avgQP, avgLambda );
1949#endif
1950#else
1951        m_pcRateCtrl->getRCPic()->updateAfterPicture( actualHeadBits, actualTotalBits, avgQP, avgLambda, effectivePercentage );
1952#endif
1953        m_pcRateCtrl->getRCPic()->addToPictureLsit( m_pcRateCtrl->getPicList() );
1954
1955        m_pcRateCtrl->getRCSeq()->updateAfterPic( actualTotalBits );
1956        if ( pcSlice->getSliceType() != I_SLICE )
1957        {
1958          m_pcRateCtrl->getRCGOP()->updateAfterPicture( actualTotalBits );
1959        }
1960        else    // for intra picture, the estimated bits are used to update the current status in the GOP
1961        {
1962          m_pcRateCtrl->getRCGOP()->updateAfterPicture( estimatedBits );
1963        }
1964      }
1965#else
1966      if(m_pcCfg->getUseRateCtrl())
1967      {
1968        UInt  frameBits = m_vRVM_RP[m_vRVM_RP.size()-1];
1969        m_pcRateCtrl->updataRCFrameStatus((Int)frameBits, pcSlice->getSliceType());
1970      }
1971#endif
1972
1973      if( ( m_pcCfg->getPictureTimingSEIEnabled() || m_pcCfg->getDecodingUnitInfoSEIEnabled() ) &&
1974          ( pcSlice->getSPS()->getVuiParametersPresentFlag() ) &&
1975          ( ( pcSlice->getSPS()->getVuiParameters()->getHrdParameters()->getNalHrdParametersPresentFlag() ) 
1976         || ( pcSlice->getSPS()->getVuiParameters()->getHrdParameters()->getVclHrdParametersPresentFlag() ) ) )
1977      {
1978        TComVUI *vui = pcSlice->getSPS()->getVuiParameters();
1979        TComHRD *hrd = vui->getHrdParameters();
1980
1981        if( hrd->getSubPicCpbParamsPresentFlag() )
1982        {
1983          Int i;
1984          UInt64 ui64Tmp;
1985          UInt uiPrev = 0;
1986          UInt numDU = ( pictureTimingSEI.m_numDecodingUnitsMinus1 + 1 );
1987          UInt *pCRD = &pictureTimingSEI.m_duCpbRemovalDelayMinus1[0];
1988          UInt maxDiff = ( hrd->getTickDivisorMinus2() + 2 ) - 1;
1989
1990          for( i = 0; i < numDU; i ++ )
1991          {
1992            pictureTimingSEI.m_numNalusInDuMinus1[ i ]       = ( i == 0 ) ? ( accumNalsDU[ i ] - 1 ) : ( accumNalsDU[ i ] - accumNalsDU[ i - 1] - 1 );
1993          }
1994
1995          if( numDU == 1 )
1996          {
1997            pCRD[ 0 ] = 0; /* don't care */
1998          }
1999          else
2000          {
2001            pCRD[ numDU - 1 ] = 0;/* by definition */
2002            UInt tmp = 0;
2003            UInt accum = 0;
2004
2005            for( i = ( numDU - 2 ); i >= 0; i -- )
2006            {
2007              ui64Tmp = ( ( ( accumBitsDU[ numDU - 1 ]  - accumBitsDU[ i ] ) * ( vui->getTimingInfo()->getTimeScale() / vui->getTimingInfo()->getNumUnitsInTick() ) * ( hrd->getTickDivisorMinus2() + 2 ) ) / ( m_pcCfg->getTargetBitrate() ) );
2008              if( (UInt)ui64Tmp > maxDiff )
2009              {
2010                tmp ++;
2011              }
2012            }
2013            uiPrev = 0;
2014
2015            UInt flag = 0;
2016            for( i = ( numDU - 2 ); i >= 0; i -- )
2017            {
2018              flag = 0;
2019              ui64Tmp = ( ( ( accumBitsDU[ numDU - 1 ]  - accumBitsDU[ i ] ) * ( vui->getTimingInfo()->getTimeScale() / vui->getTimingInfo()->getNumUnitsInTick() ) * ( hrd->getTickDivisorMinus2() + 2 ) ) / ( m_pcCfg->getTargetBitrate() ) );
2020
2021              if( (UInt)ui64Tmp > maxDiff )
2022              {
2023                if(uiPrev >= maxDiff - tmp)
2024                {
2025                  ui64Tmp = uiPrev + 1;
2026                  flag = 1;
2027                }
2028                else                            ui64Tmp = maxDiff - tmp + 1;
2029              }
2030              pCRD[ i ] = (UInt)ui64Tmp - uiPrev - 1;
2031              if( (Int)pCRD[ i ] < 0 )
2032              {
2033                pCRD[ i ] = 0;
2034              }
2035              else if (tmp > 0 && flag == 1) 
2036              {
2037                tmp --;
2038              }
2039              accum += pCRD[ i ] + 1;
2040              uiPrev = accum;
2041            }
2042          }
2043        }
2044        if( m_pcCfg->getPictureTimingSEIEnabled() )
2045        {
2046          {
2047            OutputNALUnit nalu(NAL_UNIT_PREFIX_SEI, pcSlice->getTLayer());
2048          m_pcEntropyCoder->setEntropyCoder(m_pcCavlcCoder, pcSlice);
2049          pictureTimingSEI.m_picStruct = (isField && pcSlice->getPic()->isTopField())? 1 : isField? 2 : 0;
2050          m_seiWriter.writeSEImessage(nalu.m_Bitstream, pictureTimingSEI, pcSlice->getSPS());
2051          writeRBSPTrailingBits(nalu.m_Bitstream);
2052          UInt seiPositionInAu = xGetFirstSeiLocation(accessUnit);
2053          UInt offsetPosition = m_activeParameterSetSEIPresentInAU
2054                                    + m_bufferingPeriodSEIPresentInAU;    // Insert PT SEI after APS and BP SEI
2055          AccessUnit::iterator it;
2056          for(j = 0, it = accessUnit.begin(); j < seiPositionInAu + offsetPosition; j++)
2057          {
2058            it++;
2059          }
2060          accessUnit.insert(it, new NALUnitEBSP(nalu));
2061          m_pictureTimingSEIPresentInAU = true;
2062        }
2063          if ( m_pcCfg->getScalableNestingSEIEnabled() ) // put picture timing SEI into scalable nesting SEI
2064          {
2065            OutputNALUnit nalu(NAL_UNIT_PREFIX_SEI, pcSlice->getTLayer());
2066            m_pcEntropyCoder->setEntropyCoder(m_pcCavlcCoder, pcSlice);
2067            scalableNestingSEI.m_nestedSEIs.clear();
2068            scalableNestingSEI.m_nestedSEIs.push_back(&pictureTimingSEI);
2069            m_seiWriter.writeSEImessage(nalu.m_Bitstream, scalableNestingSEI, pcSlice->getSPS());
2070            writeRBSPTrailingBits(nalu.m_Bitstream);
2071            UInt seiPositionInAu = xGetFirstSeiLocation(accessUnit);
2072            UInt offsetPosition = m_activeParameterSetSEIPresentInAU
2073              + m_bufferingPeriodSEIPresentInAU + m_pictureTimingSEIPresentInAU + m_nestedBufferingPeriodSEIPresentInAU;    // Insert PT SEI after APS and BP SEI
2074            AccessUnit::iterator it;
2075            for(j = 0, it = accessUnit.begin(); j < seiPositionInAu + offsetPosition; j++)
2076            {
2077              it++;
2078            }
2079            accessUnit.insert(it, new NALUnitEBSP(nalu));
2080            m_nestedPictureTimingSEIPresentInAU = true;
2081          }
2082        }
2083        if( m_pcCfg->getDecodingUnitInfoSEIEnabled() && hrd->getSubPicCpbParamsPresentFlag() )
2084        {             
2085          m_pcEntropyCoder->setEntropyCoder(m_pcCavlcCoder, pcSlice);
2086          for( Int i = 0; i < ( pictureTimingSEI.m_numDecodingUnitsMinus1 + 1 ); i ++ )
2087          {
2088            OutputNALUnit nalu(NAL_UNIT_PREFIX_SEI, pcSlice->getTLayer());
2089
2090            SEIDecodingUnitInfo tempSEI;
2091            tempSEI.m_decodingUnitIdx = i;
2092            tempSEI.m_duSptCpbRemovalDelay = pictureTimingSEI.m_duCpbRemovalDelayMinus1[i] + 1;
2093            tempSEI.m_dpbOutputDuDelayPresentFlag = false;
2094            tempSEI.m_picSptDpbOutputDuDelay = picSptDpbOutputDuDelay;
2095
2096            AccessUnit::iterator it;
2097            // Insert the first one in the right location, before the first slice
2098            if(i == 0)
2099            {
2100              // Insert before the first slice.
2101              m_seiWriter.writeSEImessage(nalu.m_Bitstream, tempSEI, pcSlice->getSPS());
2102              writeRBSPTrailingBits(nalu.m_Bitstream);
2103
2104              UInt seiPositionInAu = xGetFirstSeiLocation(accessUnit);
2105              UInt offsetPosition = m_activeParameterSetSEIPresentInAU
2106                                    + m_bufferingPeriodSEIPresentInAU
2107                                    + m_pictureTimingSEIPresentInAU;  // Insert DU info SEI after APS, BP and PT SEI
2108              for(j = 0, it = accessUnit.begin(); j < seiPositionInAu + offsetPosition; j++)
2109              {
2110                it++;
2111              }
2112              accessUnit.insert(it, new NALUnitEBSP(nalu));
2113            }
2114            else
2115            {
2116              Int ctr;
2117              // For the second decoding unit onwards we know how many NALUs are present
2118              for (ctr = 0, it = accessUnit.begin(); it != accessUnit.end(); it++)
2119              {           
2120                if(ctr == accumNalsDU[ i - 1 ])
2121                {
2122                  // Insert before the first slice.
2123                  m_seiWriter.writeSEImessage(nalu.m_Bitstream, tempSEI, pcSlice->getSPS());
2124                  writeRBSPTrailingBits(nalu.m_Bitstream);
2125
2126                  accessUnit.insert(it, new NALUnitEBSP(nalu));
2127                  break;
2128                }
2129                if ((*it)->m_nalUnitType != NAL_UNIT_PREFIX_SEI && (*it)->m_nalUnitType != NAL_UNIT_SUFFIX_SEI)
2130                {
2131                  ctr++;
2132                }
2133              }
2134            }           
2135          }
2136        }
2137      }
2138      xResetNonNestedSEIPresentFlags();
2139      xResetNestedSEIPresentFlags();
2140      pcPic->getPicYuvRec()->copyToPic(pcPicYuvRecOut);
2141
2142      pcPic->setReconMark   ( true );
2143#if H_MV
2144      TComSlice::markIvRefPicsAsShortTerm( m_refPicSetInterLayer0, m_refPicSetInterLayer1 ); 
2145      std::vector<Int> temp; 
2146      TComSlice::markCurrPic( pcPic ); 
2147      TComSlice::markIvRefPicsAsUnused   ( m_ivPicLists, temp, pcPic->getSlice(0)->getVPS(), m_layerId, pcPic->getPOC() ); 
2148#endif
2149      m_bFirst = false;
2150      m_iNumPicCoded++;
2151      m_totalCoded ++;
2152      /* logging: insert a newline at end of picture period */
2153      printf("\n");
2154      fflush(stdout);
2155
2156      delete[] pcSubstreamsOut;
2157  }
2158#if !KWU_FIX_URQ && !RATE_CONTROL_LAMBDA_DOMAIN
2159  if(m_pcCfg->getUseRateCtrl())
2160  {
2161    m_pcRateCtrl->updateRCGOPStatus();
2162  }
2163#endif
2164  delete pcBitstreamRedirect;
2165
2166  if( accumBitsDU != NULL) delete accumBitsDU;
2167  if( accumNalsDU != NULL) delete accumNalsDU;
2168
2169#if !H_MV
2170  assert ( (m_iNumPicCoded == iNumPicRcvd) || (isField && iPOCLast == 1) );
2171#endif
2172}
2173
2174#if !H_MV
2175Void TEncGOP::printOutSummary(UInt uiNumAllPicCoded, bool isField)
2176{
2177  assert (uiNumAllPicCoded == m_gcAnalyzeAll.getNumPic());
2178 
2179   
2180  //--CFG_KDY
2181  if(isField)
2182  {
2183    m_gcAnalyzeAll.setFrmRate( m_pcCfg->getFrameRate() * 2);
2184    m_gcAnalyzeI.setFrmRate( m_pcCfg->getFrameRate() * 2);
2185    m_gcAnalyzeP.setFrmRate( m_pcCfg->getFrameRate() * 2);
2186    m_gcAnalyzeB.setFrmRate( m_pcCfg->getFrameRate() * 2);
2187  }
2188  else
2189  {
2190  m_gcAnalyzeAll.setFrmRate( m_pcCfg->getFrameRate() );
2191  m_gcAnalyzeI.setFrmRate( m_pcCfg->getFrameRate() );
2192  m_gcAnalyzeP.setFrmRate( m_pcCfg->getFrameRate() );
2193  m_gcAnalyzeB.setFrmRate( m_pcCfg->getFrameRate() );
2194  }
2195 
2196  //-- all
2197  printf( "\n\nSUMMARY --------------------------------------------------------\n" );
2198  m_gcAnalyzeAll.printOut('a');
2199 
2200  printf( "\n\nI Slices--------------------------------------------------------\n" );
2201  m_gcAnalyzeI.printOut('i');
2202 
2203  printf( "\n\nP Slices--------------------------------------------------------\n" );
2204  m_gcAnalyzeP.printOut('p');
2205 
2206  printf( "\n\nB Slices--------------------------------------------------------\n" );
2207  m_gcAnalyzeB.printOut('b');
2208 
2209#if _SUMMARY_OUT_
2210  m_gcAnalyzeAll.printSummaryOut();
2211#endif
2212#if _SUMMARY_PIC_
2213  m_gcAnalyzeI.printSummary('I');
2214  m_gcAnalyzeP.printSummary('P');
2215  m_gcAnalyzeB.printSummary('B');
2216#endif
2217
2218  if(isField)
2219  {
2220    //-- interlaced summary
2221    m_gcAnalyzeAll_in.setFrmRate( m_pcCfg->getFrameRate());
2222    printf( "\n\nSUMMARY INTERLACED ---------------------------------------------\n" );
2223    m_gcAnalyzeAll_in.printOutInterlaced('a',  m_gcAnalyzeAll.getBits());
2224   
2225#if _SUMMARY_OUT_
2226    m_gcAnalyzeAll_in.printSummaryOutInterlaced();
2227#endif
2228  }
2229
2230  printf("\nRVM: %.3lf\n" , xCalculateRVM());
2231}
2232#endif
2233#if H_3D_VSO
2234Void TEncGOP::preLoopFilterPicAll( TComPic* pcPic, Dist64& ruiDist, UInt64& ruiBits )
2235#else
2236Void TEncGOP::preLoopFilterPicAll( TComPic* pcPic, UInt64& ruiDist, UInt64& ruiBits )
2237#endif
2238{
2239  TComSlice* pcSlice = pcPic->getSlice(pcPic->getCurrSliceIdx());
2240  Bool bCalcDist = false;
2241  m_pcLoopFilter->setCfg(m_pcCfg->getLFCrossTileBoundaryFlag());
2242  m_pcLoopFilter->loopFilterPic( pcPic );
2243 
2244  m_pcEntropyCoder->setEntropyCoder ( m_pcEncTop->getRDGoOnSbacCoder(), pcSlice );
2245  m_pcEntropyCoder->resetEntropy    ();
2246  m_pcEntropyCoder->setBitstream    ( m_pcBitCounter );
2247  pcSlice = pcPic->getSlice(0);
2248  if(pcSlice->getSPS()->getUseSAO())
2249  {
2250    std::vector<Bool> LFCrossSliceBoundaryFlag(1, true);
2251    std::vector<Int>  sliceStartAddress;
2252    sliceStartAddress.push_back(0);
2253    sliceStartAddress.push_back(pcPic->getNumCUsInFrame()* pcPic->getNumPartInCU());
2254    pcPic->createNonDBFilterInfo(sliceStartAddress, 0, &LFCrossSliceBoundaryFlag);
2255  }
2256 
2257  if( pcSlice->getSPS()->getUseSAO())
2258  {
2259    pcPic->destroyNonDBFilterInfo();
2260  }
2261 
2262  m_pcEntropyCoder->resetEntropy    ();
2263  ruiBits += m_pcEntropyCoder->getNumberOfWrittenBits();
2264 
2265  if (!bCalcDist)
2266    ruiDist = xFindDistortionFrame(pcPic->getPicYuvOrg(), pcPic->getPicYuvRec());
2267}
2268
2269// ====================================================================================================================
2270// Protected member functions
2271// ====================================================================================================================
2272
2273
2274Void TEncGOP::xInitGOP( Int iPOCLast, Int iNumPicRcvd, TComList<TComPic*>& rcListPic, TComList<TComPicYuv*>& rcListPicYuvRecOut, bool isField )
2275{
2276  assert( iNumPicRcvd > 0 );
2277  //  Exception for the first frames
2278  if ( ( isField && (iPOCLast == 0 || iPOCLast == 1) ) || (!isField  && (iPOCLast == 0))  )
2279  {
2280    m_iGopSize    = 1;
2281  }
2282  else
2283  {
2284    m_iGopSize    = m_pcCfg->getGOPSize();
2285  }
2286  assert (m_iGopSize > 0);
2287 
2288  return;
2289}
2290
2291Void TEncGOP::xInitGOP( Int iPOCLast, Int iNumPicRcvd, TComList<TComPic*>& rcListPic, TComList<TComPicYuv*>& rcListPicYuvRecOut )
2292{
2293  assert( iNumPicRcvd > 0 );
2294  //  Exception for the first frame
2295  if ( iPOCLast == 0 )
2296  {
2297    m_iGopSize    = 1;
2298  }
2299  else
2300    m_iGopSize    = m_pcCfg->getGOPSize();
2301 
2302  assert (m_iGopSize > 0); 
2303
2304  return;
2305}
2306
2307Void TEncGOP::xGetBuffer( TComList<TComPic*>&      rcListPic,
2308                         TComList<TComPicYuv*>&    rcListPicYuvRecOut,
2309                         Int                       iNumPicRcvd,
2310                         Int                       iTimeOffset,
2311                         TComPic*&                 rpcPic,
2312                         TComPicYuv*&              rpcPicYuvRecOut,
2313                         Int                       pocCurr,
2314                         bool                      isField)
2315{
2316  Int i;
2317  //  Rec. output
2318  TComList<TComPicYuv*>::iterator     iterPicYuvRec = rcListPicYuvRecOut.end();
2319 
2320  if (isField)
2321  {
2322    for ( i = 0; i < ( (pocCurr == 0 ) || (pocCurr == 1 ) ? (iNumPicRcvd - iTimeOffset + 1) : (iNumPicRcvd - iTimeOffset + 2) ); i++ )
2323    {
2324      iterPicYuvRec--;
2325    }
2326  }
2327  else
2328  {
2329    for ( i = 0; i < (iNumPicRcvd - iTimeOffset + 1); i++ )
2330  {
2331    iterPicYuvRec--;
2332  }
2333 
2334  }
2335 
2336  if (isField)
2337  {
2338    if(pocCurr == 1)
2339    {
2340      iterPicYuvRec++;
2341    }
2342  }
2343  rpcPicYuvRecOut = *(iterPicYuvRec);
2344 
2345  //  Current pic.
2346  TComList<TComPic*>::iterator        iterPic       = rcListPic.begin();
2347  while (iterPic != rcListPic.end())
2348  {
2349    rpcPic = *(iterPic);
2350    rpcPic->setCurrSliceIdx(0);
2351    if (rpcPic->getPOC() == pocCurr)
2352    {
2353      break;
2354    }
2355    iterPic++;
2356  }
2357 
2358  assert (rpcPic->getPOC() == pocCurr);
2359 
2360  return;
2361}
2362
2363#if H_3D_VSO
2364Dist64 TEncGOP::xFindDistortionFrame (TComPicYuv* pcPic0, TComPicYuv* pcPic1)
2365#else
2366UInt64 TEncGOP::xFindDistortionFrame (TComPicYuv* pcPic0, TComPicYuv* pcPic1)
2367#endif
2368{
2369  Int     x, y;
2370  Pel*  pSrc0   = pcPic0 ->getLumaAddr();
2371  Pel*  pSrc1   = pcPic1 ->getLumaAddr();
2372  UInt  uiShift = 2 * DISTORTION_PRECISION_ADJUSTMENT(g_bitDepthY-8);
2373  Int   iTemp;
2374 
2375  Int   iStride = pcPic0->getStride();
2376  Int   iWidth  = pcPic0->getWidth();
2377  Int   iHeight = pcPic0->getHeight();
2378 
2379#if H_3D_VSO
2380  Dist64  uiTotalDiff = 0;
2381#else
2382  UInt64  uiTotalDiff = 0;
2383#endif
2384 
2385  for( y = 0; y < iHeight; y++ )
2386  {
2387    for( x = 0; x < iWidth; x++ )
2388    {
2389      iTemp = pSrc0[x] - pSrc1[x]; uiTotalDiff += (iTemp*iTemp) >> uiShift;
2390    }
2391    pSrc0 += iStride;
2392    pSrc1 += iStride;
2393  }
2394 
2395  uiShift = 2 * DISTORTION_PRECISION_ADJUSTMENT(g_bitDepthC-8);
2396  iHeight >>= 1;
2397  iWidth  >>= 1;
2398  iStride >>= 1;
2399 
2400  pSrc0  = pcPic0->getCbAddr();
2401  pSrc1  = pcPic1->getCbAddr();
2402 
2403  for( y = 0; y < iHeight; y++ )
2404  {
2405    for( x = 0; x < iWidth; x++ )
2406    {
2407      iTemp = pSrc0[x] - pSrc1[x]; uiTotalDiff += (iTemp*iTemp) >> uiShift;
2408    }
2409    pSrc0 += iStride;
2410    pSrc1 += iStride;
2411  }
2412 
2413  pSrc0  = pcPic0->getCrAddr();
2414  pSrc1  = pcPic1->getCrAddr();
2415 
2416  for( y = 0; y < iHeight; y++ )
2417  {
2418    for( x = 0; x < iWidth; x++ )
2419    {
2420      iTemp = pSrc0[x] - pSrc1[x]; uiTotalDiff += (iTemp*iTemp) >> uiShift;
2421    }
2422    pSrc0 += iStride;
2423    pSrc1 += iStride;
2424  }
2425 
2426  return uiTotalDiff;
2427}
2428
2429#if VERBOSE_RATE
2430static const Char* nalUnitTypeToString(NalUnitType type)
2431{
2432  switch (type)
2433  {
2434    case NAL_UNIT_CODED_SLICE_TRAIL_R: return "TRAIL_R";
2435    case NAL_UNIT_CODED_SLICE_TRAIL_N: return "TRAIL_N";
2436    case NAL_UNIT_CODED_SLICE_TLA_R:      return "TLA_R";
2437    case NAL_UNIT_CODED_SLICE_TSA_N: return "TSA_N";
2438    case NAL_UNIT_CODED_SLICE_STSA_R: return "STSA_R";
2439    case NAL_UNIT_CODED_SLICE_STSA_N: return "STSA_N";
2440    case NAL_UNIT_CODED_SLICE_BLA_W_LP:   return "BLA_W_LP";
2441    case NAL_UNIT_CODED_SLICE_BLA_W_RADL: return "BLA_W_RADL";
2442    case NAL_UNIT_CODED_SLICE_BLA_N_LP: return "BLA_N_LP";
2443    case NAL_UNIT_CODED_SLICE_IDR_W_RADL: return "IDR_W_RADL";
2444    case NAL_UNIT_CODED_SLICE_IDR_N_LP: return "IDR_N_LP";
2445    case NAL_UNIT_CODED_SLICE_CRA: return "CRA";
2446    case NAL_UNIT_CODED_SLICE_RADL_R:     return "RADL_R";
2447    case NAL_UNIT_CODED_SLICE_RASL_R:     return "RASL_R";
2448    case NAL_UNIT_VPS: return "VPS";
2449    case NAL_UNIT_SPS: return "SPS";
2450    case NAL_UNIT_PPS: return "PPS";
2451    case NAL_UNIT_ACCESS_UNIT_DELIMITER: return "AUD";
2452    case NAL_UNIT_EOS: return "EOS";
2453    case NAL_UNIT_EOB: return "EOB";
2454    case NAL_UNIT_FILLER_DATA: return "FILLER";
2455    case NAL_UNIT_PREFIX_SEI:             return "SEI";
2456    case NAL_UNIT_SUFFIX_SEI:             return "SEI";
2457    default: return "UNK";
2458  }
2459}
2460#endif
2461
2462Void TEncGOP::xCalculateAddPSNR( TComPic* pcPic, TComPicYuv* pcPicD, const AccessUnit& accessUnit, Double dEncTime )
2463{
2464  Int     x, y;
2465  UInt64 uiSSDY  = 0;
2466  UInt64 uiSSDU  = 0;
2467  UInt64 uiSSDV  = 0;
2468 
2469  Double  dYPSNR  = 0.0;
2470  Double  dUPSNR  = 0.0;
2471  Double  dVPSNR  = 0.0;
2472 
2473  //===== calculate PSNR =====
2474  Pel*  pOrg    = pcPic ->getPicYuvOrg()->getLumaAddr();
2475  Pel*  pRec    = pcPicD->getLumaAddr();
2476  Int   iStride = pcPicD->getStride();
2477 
2478  Int   iWidth;
2479  Int   iHeight;
2480 
2481  iWidth  = pcPicD->getWidth () - m_pcEncTop->getPad(0);
2482  iHeight = pcPicD->getHeight() - m_pcEncTop->getPad(1);
2483 
2484  Int   iSize   = iWidth*iHeight;
2485 
2486  for( y = 0; y < iHeight; y++ )
2487  {
2488    for( x = 0; x < iWidth; x++ )
2489    {
2490      Int iDiff = (Int)( pOrg[x] - pRec[x] );
2491      uiSSDY   += iDiff * iDiff;
2492    }
2493    pOrg += iStride;
2494    pRec += iStride;
2495  }
2496 
2497#if H_3D_VSO
2498#if H_3D_VSO_SYNTH_DIST_OUT
2499  if ( m_pcRdCost->getUseRenModel() )
2500  {
2501    unsigned int maxval = 255 * (1<<(g_uiBitDepth + g_uiBitIncrement -8));
2502    Double fRefValueY = (double) maxval * maxval * iSize;
2503    Double fRefValueC = fRefValueY / 4.0;
2504    TRenModel*  pcRenModel = m_pcEncTop->getEncTop()->getRenModel();
2505    Int64 iDistVSOY, iDistVSOU, iDistVSOV;
2506    pcRenModel->getTotalSSE( iDistVSOY, iDistVSOU, iDistVSOV );
2507    dYPSNR = ( iDistVSOY ? 10.0 * log10( fRefValueY / (Double) iDistVSOY ) : 99.99 );
2508    dUPSNR = ( iDistVSOU ? 10.0 * log10( fRefValueC / (Double) iDistVSOU ) : 99.99 );
2509    dVPSNR = ( iDistVSOV ? 10.0 * log10( fRefValueC / (Double) iDistVSOV ) : 99.99 );
2510  }
2511  else
2512  {
2513#endif
2514#endif
2515    iHeight >>= 1;
2516  iWidth  >>= 1;
2517  iStride >>= 1;
2518  pOrg  = pcPic ->getPicYuvOrg()->getCbAddr();
2519  pRec  = pcPicD->getCbAddr();
2520 
2521  for( y = 0; y < iHeight; y++ )
2522  {
2523    for( x = 0; x < iWidth; x++ )
2524    {
2525      Int iDiff = (Int)( pOrg[x] - pRec[x] );
2526      uiSSDU   += iDiff * iDiff;
2527    }
2528    pOrg += iStride;
2529    pRec += iStride;
2530  }
2531 
2532  pOrg  = pcPic ->getPicYuvOrg()->getCrAddr();
2533  pRec  = pcPicD->getCrAddr();
2534 
2535  for( y = 0; y < iHeight; y++ )
2536  {
2537    for( x = 0; x < iWidth; x++ )
2538    {
2539      Int iDiff = (Int)( pOrg[x] - pRec[x] );
2540      uiSSDV   += iDiff * iDiff;
2541    }
2542    pOrg += iStride;
2543    pRec += iStride;
2544  }
2545 
2546  Int maxvalY = 255 << (g_bitDepthY-8);
2547  Int maxvalC = 255 << (g_bitDepthC-8);
2548  Double fRefValueY = (Double) maxvalY * maxvalY * iSize;
2549  Double fRefValueC = (Double) maxvalC * maxvalC * iSize / 4.0;
2550  dYPSNR            = ( uiSSDY ? 10.0 * log10( fRefValueY / (Double)uiSSDY ) : 99.99 );
2551  dUPSNR            = ( uiSSDU ? 10.0 * log10( fRefValueC / (Double)uiSSDU ) : 99.99 );
2552  dVPSNR            = ( uiSSDV ? 10.0 * log10( fRefValueC / (Double)uiSSDV ) : 99.99 );
2553#if H_3D_VSO
2554#if H_3D_VSO_SYNTH_DIST_OUT
2555}
2556#endif
2557#endif
2558  /* calculate the size of the access unit, excluding:
2559   *  - any AnnexB contributions (start_code_prefix, zero_byte, etc.,)
2560   *  - SEI NAL units
2561   */
2562  UInt numRBSPBytes = 0;
2563  for (AccessUnit::const_iterator it = accessUnit.begin(); it != accessUnit.end(); it++)
2564  {
2565    UInt numRBSPBytes_nal = UInt((*it)->m_nalUnitData.str().size());
2566#if VERBOSE_RATE
2567    printf("*** %6s numBytesInNALunit: %u\n", nalUnitTypeToString((*it)->m_nalUnitType), numRBSPBytes_nal);
2568#endif
2569    if ((*it)->m_nalUnitType != NAL_UNIT_PREFIX_SEI && (*it)->m_nalUnitType != NAL_UNIT_SUFFIX_SEI)
2570    {
2571      numRBSPBytes += numRBSPBytes_nal;
2572    }
2573  }
2574
2575  UInt uibits = numRBSPBytes * 8;
2576  m_vRVM_RP.push_back( uibits );
2577
2578  //===== add PSNR =====
2579#if H_MV
2580  m_pcEncTop->getAnalyzeAll()->addResult (dYPSNR, dUPSNR, dVPSNR, (Double)uibits);
2581#else
2582  m_gcAnalyzeAll.addResult (dYPSNR, dUPSNR, dVPSNR, (Double)uibits);
2583#endif
2584  TComSlice*  pcSlice = pcPic->getSlice(0);
2585  if (pcSlice->isIntra())
2586  {
2587#if H_MV
2588    m_pcEncTop->getAnalyzeI()->addResult (dYPSNR, dUPSNR, dVPSNR, (Double)uibits);
2589#else
2590    m_gcAnalyzeI.addResult (dYPSNR, dUPSNR, dVPSNR, (Double)uibits);
2591#endif
2592  }
2593  if (pcSlice->isInterP())
2594  {
2595#if H_MV
2596    m_pcEncTop->getAnalyzeP()->addResult (dYPSNR, dUPSNR, dVPSNR, (Double)uibits);
2597#else
2598    m_gcAnalyzeP.addResult (dYPSNR, dUPSNR, dVPSNR, (Double)uibits);
2599#endif
2600  }
2601  if (pcSlice->isInterB())
2602  {
2603#if H_MV
2604    m_pcEncTop->getAnalyzeB()->addResult (dYPSNR, dUPSNR, dVPSNR, (Double)uibits);
2605#else
2606    m_gcAnalyzeB.addResult (dYPSNR, dUPSNR, dVPSNR, (Double)uibits);
2607#endif
2608  }
2609
2610  Char c = (pcSlice->isIntra() ? 'I' : pcSlice->isInterP() ? 'P' : 'B');
2611  if (!pcSlice->isReferenced()) c += 32;
2612
2613#if ADAPTIVE_QP_SELECTION
2614#if H_MV
2615  printf("Layer %3d   POC %4d TId: %1d ( %c-SLICE, nQP %d QP %d ) %10d  bits",
2616    pcSlice->getLayerId(),
2617    pcSlice->getPOC(),
2618    pcSlice->getTLayer(),
2619    c,
2620    pcSlice->getSliceQpBase(),
2621    pcSlice->getSliceQp(),
2622    uibits );
2623#else
2624  printf("POC %4d TId: %1d ( %c-SLICE, nQP %d QP %d ) %10d bits",
2625         pcSlice->getPOC(),
2626         pcSlice->getTLayer(),
2627         c,
2628         pcSlice->getSliceQpBase(),
2629         pcSlice->getSliceQp(),
2630         uibits );
2631#endif
2632#else
2633#if H_MV
2634  printf("Layer %3d   POC %4d TId: %1d ( %c-SLICE, QP %d ) %10d bits",
2635    pcSlice->getLayerId(),
2636    pcSlice->getPOC()-pcSlice->getLastIDR(),
2637    pcSlice->getTLayer(),
2638    c,
2639    pcSlice->getSliceQp(),
2640    uibits );
2641#else
2642  printf("POC %4d TId: %1d ( %c-SLICE, QP %d ) %10d bits",
2643         pcSlice->getPOC()-pcSlice->getLastIDR(),
2644         pcSlice->getTLayer(),
2645         c,
2646         pcSlice->getSliceQp(),
2647         uibits );
2648#endif
2649#endif
2650
2651  printf(" [Y %6.4lf dB    U %6.4lf dB    V %6.4lf dB]", dYPSNR, dUPSNR, dVPSNR );
2652  printf(" [ET %5.0f ]", dEncTime );
2653 
2654  for (Int iRefList = 0; iRefList < 2; iRefList++)
2655  {
2656    printf(" [L%d ", iRefList);
2657    for (Int iRefIndex = 0; iRefIndex < pcSlice->getNumRefIdx(RefPicList(iRefList)); iRefIndex++)
2658    {
2659#if H_MV
2660      if( pcSlice->getLayerId() != pcSlice->getRefLayerId( RefPicList(iRefList), iRefIndex ) )
2661      {
2662        printf( "V%d ", pcSlice->getRefLayerId( RefPicList(iRefList), iRefIndex ) );
2663      }
2664      else
2665      {
2666#endif
2667      printf ("%d ", pcSlice->getRefPOC(RefPicList(iRefList), iRefIndex)-pcSlice->getLastIDR());
2668#if H_MV
2669      }
2670#endif
2671    }
2672    printf("]");
2673  }
2674}
2675
2676
2677Void reinterlace(Pel* top, Pel* bottom, Pel* dst, UInt stride, UInt width, UInt height, bool isTff)
2678{
2679 
2680  for (Int y = 0; y < height; y++)
2681  {
2682    for (Int x = 0; x < width; x++)
2683    {
2684      dst[x] = isTff ? (UChar) top[x] : (UChar) bottom[x];
2685      dst[stride+x] = isTff ? (UChar) bottom[x] : (UChar) top[x];
2686    }
2687    top += stride;
2688    bottom += stride;
2689    dst += stride*2;
2690  }
2691}
2692
2693
2694Void TEncGOP::xCalculateInterlacedAddPSNR( TComPic* pcPicOrgTop, TComPic* pcPicOrgBottom, TComPicYuv* pcPicRecTop, TComPicYuv* pcPicRecBottom, const AccessUnit& accessUnit, Double dEncTime )
2695{
2696#if  H_MV
2697  assert( 0 ); // Field coding and MV need to be aligned.
2698#else
2699  Int     x, y;
2700 
2701  UInt64 uiSSDY_in  = 0;
2702  UInt64 uiSSDU_in  = 0;
2703  UInt64 uiSSDV_in  = 0;
2704 
2705  Double  dYPSNR_in  = 0.0;
2706  Double  dUPSNR_in  = 0.0;
2707  Double  dVPSNR_in  = 0.0;
2708 
2709  /*------ INTERLACED PSNR -----------*/
2710 
2711  /* Luma */
2712 
2713  Pel*  pOrgTop = pcPicOrgTop->getPicYuvOrg()->getLumaAddr();
2714  Pel*  pOrgBottom = pcPicOrgBottom->getPicYuvOrg()->getLumaAddr();
2715  Pel*  pRecTop = pcPicRecTop->getLumaAddr();
2716  Pel*  pRecBottom = pcPicRecBottom->getLumaAddr();
2717 
2718  Int   iWidth;
2719  Int   iHeight;
2720  Int iStride;
2721 
2722  iWidth  = pcPicOrgTop->getPicYuvOrg()->getWidth () - m_pcEncTop->getPad(0);
2723  iHeight = pcPicOrgTop->getPicYuvOrg()->getHeight() - m_pcEncTop->getPad(1);
2724  iStride = pcPicOrgTop->getPicYuvOrg()->getStride();
2725  Int   iSize   = iWidth*iHeight;
2726  bool isTff = pcPicOrgTop->isTopField();
2727 
2728  TComPicYuv* pcOrgInterlaced = new TComPicYuv;
2729  pcOrgInterlaced->create( iWidth, iHeight << 1, g_uiMaxCUWidth, g_uiMaxCUHeight, g_uiMaxCUDepth );
2730 
2731  TComPicYuv* pcRecInterlaced = new TComPicYuv;
2732  pcRecInterlaced->create( iWidth, iHeight << 1, g_uiMaxCUWidth, g_uiMaxCUHeight, g_uiMaxCUDepth );
2733 
2734  Pel* pOrgInterlaced = pcOrgInterlaced->getLumaAddr();
2735  Pel* pRecInterlaced = pcRecInterlaced->getLumaAddr();
2736 
2737  //=== Interlace fields ====
2738  reinterlace(pOrgTop, pOrgBottom, pOrgInterlaced, iStride, iWidth, iHeight, isTff);
2739  reinterlace(pRecTop, pRecBottom, pRecInterlaced, iStride, iWidth, iHeight, isTff);
2740 
2741  //===== calculate PSNR =====
2742  for( y = 0; y < iHeight << 1; y++ )
2743  {
2744    for( x = 0; x < iWidth; x++ )
2745    {
2746      Int iDiff = (Int)( pOrgInterlaced[x] - pRecInterlaced[x] );
2747      uiSSDY_in   += iDiff * iDiff;
2748    }
2749    pOrgInterlaced += iStride;
2750    pRecInterlaced += iStride;
2751  }
2752 
2753  /*Chroma*/
2754 
2755  iHeight >>= 1;
2756  iWidth  >>= 1;
2757  iStride >>= 1;
2758 
2759  pOrgTop = pcPicOrgTop->getPicYuvOrg()->getCbAddr();
2760  pOrgBottom = pcPicOrgBottom->getPicYuvOrg()->getCbAddr();
2761  pRecTop = pcPicRecTop->getCbAddr();
2762  pRecBottom = pcPicRecBottom->getCbAddr();
2763  pOrgInterlaced = pcOrgInterlaced->getCbAddr();
2764  pRecInterlaced = pcRecInterlaced->getCbAddr();
2765 
2766  //=== Interlace fields ====
2767  reinterlace(pOrgTop, pOrgBottom, pOrgInterlaced, iStride, iWidth, iHeight, isTff);
2768  reinterlace(pRecTop, pRecBottom, pRecInterlaced, iStride, iWidth, iHeight, isTff);
2769 
2770  //===== calculate PSNR =====
2771  for( y = 0; y < iHeight << 1; y++ )
2772  {
2773    for( x = 0; x < iWidth; x++ )
2774    {
2775      Int iDiff = (Int)( pOrgInterlaced[x] - pRecInterlaced[x] );
2776      uiSSDU_in   += iDiff * iDiff;
2777    }
2778    pOrgInterlaced += iStride;
2779    pRecInterlaced += iStride;
2780  }
2781 
2782  pOrgTop = pcPicOrgTop->getPicYuvOrg()->getCrAddr();
2783  pOrgBottom = pcPicOrgBottom->getPicYuvOrg()->getCrAddr();
2784  pRecTop = pcPicRecTop->getCrAddr();
2785  pRecBottom = pcPicRecBottom->getCrAddr();
2786  pOrgInterlaced = pcOrgInterlaced->getCrAddr();
2787  pRecInterlaced = pcRecInterlaced->getCrAddr();
2788 
2789  //=== Interlace fields ====
2790  reinterlace(pOrgTop, pOrgBottom, pOrgInterlaced, iStride, iWidth, iHeight, isTff);
2791  reinterlace(pRecTop, pRecBottom, pRecInterlaced, iStride, iWidth, iHeight, isTff);
2792 
2793  //===== calculate PSNR =====
2794  for( y = 0; y < iHeight << 1; y++ )
2795  {
2796    for( x = 0; x < iWidth; x++ )
2797    {
2798      Int iDiff = (Int)( pOrgInterlaced[x] - pRecInterlaced[x] );
2799      uiSSDV_in   += iDiff * iDiff;
2800    }
2801    pOrgInterlaced += iStride;
2802    pRecInterlaced += iStride;
2803  }
2804 
2805  Int maxvalY = 255 << (g_bitDepthY-8);
2806  Int maxvalC = 255 << (g_bitDepthC-8);
2807  Double fRefValueY = (Double) maxvalY * maxvalY * iSize*2;
2808  Double fRefValueC = (Double) maxvalC * maxvalC * iSize*2 / 4.0;
2809  dYPSNR_in            = ( uiSSDY_in ? 10.0 * log10( fRefValueY / (Double)uiSSDY_in ) : 99.99 );
2810  dUPSNR_in            = ( uiSSDU_in ? 10.0 * log10( fRefValueC / (Double)uiSSDU_in ) : 99.99 );
2811  dVPSNR_in            = ( uiSSDV_in ? 10.0 * log10( fRefValueC / (Double)uiSSDV_in ) : 99.99 );
2812 
2813  /* calculate the size of the access unit, excluding:
2814   *  - any AnnexB contributions (start_code_prefix, zero_byte, etc.,)
2815   *  - SEI NAL units
2816   */
2817  UInt numRBSPBytes = 0;
2818  for (AccessUnit::const_iterator it = accessUnit.begin(); it != accessUnit.end(); it++)
2819  {
2820    UInt numRBSPBytes_nal = UInt((*it)->m_nalUnitData.str().size());
2821   
2822    if ((*it)->m_nalUnitType != NAL_UNIT_PREFIX_SEI && (*it)->m_nalUnitType != NAL_UNIT_SUFFIX_SEI)
2823      numRBSPBytes += numRBSPBytes_nal;
2824  }
2825 
2826  UInt uibits = numRBSPBytes * 8 ;
2827 
2828  //===== add PSNR =====
2829  m_gcAnalyzeAll_in.addResult (dYPSNR_in, dUPSNR_in, dVPSNR_in, (Double)uibits);
2830 
2831  printf("\n                                      Interlaced frame %d: [Y %6.4lf dB    U %6.4lf dB    V %6.4lf dB]", pcPicOrgBottom->getPOC()/2 , dYPSNR_in, dUPSNR_in, dVPSNR_in );
2832 
2833  pcOrgInterlaced->destroy();
2834  delete pcOrgInterlaced;
2835  pcRecInterlaced->destroy();
2836  delete pcRecInterlaced;
2837#endif
2838}
2839/** Function for deciding the nal_unit_type.
2840 * \param pocCurr POC of the current picture
2841 * \returns the nal unit type of the picture
2842 * This function checks the configuration and returns the appropriate nal_unit_type for the picture.
2843 */
2844NalUnitType TEncGOP::getNalUnitType(Int pocCurr, Int lastIDR)
2845{
2846  if (pocCurr == 0)
2847  {
2848    return NAL_UNIT_CODED_SLICE_IDR_W_RADL;
2849  }
2850  if (pocCurr % m_pcCfg->getIntraPeriod() == 0)
2851  {
2852    if (m_pcCfg->getDecodingRefreshType() == 1)
2853    {
2854      return NAL_UNIT_CODED_SLICE_CRA;
2855    }
2856    else if (m_pcCfg->getDecodingRefreshType() == 2)
2857    {
2858      return NAL_UNIT_CODED_SLICE_IDR_W_RADL;
2859    }
2860  }
2861  if(m_pocCRA>0)
2862  {
2863    if(pocCurr<m_pocCRA)
2864    {
2865      // All leading pictures are being marked as TFD pictures here since current encoder uses all
2866      // reference pictures while encoding leading pictures. An encoder can ensure that a leading
2867      // picture can be still decodable when random accessing to a CRA/CRANT/BLA/BLANT picture by
2868      // controlling the reference pictures used for encoding that leading picture. Such a leading
2869      // picture need not be marked as a TFD picture.
2870      return NAL_UNIT_CODED_SLICE_RASL_R;
2871    }
2872  }
2873  if (lastIDR>0)
2874  {
2875    if (pocCurr < lastIDR)
2876    {
2877      return NAL_UNIT_CODED_SLICE_RADL_R;
2878    }
2879  }
2880  return NAL_UNIT_CODED_SLICE_TRAIL_R;
2881}
2882
2883Double TEncGOP::xCalculateRVM()
2884{
2885  Double dRVM = 0;
2886 
2887  if( m_pcCfg->getGOPSize() == 1 && m_pcCfg->getIntraPeriod() != 1 && m_pcCfg->getFramesToBeEncoded() > RVM_VCEGAM10_M * 2 )
2888  {
2889    // calculate RVM only for lowdelay configurations
2890    std::vector<Double> vRL , vB;
2891    size_t N = m_vRVM_RP.size();
2892    vRL.resize( N );
2893    vB.resize( N );
2894   
2895    Int i;
2896    Double dRavg = 0 , dBavg = 0;
2897    vB[RVM_VCEGAM10_M] = 0;
2898    for( i = RVM_VCEGAM10_M + 1 ; i < N - RVM_VCEGAM10_M + 1 ; i++ )
2899    {
2900      vRL[i] = 0;
2901      for( Int j = i - RVM_VCEGAM10_M ; j <= i + RVM_VCEGAM10_M - 1 ; j++ )
2902        vRL[i] += m_vRVM_RP[j];
2903      vRL[i] /= ( 2 * RVM_VCEGAM10_M );
2904      vB[i] = vB[i-1] + m_vRVM_RP[i] - vRL[i];
2905      dRavg += m_vRVM_RP[i];
2906      dBavg += vB[i];
2907    }
2908   
2909    dRavg /= ( N - 2 * RVM_VCEGAM10_M );
2910    dBavg /= ( N - 2 * RVM_VCEGAM10_M );
2911   
2912    Double dSigamB = 0;
2913    for( i = RVM_VCEGAM10_M + 1 ; i < N - RVM_VCEGAM10_M + 1 ; i++ )
2914    {
2915      Double tmp = vB[i] - dBavg;
2916      dSigamB += tmp * tmp;
2917    }
2918    dSigamB = sqrt( dSigamB / ( N - 2 * RVM_VCEGAM10_M ) );
2919   
2920    Double f = sqrt( 12.0 * ( RVM_VCEGAM10_M - 1 ) / ( RVM_VCEGAM10_M + 1 ) );
2921   
2922    dRVM = dSigamB / dRavg * f;
2923  }
2924 
2925  return( dRVM );
2926}
2927
2928/** Attaches the input bitstream to the stream in the output NAL unit
2929    Updates rNalu to contain concatenated bitstream. rpcBitstreamRedirect is cleared at the end of this function call.
2930 *  \param codedSliceData contains the coded slice data (bitstream) to be concatenated to rNalu
2931 *  \param rNalu          target NAL unit
2932 */
2933Void TEncGOP::xAttachSliceDataToNalUnit (OutputNALUnit& rNalu, TComOutputBitstream*& codedSliceData)
2934{
2935  // Byte-align
2936  rNalu.m_Bitstream.writeByteAlignment();   // Slice header byte-alignment
2937
2938  // Perform bitstream concatenation
2939  if (codedSliceData->getNumberOfWrittenBits() > 0)
2940    {
2941    rNalu.m_Bitstream.addSubstream(codedSliceData);
2942  }
2943
2944  m_pcEntropyCoder->setBitstream(&rNalu.m_Bitstream);
2945
2946  codedSliceData->clear();
2947}
2948
2949// Function will arrange the long-term pictures in the decreasing order of poc_lsb_lt,
2950// and among the pictures with the same lsb, it arranges them in increasing delta_poc_msb_cycle_lt value
2951Void TEncGOP::arrangeLongtermPicturesInRPS(TComSlice *pcSlice, TComList<TComPic*>& rcListPic)
2952{
2953  TComReferencePictureSet *rps = pcSlice->getRPS();
2954  if(!rps->getNumberOfLongtermPictures())
2955  {
2956    return;
2957  }
2958
2959  // Arrange long-term reference pictures in the correct order of LSB and MSB,
2960  // and assign values for pocLSBLT and MSB present flag
2961  Int longtermPicsPoc[MAX_NUM_REF_PICS], longtermPicsLSB[MAX_NUM_REF_PICS], indices[MAX_NUM_REF_PICS];
2962  Int longtermPicsMSB[MAX_NUM_REF_PICS];
2963  Bool mSBPresentFlag[MAX_NUM_REF_PICS];
2964  ::memset(longtermPicsPoc, 0, sizeof(longtermPicsPoc));    // Store POC values of LTRP
2965  ::memset(longtermPicsLSB, 0, sizeof(longtermPicsLSB));    // Store POC LSB values of LTRP
2966  ::memset(longtermPicsMSB, 0, sizeof(longtermPicsMSB));    // Store POC LSB values of LTRP
2967  ::memset(indices        , 0, sizeof(indices));            // Indices to aid in tracking sorted LTRPs
2968  ::memset(mSBPresentFlag , 0, sizeof(mSBPresentFlag));     // Indicate if MSB needs to be present
2969
2970  // Get the long-term reference pictures
2971  Int offset = rps->getNumberOfNegativePictures() + rps->getNumberOfPositivePictures();
2972  Int i, ctr = 0;
2973  Int maxPicOrderCntLSB = 1 << pcSlice->getSPS()->getBitsForPOC();
2974  for(i = rps->getNumberOfPictures() - 1; i >= offset; i--, ctr++)
2975  {
2976    longtermPicsPoc[ctr] = rps->getPOC(i);                                  // LTRP POC
2977    longtermPicsLSB[ctr] = getLSB(longtermPicsPoc[ctr], maxPicOrderCntLSB); // LTRP POC LSB
2978    indices[ctr]      = i; 
2979    longtermPicsMSB[ctr] = longtermPicsPoc[ctr] - longtermPicsLSB[ctr];
2980  }
2981  Int numLongPics = rps->getNumberOfLongtermPictures();
2982  assert(ctr == numLongPics);
2983
2984  // Arrange pictures in decreasing order of MSB;
2985  for(i = 0; i < numLongPics; i++)
2986  {
2987    for(Int j = 0; j < numLongPics - 1; j++)
2988    {
2989      if(longtermPicsMSB[j] < longtermPicsMSB[j+1])
2990      {
2991        std::swap(longtermPicsPoc[j], longtermPicsPoc[j+1]);
2992        std::swap(longtermPicsLSB[j], longtermPicsLSB[j+1]);
2993        std::swap(longtermPicsMSB[j], longtermPicsMSB[j+1]);
2994        std::swap(indices[j]        , indices[j+1]        );
2995      }
2996    }
2997  }
2998
2999  for(i = 0; i < numLongPics; i++)
3000  {
3001    // Check if MSB present flag should be enabled.
3002    // Check if the buffer contains any pictures that have the same LSB.
3003    TComList<TComPic*>::iterator  iterPic = rcListPic.begin(); 
3004    TComPic*                      pcPic;
3005    while ( iterPic != rcListPic.end() )
3006    {
3007      pcPic = *iterPic;
3008      if( (getLSB(pcPic->getPOC(), maxPicOrderCntLSB) == longtermPicsLSB[i])   &&     // Same LSB
3009                                      (pcPic->getSlice(0)->isReferenced())     &&    // Reference picture
3010                                        (pcPic->getPOC() != longtermPicsPoc[i])    )  // Not the LTRP itself
3011      {
3012        mSBPresentFlag[i] = true;
3013        break;
3014      }
3015      iterPic++;     
3016    }
3017  }
3018
3019  // tempArray for usedByCurr flag
3020  Bool tempArray[MAX_NUM_REF_PICS]; ::memset(tempArray, 0, sizeof(tempArray));
3021  for(i = 0; i < numLongPics; i++)
3022  {
3023    tempArray[i] = rps->getUsed(indices[i]);
3024  }
3025  // Now write the final values;
3026  ctr = 0;
3027  Int currMSB = 0, currLSB = 0;
3028  // currPicPoc = currMSB + currLSB
3029  currLSB = getLSB(pcSlice->getPOC(), maxPicOrderCntLSB); 
3030  currMSB = pcSlice->getPOC() - currLSB;
3031
3032  for(i = rps->getNumberOfPictures() - 1; i >= offset; i--, ctr++)
3033  {
3034    rps->setPOC                   (i, longtermPicsPoc[ctr]);
3035    rps->setDeltaPOC              (i, - pcSlice->getPOC() + longtermPicsPoc[ctr]);
3036    rps->setUsed                  (i, tempArray[ctr]);
3037    rps->setPocLSBLT              (i, longtermPicsLSB[ctr]);
3038    rps->setDeltaPocMSBCycleLT    (i, (currMSB - (longtermPicsPoc[ctr] - longtermPicsLSB[ctr])) / maxPicOrderCntLSB);
3039    rps->setDeltaPocMSBPresentFlag(i, mSBPresentFlag[ctr]);     
3040
3041    assert(rps->getDeltaPocMSBCycleLT(i) >= 0);   // Non-negative value
3042  }
3043  for(i = rps->getNumberOfPictures() - 1, ctr = 1; i >= offset; i--, ctr++)
3044  {
3045    for(Int j = rps->getNumberOfPictures() - 1 - ctr; j >= offset; j--)
3046    {
3047      // Here at the encoder we know that we have set the full POC value for the LTRPs, hence we
3048      // don't have to check the MSB present flag values for this constraint.
3049      assert( rps->getPOC(i) != rps->getPOC(j) ); // If assert fails, LTRP entry repeated in RPS!!!
3050    }
3051  }
3052}
3053
3054/** Function for finding the position to insert the first of APS and non-nested BP, PT, DU info SEI messages.
3055 * \param accessUnit Access Unit of the current picture
3056 * This function finds the position to insert the first of APS and non-nested BP, PT, DU info SEI messages.
3057 */
3058Int TEncGOP::xGetFirstSeiLocation(AccessUnit &accessUnit)
3059{
3060  // Find the location of the first SEI message
3061  AccessUnit::iterator it;
3062  Int seiStartPos = 0;
3063  for(it = accessUnit.begin(); it != accessUnit.end(); it++, seiStartPos++)
3064  {
3065     if ((*it)->isSei() || (*it)->isVcl())
3066     {
3067       break;
3068     }               
3069  }
3070//  assert(it != accessUnit.end());  // Triggers with some legit configurations
3071  return seiStartPos;
3072}
3073
3074Void TEncGOP::dblMetric( TComPic* pcPic, UInt uiNumSlices )
3075{
3076  TComPicYuv* pcPicYuvRec = pcPic->getPicYuvRec();
3077  Pel* Rec    = pcPicYuvRec->getLumaAddr( 0 );
3078  Pel* tempRec = Rec;
3079  Int  stride = pcPicYuvRec->getStride();
3080  UInt log2maxTB = pcPic->getSlice(0)->getSPS()->getQuadtreeTULog2MaxSize();
3081  UInt maxTBsize = (1<<log2maxTB);
3082  const UInt minBlockArtSize = 8;
3083  const UInt picWidth = pcPicYuvRec->getWidth();
3084  const UInt picHeight = pcPicYuvRec->getHeight();
3085  const UInt noCol = (picWidth>>log2maxTB);
3086  const UInt noRows = (picHeight>>log2maxTB);
3087  assert(noCol > 1);
3088  assert(noRows > 1);
3089  UInt64 *colSAD = (UInt64*)malloc(noCol*sizeof(UInt64));
3090  UInt64 *rowSAD = (UInt64*)malloc(noRows*sizeof(UInt64));
3091  UInt colIdx = 0;
3092  UInt rowIdx = 0;
3093  Pel p0, p1, p2, q0, q1, q2;
3094 
3095  Int qp = pcPic->getSlice(0)->getSliceQp();
3096  Int bitdepthScale = 1 << (g_bitDepthY-8);
3097  Int beta = TComLoopFilter::getBeta( qp ) * bitdepthScale;
3098  const Int thr2 = (beta>>2);
3099  const Int thr1 = 2*bitdepthScale;
3100  UInt a = 0;
3101 
3102  memset(colSAD, 0, noCol*sizeof(UInt64));
3103  memset(rowSAD, 0, noRows*sizeof(UInt64));
3104 
3105  if (maxTBsize > minBlockArtSize)
3106  {
3107    // Analyze vertical artifact edges
3108    for(Int c = maxTBsize; c < picWidth; c += maxTBsize)
3109    {
3110      for(Int r = 0; r < picHeight; r++)
3111      {
3112        p2 = Rec[c-3];
3113        p1 = Rec[c-2];
3114        p0 = Rec[c-1];
3115        q0 = Rec[c];
3116        q1 = Rec[c+1];
3117        q2 = Rec[c+2];
3118        a = ((abs(p2-(p1<<1)+p0)+abs(q0-(q1<<1)+q2))<<1);
3119        if ( thr1 < a && a < thr2)
3120        {
3121          colSAD[colIdx] += abs(p0 - q0);
3122        }
3123        Rec += stride;
3124      }
3125      colIdx++;
3126      Rec = tempRec;
3127    }
3128   
3129    // Analyze horizontal artifact edges
3130    for(Int r = maxTBsize; r < picHeight; r += maxTBsize)
3131    {
3132      for(Int c = 0; c < picWidth; c++)
3133      {
3134        p2 = Rec[c + (r-3)*stride];
3135        p1 = Rec[c + (r-2)*stride];
3136        p0 = Rec[c + (r-1)*stride];
3137        q0 = Rec[c + r*stride];
3138        q1 = Rec[c + (r+1)*stride];
3139        q2 = Rec[c + (r+2)*stride];
3140        a = ((abs(p2-(p1<<1)+p0)+abs(q0-(q1<<1)+q2))<<1);
3141        if (thr1 < a && a < thr2)
3142        {
3143          rowSAD[rowIdx] += abs(p0 - q0);
3144        }
3145      }
3146      rowIdx++;
3147    }
3148  }
3149 
3150  UInt64 colSADsum = 0;
3151  UInt64 rowSADsum = 0;
3152  for(Int c = 0; c < noCol-1; c++)
3153  {
3154    colSADsum += colSAD[c];
3155  }
3156  for(Int r = 0; r < noRows-1; r++)
3157  {
3158    rowSADsum += rowSAD[r];
3159  }
3160 
3161  colSADsum <<= 10;
3162  rowSADsum <<= 10;
3163  colSADsum /= (noCol-1);
3164  colSADsum /= picHeight;
3165  rowSADsum /= (noRows-1);
3166  rowSADsum /= picWidth;
3167 
3168  UInt64 avgSAD = ((colSADsum + rowSADsum)>>1);
3169  avgSAD >>= (g_bitDepthY-8);
3170 
3171  if ( avgSAD > 2048 )
3172  {
3173    avgSAD >>= 9;
3174    Int offset = Clip3(2,6,(Int)avgSAD);
3175    for (Int i=0; i<uiNumSlices; i++)
3176    {
3177      pcPic->getSlice(i)->setDeblockingFilterOverrideFlag(true);
3178      pcPic->getSlice(i)->setDeblockingFilterDisable(false);
3179      pcPic->getSlice(i)->setDeblockingFilterBetaOffsetDiv2( offset );
3180      pcPic->getSlice(i)->setDeblockingFilterTcOffsetDiv2( offset );
3181    }
3182  }
3183  else
3184  {
3185    for (Int i=0; i<uiNumSlices; i++)
3186    {
3187      pcPic->getSlice(i)->setDeblockingFilterOverrideFlag(false);
3188      pcPic->getSlice(i)->setDeblockingFilterDisable(        pcPic->getSlice(i)->getPPS()->getPicDisableDeblockingFilterFlag() );
3189      pcPic->getSlice(i)->setDeblockingFilterBetaOffsetDiv2( pcPic->getSlice(i)->getPPS()->getDeblockingFilterBetaOffsetDiv2() );
3190      pcPic->getSlice(i)->setDeblockingFilterTcOffsetDiv2(   pcPic->getSlice(i)->getPPS()->getDeblockingFilterTcOffsetDiv2()   );
3191    }
3192  }
3193 
3194  free(colSAD);
3195  free(rowSAD);
3196}
3197
3198#if H_MV
3199Void TEncGOP::xSetRefPicListModificationsMv( std::vector<TComPic*> tempPicLists[2], TComSlice* pcSlice, UInt iGOPid )
3200{ 
3201 
3202  if( pcSlice->getSliceType() == I_SLICE || !(pcSlice->getPPS()->getListsModificationPresentFlag()) || pcSlice->getNumActiveRefLayerPics() == 0 )
3203  {
3204    return;
3205  }
3206 
3207  GOPEntry ge = m_pcCfg->getGOPEntry( (pcSlice->getRapPicFlag() && ( pcSlice->getLayerId( ) > 0) ) ? MAX_GOP : iGOPid );
3208  assert( ge.m_numActiveRefLayerPics == pcSlice->getNumActiveRefLayerPics() ); 
3209
3210  Int numPicsInTempList     = pcSlice->getNumRpsCurrTempList(); 
3211
3212  // GT: check if SliceType should be checked here.
3213  for (Int li = 0; li < 2; li ++) // Loop over lists L0 and L1
3214  {
3215    Int numPicsInFinalRefList = pcSlice->getNumRefIdx( ( li == 0 ) ? REF_PIC_LIST_0 : REF_PIC_LIST_1 ); 
3216           
3217    Int finalIdxToTempIdxMap[16];
3218    for( Int k = 0; k < 16; k++ )
3219    {
3220      finalIdxToTempIdxMap[ k ] = -1;
3221    }
3222
3223    Bool isModified = false;
3224    if ( numPicsInTempList > 1 )
3225    {
3226      for( Int k = 0; k < pcSlice->getNumActiveRefLayerPics(); k++ )
3227      {
3228        // get position in temp. list
3229        Int refPicLayerId = pcSlice->getRefPicLayerId(k);
3230        Int idxInTempList = 0; 
3231        for (; idxInTempList < numPicsInTempList; idxInTempList++)
3232        {
3233          if ( (tempPicLists[li][idxInTempList])->getLayerId() == refPicLayerId )
3234          {
3235            break; 
3236          }
3237        }
3238
3239        Int idxInFinalList = ge.m_interViewRefPosL[ li ][ k ];
3240       
3241        // Add negative from behind
3242        idxInFinalList = ( idxInFinalList < 0 )? ( numPicsInTempList + idxInFinalList ) : idxInFinalList; 
3243       
3244        Bool curIsModified = ( idxInFinalList != idxInTempList ) && ( ( idxInTempList < numPicsInFinalRefList ) || ( idxInFinalList < numPicsInFinalRefList ) ) ;
3245        if ( curIsModified )
3246        {
3247          isModified = true; 
3248          assert( finalIdxToTempIdxMap[ idxInFinalList ] == -1 ); // Assert when two inter layer reference pictures are sorted to the same position
3249        }
3250        finalIdxToTempIdxMap[ idxInFinalList ] = idxInTempList;             
3251      }
3252    }
3253
3254    TComRefPicListModification* refPicListModification = pcSlice->getRefPicListModification();
3255    refPicListModification->setRefPicListModificationFlagL( li, isModified ); 
3256
3257    if( isModified )
3258    {
3259      Int refIdx = 0;
3260     
3261      for( Int i = 0; i < numPicsInFinalRefList; i++ )
3262      {
3263        if( finalIdxToTempIdxMap[i] >= 0 ) 
3264        {
3265          refPicListModification->setRefPicSetIdxL( li, i, finalIdxToTempIdxMap[i] );
3266        }
3267        else
3268        {
3269          ///* Fill gaps with temporal references *///
3270          // Forward inter layer reference pictures
3271          while( ( refIdx < numPicsInTempList ) && ( tempPicLists[li][refIdx]->getLayerId() != getLayerId())  )
3272          {
3273            refIdx++; 
3274          }
3275          refPicListModification->setRefPicSetIdxL( li, i, refIdx );
3276          refIdx++;
3277        }
3278      }
3279    }
3280  }
3281}
3282#endif
3283//! \}
Note: See TracBrowser for help on using the repository browser.