source: 3DVCSoftware/branches/HTM-9.0r1-F0122/source/Lib/TLibEncoder/TEncGOP.cpp @ 747

Last change on this file since 747 was 747, checked in by qualcomm, 10 years ago

MV-HEVC+D support based on JCT3V-F0122

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