source: 3DVCSoftware/branches/HTM-14.1-update-dev3-MediaTek-Qualcomm/source/Lib/TLibEncoder/TEncGOP.cpp @ 1259

Last change on this file since 1259 was 1259, checked in by mediatek-htm, 9 years ago

Reactive IVMV by Mediatek

  • Property svn:eol-style set to native
File size: 106.6 KB
Line 
1/* The copyright in this software is being made available under the BSD
2 * License, included below. This software may be subject to other third party
3 * and contributor rights, including patent rights, and no such rights are
4 * granted under this license.
5 *
6 * Copyright (c) 2010-2015, ITU/ISO/IEC
7 * All rights reserved.
8 *
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions are met:
11 *
12 *  * Redistributions of source code must retain the above copyright notice,
13 *    this list of conditions and the following disclaimer.
14 *  * Redistributions in binary form must reproduce the above copyright notice,
15 *    this list of conditions and the following disclaimer in the documentation
16 *    and/or other materials provided with the distribution.
17 *  * Neither the name of the ITU/ISO/IEC nor the names of its contributors may
18 *    be used to endorse or promote products derived from this software without
19 *    specific prior written permission.
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
22 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
25 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
26 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
27 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
28 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
29 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
30 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
31 * THE POSSIBILITY OF SUCH DAMAGE.
32 */
33
34/** \file     TEncGOP.cpp
35    \brief    GOP encoder class
36*/
37
38#include <list>
39#include <algorithm>
40#include <functional>
41
42#include "TEncTop.h"
43#include "TEncGOP.h"
44#include "TEncAnalyze.h"
45#include "libmd5/MD5.h"
46#include "TLibCommon/SEI.h"
47#include "TLibCommon/NAL.h"
48#include "NALwrite.h"
49#include <time.h>
50#include <math.h>
51
52#include <deque>
53using namespace std;
54
55//! \ingroup TLibEncoder
56//! \{
57
58// ====================================================================================================================
59// Constructor / destructor / initialization / destroy
60// ====================================================================================================================
61Int getLSB(Int poc, Int maxLSB)
62{
63  if (poc >= 0)
64  {
65    return poc % maxLSB;
66  }
67  else
68  {
69    return (maxLSB - ((-poc) % maxLSB)) % maxLSB;
70  }
71}
72
73TEncGOP::TEncGOP()
74{
75  m_iLastIDR            = 0;
76  m_iGopSize            = 0;
77  m_iNumPicCoded        = 0; //Niko
78  m_bFirst              = true;
79  m_iLastRecoveryPicPOC = 0;
80
81  m_pcCfg               = NULL;
82  m_pcSliceEncoder      = NULL;
83  m_pcListPic           = NULL;
84
85  m_pcEntropyCoder      = NULL;
86  m_pcCavlcCoder        = NULL;
87  m_pcSbacCoder         = NULL;
88  m_pcBinCABAC          = NULL;
89
90  m_bSeqFirst           = true;
91
92  m_bRefreshPending     = 0;
93  m_pocCRA            = 0;
94  m_numLongTermRefPicSPS = 0;
95  ::memset(m_ltRefPicPocLsbSps, 0, sizeof(m_ltRefPicPocLsbSps));
96  ::memset(m_ltRefPicUsedByCurrPicFlag, 0, sizeof(m_ltRefPicUsedByCurrPicFlag));
97  m_lastBPSEI         = 0;
98  m_bufferingPeriodSEIPresentInAU = false;
99#if NH_MV
100  m_layerId      = 0;
101  m_viewId       = 0;
102  m_pocLastCoded = -1; 
103#if NH_3D
104  m_viewIndex  =   0; 
105  m_isDepth = false;
106#endif
107#endif
108  m_associatedIRAPType = NAL_UNIT_CODED_SLICE_IDR_N_LP;
109  m_associatedIRAPPOC  = 0;
110  return;
111}
112
113TEncGOP::~TEncGOP()
114{
115}
116
117/** Create list to contain pointers to CTU start addresses of slice.
118 */
119Void  TEncGOP::create()
120{
121  m_bLongtermTestPictureHasBeenCoded = 0;
122  m_bLongtermTestPictureHasBeenCoded2 = 0;
123}
124
125Void  TEncGOP::destroy()
126{
127}
128
129Void TEncGOP::init ( TEncTop* pcTEncTop )
130{
131  m_pcEncTop     = pcTEncTop;
132  m_pcCfg                = pcTEncTop;
133  m_seiEncoder.init(m_pcCfg, pcTEncTop, this);
134  m_pcSliceEncoder       = pcTEncTop->getSliceEncoder();
135  m_pcListPic            = pcTEncTop->getListPic();
136
137  m_pcEntropyCoder       = pcTEncTop->getEntropyCoder();
138  m_pcCavlcCoder         = pcTEncTop->getCavlcCoder();
139  m_pcSbacCoder          = pcTEncTop->getSbacCoder();
140  m_pcBinCABAC           = pcTEncTop->getBinCABAC();
141  m_pcLoopFilter         = pcTEncTop->getLoopFilter();
142
143  m_pcSAO                = pcTEncTop->getSAO();
144  m_pcRateCtrl           = pcTEncTop->getRateCtrl();
145  m_lastBPSEI          = 0;
146  m_totalCoded         = 0;
147
148#if NH_MV
149  m_ivPicLists           = pcTEncTop->getIvPicLists(); 
150  m_layerId              = pcTEncTop->getLayerId();
151  m_viewId               = pcTEncTop->getViewId();
152#if NH_3D
153  m_viewIndex            = pcTEncTop->getViewIndex();
154  m_isDepth              = pcTEncTop->getIsDepth();
155#endif
156#endif
157#if H_3D_IC
158  m_aICEnableCandidate   = pcTEncTop->getICEnableCandidate(); 
159  m_aICEnableNum         = pcTEncTop->getICEnableNum(); 
160#endif
161#if KWU_FIX_URQ
162  m_pcRateCtrl           = pcTEncTop->getRateCtrl();
163#endif
164}
165
166Int TEncGOP::xWriteVPS (AccessUnit &accessUnit, const TComVPS *vps)
167{
168  OutputNALUnit nalu(NAL_UNIT_VPS);
169  m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
170  m_pcEntropyCoder->encodeVPS(vps);
171  accessUnit.push_back(new NALUnitEBSP(nalu));
172  return (Int)(accessUnit.back()->m_nalUnitData.str().size()) * 8;
173}
174
175Int TEncGOP::xWriteSPS (AccessUnit &accessUnit, const TComSPS *sps)
176{
177#if NH_MV
178  OutputNALUnit nalu(NAL_UNIT_SPS, 0, getLayerId() );
179#else
180  OutputNALUnit nalu(NAL_UNIT_SPS);
181#endif
182  m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
183  m_pcEntropyCoder->encodeSPS(sps);
184  accessUnit.push_back(new NALUnitEBSP(nalu));
185  return (Int)(accessUnit.back()->m_nalUnitData.str().size()) * 8;
186
187}
188
189Int TEncGOP::xWritePPS (AccessUnit &accessUnit, const TComPPS *pps)
190{
191#if NH_MV
192  OutputNALUnit nalu(NAL_UNIT_PPS, 0, getLayerId() );
193#else
194  OutputNALUnit nalu(NAL_UNIT_PPS);
195#endif
196  m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
197  m_pcEntropyCoder->encodePPS(pps);
198  accessUnit.push_back(new NALUnitEBSP(nalu));
199  return (Int)(accessUnit.back()->m_nalUnitData.str().size()) * 8;
200}
201
202
203Int TEncGOP::xWriteParameterSets (AccessUnit &accessUnit, TComSlice *slice)
204{
205  Int actualTotalBits = 0;
206
207#if NH_MV
208  if ( getLayerId() == 0 )
209  { 
210    actualTotalBits += xWriteVPS(accessUnit, m_pcEncTop->getVPS());
211  }
212#else
213  actualTotalBits += xWriteVPS(accessUnit, m_pcEncTop->getVPS());
214#endif
215  actualTotalBits += xWriteSPS(accessUnit, slice->getSPS());
216  actualTotalBits += xWritePPS(accessUnit, slice->getPPS());
217
218  return actualTotalBits;
219}
220
221// write SEI list into one NAL unit and add it to the Access unit at auPos
222Void TEncGOP::xWriteSEI (NalUnitType naluType, SEIMessages& seiMessages, AccessUnit &accessUnit, AccessUnit::iterator &auPos, Int temporalId, const TComSPS *sps)
223{
224  // don't do anything, if we get an empty list
225  if (seiMessages.empty())
226  {
227    return;
228  }
229#if NH_MV
230  OutputNALUnit nalu(naluType, temporalId, getLayerId() );
231#else
232  OutputNALUnit nalu(naluType, temporalId);
233#endif
234  m_seiWriter.writeSEImessages(nalu.m_Bitstream, seiMessages, sps, false);
235  auPos = accessUnit.insert(auPos, new NALUnitEBSP(nalu));
236  auPos++;
237}
238
239Void TEncGOP::xWriteSEISeparately (NalUnitType naluType, SEIMessages& seiMessages, AccessUnit &accessUnit, AccessUnit::iterator &auPos, Int temporalId, const TComSPS *sps)
240{
241  // don't do anything, if we get an empty list
242  if (seiMessages.empty())
243  {
244    return;
245  }
246  for (SEIMessages::const_iterator sei = seiMessages.begin(); sei!=seiMessages.end(); sei++ )
247  {
248    SEIMessages tmpMessages;
249    tmpMessages.push_back(*sei);
250#if NH_MV
251    OutputNALUnit nalu(naluType, temporalId, getLayerId() );
252#else
253    OutputNALUnit nalu(naluType, temporalId);
254#endif
255    m_seiWriter.writeSEImessages(nalu.m_Bitstream, tmpMessages, sps, false);
256    auPos = accessUnit.insert(auPos, new NALUnitEBSP(nalu));
257    auPos++;
258  }
259}
260
261Void TEncGOP::xClearSEIs(SEIMessages& seiMessages, Bool deleteMessages)
262{
263  if (deleteMessages)
264  {
265    deleteSEIs(seiMessages);
266  }
267  else
268  {
269    seiMessages.clear();
270  }
271}
272
273// write SEI messages as separate NAL units ordered
274Void TEncGOP::xWriteLeadingSEIOrdered (SEIMessages& seiMessages, SEIMessages& duInfoSeiMessages, AccessUnit &accessUnit, Int temporalId, const TComSPS *sps, Bool testWrite)
275{
276  AccessUnit::iterator itNalu = accessUnit.begin();
277
278  while ( (itNalu!=accessUnit.end())&&
279    ( (*itNalu)->m_nalUnitType==NAL_UNIT_ACCESS_UNIT_DELIMITER
280    || (*itNalu)->m_nalUnitType==NAL_UNIT_VPS
281    || (*itNalu)->m_nalUnitType==NAL_UNIT_SPS
282    || (*itNalu)->m_nalUnitType==NAL_UNIT_PPS
283    ))
284  {
285    itNalu++;
286  }
287
288  SEIMessages localMessages = seiMessages;
289  SEIMessages currentMessages;
290 
291#if ENC_DEC_TRACE
292  g_HLSTraceEnable = !testWrite;
293#endif
294  // The case that a specific SEI is not present is handled in xWriteSEI (empty list)
295
296  // Active parameter sets SEI must always be the first SEI
297  currentMessages = extractSeisByType(localMessages, SEI::ACTIVE_PARAMETER_SETS);
298  assert (currentMessages.size() <= 1);
299  xWriteSEI(NAL_UNIT_PREFIX_SEI, currentMessages, accessUnit, itNalu, temporalId, sps);
300  xClearSEIs(currentMessages, !testWrite);
301 
302  // Buffering period SEI must always be following active parameter sets
303  currentMessages = extractSeisByType(localMessages, SEI::BUFFERING_PERIOD);
304  assert (currentMessages.size() <= 1);
305  xWriteSEI(NAL_UNIT_PREFIX_SEI, currentMessages, accessUnit, itNalu, temporalId, sps);
306  xClearSEIs(currentMessages, !testWrite);
307
308  // Picture timing SEI must always be following buffering period
309  currentMessages = extractSeisByType(localMessages, SEI::PICTURE_TIMING);
310  assert (currentMessages.size() <= 1);
311  xWriteSEI(NAL_UNIT_PREFIX_SEI, currentMessages, accessUnit, itNalu, temporalId, sps);
312  xClearSEIs(currentMessages, !testWrite);
313
314  // Decoding unit info SEI must always be following picture timing
315  if (!duInfoSeiMessages.empty())
316  {
317    currentMessages.push_back(duInfoSeiMessages.front());
318    if (!testWrite)
319    {
320      duInfoSeiMessages.pop_front();
321    }
322    xWriteSEI(NAL_UNIT_PREFIX_SEI, currentMessages, accessUnit, itNalu, temporalId, sps);
323    xClearSEIs(currentMessages, !testWrite);
324  }
325
326  // Scalable nesting SEI must always be the following DU info
327  currentMessages = extractSeisByType(localMessages, SEI::SCALABLE_NESTING);
328  xWriteSEISeparately(NAL_UNIT_PREFIX_SEI, currentMessages, accessUnit, itNalu, temporalId, sps);
329  xClearSEIs(currentMessages, !testWrite);
330
331  // And finally everything else one by one
332  xWriteSEISeparately(NAL_UNIT_PREFIX_SEI, localMessages, accessUnit, itNalu, temporalId, sps);
333  xClearSEIs(localMessages, !testWrite);
334
335  if (!testWrite)
336  {
337    seiMessages.clear();
338  }
339}
340
341
342Void TEncGOP::xWriteLeadingSEIMessages (SEIMessages& seiMessages, SEIMessages& duInfoSeiMessages, AccessUnit &accessUnit, Int temporalId, const TComSPS *sps, std::deque<DUData> &duData)
343{
344  AccessUnit testAU;
345  SEIMessages picTimingSEIs = getSeisByType(seiMessages, SEI::PICTURE_TIMING);
346  assert (picTimingSEIs.size() < 2);
347  SEIPictureTiming * picTiming = picTimingSEIs.empty() ? NULL : (SEIPictureTiming*) picTimingSEIs.front();
348
349  // test writing
350  xWriteLeadingSEIOrdered(seiMessages, duInfoSeiMessages, testAU, temporalId, sps, true);
351  // update Timing and DU info SEI
352  xUpdateDuData(testAU, duData);
353  xUpdateTimingSEI(picTiming, duData, sps);
354  xUpdateDuInfoSEI(duInfoSeiMessages, picTiming);
355  // actual writing
356  xWriteLeadingSEIOrdered(seiMessages, duInfoSeiMessages, accessUnit, temporalId, sps, false);
357
358  // testAU will automatically be cleaned up when losing scope
359}
360
361Void TEncGOP::xWriteTrailingSEIMessages (SEIMessages& seiMessages, AccessUnit &accessUnit, Int temporalId, const TComSPS *sps)
362{
363  // Note: using accessUnit.end() works only as long as this function is called after slice coding and before EOS/EOB NAL units
364  AccessUnit::iterator pos = accessUnit.end();
365  xWriteSEISeparately(NAL_UNIT_SUFFIX_SEI, seiMessages, accessUnit, pos, temporalId, sps);
366  deleteSEIs(seiMessages);
367}
368
369Void TEncGOP::xWriteDuSEIMessages (SEIMessages& duInfoSeiMessages, AccessUnit &accessUnit, Int temporalId, const TComSPS *sps, std::deque<DUData> &duData)
370{
371  const TComHRD *hrd = sps->getVuiParameters()->getHrdParameters();
372
373  if( m_pcCfg->getDecodingUnitInfoSEIEnabled() && hrd->getSubPicCpbParamsPresentFlag() )
374  {
375    Int naluIdx = 0;
376    AccessUnit::iterator nalu = accessUnit.begin();
377
378    // skip over first DU, we have a DU info SEI there already
379    while (naluIdx < duData[0].accumNalsDU && nalu!=accessUnit.end())
380    {
381      naluIdx++;
382      nalu++;
383    }
384
385    SEIMessages::iterator duSEI = duInfoSeiMessages.begin();
386    // loop over remaining DUs
387    for (Int duIdx = 1; duIdx < duData.size(); duIdx++)
388    {
389      if (duSEI == duInfoSeiMessages.end())
390      {
391        // if the number of generated SEIs matches the number of DUs, this should not happen
392        assert (false);
393        return;
394      }
395      // write the next SEI
396      SEIMessages tmpSEI;
397      tmpSEI.push_back(*duSEI);
398      xWriteSEI(NAL_UNIT_PREFIX_SEI, tmpSEI, accessUnit, nalu, temporalId, sps);
399      // nalu points to the position after the SEI, so we have to increase the index as well
400      naluIdx++;
401      while ((naluIdx < duData[duIdx].accumNalsDU) && nalu!=accessUnit.end())
402      {
403        naluIdx++;
404        nalu++;
405      }
406      duSEI++;
407    }
408  }
409  deleteSEIs(duInfoSeiMessages);
410}
411
412Void TEncGOP::xCreateIRAPLeadingSEIMessages (SEIMessages& seiMessages, const TComSPS *sps, const TComPPS *pps)
413{
414#if NH_MV
415  OutputNALUnit nalu(NAL_UNIT_PREFIX_SEI, 0, getLayerId());
416#else
417  OutputNALUnit nalu(NAL_UNIT_PREFIX_SEI);
418#endif
419  if(m_pcCfg->getActiveParameterSetsSEIEnabled())
420  {
421    SEIActiveParameterSets *sei = new SEIActiveParameterSets;
422    m_seiEncoder.initSEIActiveParameterSets (sei, m_pcCfg->getVPS(), sps);
423    seiMessages.push_back(sei);
424  }
425
426  if(m_pcCfg->getFramePackingArrangementSEIEnabled())
427  {
428    SEIFramePacking *sei = new SEIFramePacking;
429    m_seiEncoder.initSEIFramePacking (sei, m_iNumPicCoded);
430    seiMessages.push_back(sei);
431  }
432
433  if(m_pcCfg->getSegmentedRectFramePackingArrangementSEIEnabled())
434  {
435    SEISegmentedRectFramePacking *sei = new SEISegmentedRectFramePacking;
436    m_seiEncoder.initSEISegmentedRectFramePacking(sei);
437    seiMessages.push_back(sei);
438  }
439
440  if (m_pcCfg->getDisplayOrientationSEIAngle())
441  {
442    SEIDisplayOrientation *sei = new SEIDisplayOrientation;
443    m_seiEncoder.initSEIDisplayOrientation(sei);
444    seiMessages.push_back(sei);
445  }
446
447  if(m_pcCfg->getToneMappingInfoSEIEnabled())
448  {
449    SEIToneMappingInfo *sei = new SEIToneMappingInfo;
450    m_seiEncoder.initSEIToneMappingInfo (sei);
451    seiMessages.push_back(sei);
452  }
453
454  if(m_pcCfg->getTMCTSSEIEnabled())
455  {
456    SEITempMotionConstrainedTileSets *sei = new SEITempMotionConstrainedTileSets;
457    m_seiEncoder.initSEITempMotionConstrainedTileSets(sei, pps);
458    seiMessages.push_back(sei);
459  }
460
461  if(m_pcCfg->getTimeCodeSEIEnabled())
462  {
463    SEITimeCode *seiTimeCode = new SEITimeCode;
464    m_seiEncoder.initSEITimeCode(seiTimeCode);
465    seiMessages.push_back(seiTimeCode);
466  }
467
468  if(m_pcCfg->getKneeSEIEnabled())
469  {
470    SEIKneeFunctionInfo *sei = new SEIKneeFunctionInfo;
471    m_seiEncoder.initSEIKneeFunctionInfo(sei);
472    seiMessages.push_back(sei);
473  }
474   
475  if(m_pcCfg->getMasteringDisplaySEI().colourVolumeSEIEnabled)
476  {
477    const TComSEIMasteringDisplay &seiCfg=m_pcCfg->getMasteringDisplaySEI();
478    SEIMasteringDisplayColourVolume *sei = new SEIMasteringDisplayColourVolume;
479    sei->values = seiCfg;
480    seiMessages.push_back(sei);
481  }
482
483#if NH_MV
484  if( m_pcCfg->getSubBitstreamPropSEIEnabled() && ( getLayerId() == 0 ) )
485  {
486    SEISubBitstreamProperty *sei = new SEISubBitstreamProperty;
487    m_seiEncoder.initSEISubBitstreamProperty( sei, sps );   
488    seiMessages.push_back(sei);
489  }
490#endif
491}
492
493Void TEncGOP::xCreatePerPictureSEIMessages (Int picInGOP, SEIMessages& seiMessages, SEIMessages& nestedSeiMessages, TComSlice *slice)
494{
495  if( ( m_pcCfg->getBufferingPeriodSEIEnabled() ) && ( slice->getSliceType() == I_SLICE ) &&
496    ( slice->getSPS()->getVuiParametersPresentFlag() ) &&
497    ( ( slice->getSPS()->getVuiParameters()->getHrdParameters()->getNalHrdParametersPresentFlag() )
498    || ( slice->getSPS()->getVuiParameters()->getHrdParameters()->getVclHrdParametersPresentFlag() ) ) )
499  {
500    SEIBufferingPeriod *bufferingPeriodSEI = new SEIBufferingPeriod();
501    m_seiEncoder.initSEIBufferingPeriod(bufferingPeriodSEI, slice);
502    seiMessages.push_back(bufferingPeriodSEI);
503    m_bufferingPeriodSEIPresentInAU = true;
504
505    if (m_pcCfg->getScalableNestingSEIEnabled())
506    {
507      SEIBufferingPeriod *bufferingPeriodSEIcopy = new SEIBufferingPeriod();
508      bufferingPeriodSEI->copyTo(*bufferingPeriodSEIcopy);
509      nestedSeiMessages.push_back(bufferingPeriodSEIcopy);
510    }
511  }
512
513  if (picInGOP ==0 && m_pcCfg->getSOPDescriptionSEIEnabled() ) // write SOP description SEI (if enabled) at the beginning of GOP
514  {
515    SEISOPDescription* sopDescriptionSEI = new SEISOPDescription();
516    m_seiEncoder.initSEISOPDescription(sopDescriptionSEI, slice, picInGOP, m_iLastIDR, m_iGopSize);
517    seiMessages.push_back(sopDescriptionSEI);
518  }
519
520  if( ( m_pcEncTop->getRecoveryPointSEIEnabled() ) && ( slice->getSliceType() == I_SLICE ) )
521  {
522    if( m_pcEncTop->getGradualDecodingRefreshInfoEnabled() && !slice->getRapPicFlag() )
523    {
524      // Gradual decoding refresh SEI
525      SEIGradualDecodingRefreshInfo *gradualDecodingRefreshInfoSEI = new SEIGradualDecodingRefreshInfo();
526      gradualDecodingRefreshInfoSEI->m_gdrForegroundFlag = true; // Indicating all "foreground"
527      seiMessages.push_back(gradualDecodingRefreshInfoSEI);
528    }
529    // Recovery point SEI
530    SEIRecoveryPoint *recoveryPointSEI = new SEIRecoveryPoint();
531    m_seiEncoder.initSEIRecoveryPoint(recoveryPointSEI, slice);
532    seiMessages.push_back(recoveryPointSEI);
533  }
534  if (m_pcCfg->getTemporalLevel0IndexSEIEnabled())
535  {
536    SEITemporalLevel0Index *temporalLevel0IndexSEI = new SEITemporalLevel0Index();
537    m_seiEncoder.initTemporalLevel0IndexSEI(temporalLevel0IndexSEI, slice);
538    seiMessages.push_back(temporalLevel0IndexSEI);
539  }
540
541  if(slice->getSPS()->getVuiParametersPresentFlag() && m_pcCfg->getChromaSamplingFilterHintEnabled() && ( slice->getSliceType() == I_SLICE ))
542  {
543    SEIChromaSamplingFilterHint *seiChromaSamplingFilterHint = new SEIChromaSamplingFilterHint;
544    m_seiEncoder.initSEIChromaSamplingFilterHint(seiChromaSamplingFilterHint, m_pcCfg->getChromaSamplingHorFilterIdc(), m_pcCfg->getChromaSamplingVerFilterIdc());
545    seiMessages.push_back(seiChromaSamplingFilterHint);
546  }
547
548  if( m_pcEncTop->getNoDisplaySEITLayer() && ( slice->getTLayer() >= m_pcEncTop->getNoDisplaySEITLayer() ) )
549  {
550    SEINoDisplay *seiNoDisplay = new SEINoDisplay;
551    seiNoDisplay->m_noDisplay = true;
552    seiMessages.push_back(seiNoDisplay);
553  }
554}
555
556Void TEncGOP::xCreateScalableNestingSEI (SEIMessages& seiMessages, SEIMessages& nestedSeiMessages)
557{
558  SEIMessages tmpMessages;
559  while (!nestedSeiMessages.empty())
560  {
561    SEI* sei=nestedSeiMessages.front();
562    nestedSeiMessages.pop_front();
563    tmpMessages.push_back(sei);
564    SEIScalableNesting *nestingSEI = new SEIScalableNesting();
565    m_seiEncoder.initSEIScalableNesting(nestingSEI, tmpMessages);
566    seiMessages.push_back(nestingSEI);
567    tmpMessages.clear();
568  }
569}
570
571Void TEncGOP::xCreatePictureTimingSEI  (Int IRAPGOPid, SEIMessages& seiMessages, SEIMessages& nestedSeiMessages, SEIMessages& duInfoSeiMessages, TComSlice *slice, Bool isField, std::deque<DUData> &duData)
572{
573  Int picSptDpbOutputDuDelay = 0;
574#if !NH_MV
575  SEIPictureTiming *pictureTimingSEI = new SEIPictureTiming();
576#endif
577
578  const TComVUI *vui = slice->getSPS()->getVuiParameters();
579  const TComHRD *hrd = vui->getHrdParameters();
580
581  // update decoding unit parameters
582  if( ( m_pcCfg->getPictureTimingSEIEnabled() || m_pcCfg->getDecodingUnitInfoSEIEnabled() ) &&
583    ( slice->getSPS()->getVuiParametersPresentFlag() ) &&
584    (  hrd->getNalHrdParametersPresentFlag() || hrd->getVclHrdParametersPresentFlag() ) )
585  {
586#if NH_MV
587    // Preliminary fix to avoid memory leak.
588    SEIPictureTiming *pictureTimingSEI = new SEIPictureTiming();
589#endif
590
591    // DU parameters
592    if( hrd->getSubPicCpbParamsPresentFlag() )
593    {
594      UInt numDU = (UInt) duData.size();
595      pictureTimingSEI->m_numDecodingUnitsMinus1     = ( numDU - 1 );
596      pictureTimingSEI->m_duCommonCpbRemovalDelayFlag = false;
597      pictureTimingSEI->m_numNalusInDuMinus1.resize( numDU );
598      pictureTimingSEI->m_duCpbRemovalDelayMinus1.resize( numDU );
599    }
600    pictureTimingSEI->m_auCpbRemovalDelay = std::min<Int>(std::max<Int>(1, m_totalCoded - m_lastBPSEI), static_cast<Int>(pow(2, static_cast<Double>(hrd->getCpbRemovalDelayLengthMinus1()+1)))); // Syntax element signalled as minus, hence the .
601    pictureTimingSEI->m_picDpbOutputDelay = slice->getSPS()->getNumReorderPics(slice->getSPS()->getMaxTLayers()-1) + slice->getPOC() - m_totalCoded;
602    if(m_pcCfg->getEfficientFieldIRAPEnabled() && IRAPGOPid > 0 && IRAPGOPid < m_iGopSize)
603    {
604      // if pictures have been swapped there is likely one more picture delay on their tid. Very rough approximation
605      pictureTimingSEI->m_picDpbOutputDelay ++;
606    }
607    Int factor = hrd->getTickDivisorMinus2() + 2;
608    pictureTimingSEI->m_picDpbOutputDuDelay = factor * pictureTimingSEI->m_picDpbOutputDelay;
609    if( m_pcCfg->getDecodingUnitInfoSEIEnabled() )
610    {
611      picSptDpbOutputDuDelay = factor * pictureTimingSEI->m_picDpbOutputDelay;
612    }
613    if (m_bufferingPeriodSEIPresentInAU)
614    {
615      m_lastBPSEI = m_totalCoded;
616    }
617
618    if( hrd->getSubPicCpbParamsPresentFlag() )
619    {
620      Int i;
621      UInt64 ui64Tmp;
622      UInt uiPrev = 0;
623      UInt numDU = ( pictureTimingSEI->m_numDecodingUnitsMinus1 + 1 );
624      std::vector<UInt> &rDuCpbRemovalDelayMinus1 = pictureTimingSEI->m_duCpbRemovalDelayMinus1;
625      UInt maxDiff = ( hrd->getTickDivisorMinus2() + 2 ) - 1;
626
627      for( i = 0; i < numDU; i ++ )
628      {
629        pictureTimingSEI->m_numNalusInDuMinus1[ i ]       = ( i == 0 ) ? ( duData[i].accumNalsDU - 1 ) : ( duData[i].accumNalsDU- duData[i-1].accumNalsDU - 1 );
630      }
631
632      if( numDU == 1 )
633      {
634        rDuCpbRemovalDelayMinus1[ 0 ] = 0; /* don't care */
635      }
636      else
637      {
638        rDuCpbRemovalDelayMinus1[ numDU - 1 ] = 0;/* by definition */
639        UInt tmp = 0;
640        UInt accum = 0;
641
642        for( i = ( numDU - 2 ); i >= 0; i -- )
643        {
644          ui64Tmp = ( ( ( duData[numDU - 1].accumBitsDU  - duData[i].accumBitsDU ) * ( vui->getTimingInfo()->getTimeScale() / vui->getTimingInfo()->getNumUnitsInTick() ) * ( hrd->getTickDivisorMinus2() + 2 ) ) / ( m_pcCfg->getTargetBitrate() ) );
645          if( (UInt)ui64Tmp > maxDiff )
646          {
647            tmp ++;
648          }
649        }
650        uiPrev = 0;
651
652        UInt flag = 0;
653        for( i = ( numDU - 2 ); i >= 0; i -- )
654        {
655          flag = 0;
656          ui64Tmp = ( ( ( duData[numDU - 1].accumBitsDU  - duData[i].accumBitsDU ) * ( vui->getTimingInfo()->getTimeScale() / vui->getTimingInfo()->getNumUnitsInTick() ) * ( hrd->getTickDivisorMinus2() + 2 ) ) / ( m_pcCfg->getTargetBitrate() ) );
657
658          if( (UInt)ui64Tmp > maxDiff )
659          {
660            if(uiPrev >= maxDiff - tmp)
661            {
662              ui64Tmp = uiPrev + 1;
663              flag = 1;
664            }
665            else                            ui64Tmp = maxDiff - tmp + 1;
666          }
667          rDuCpbRemovalDelayMinus1[ i ] = (UInt)ui64Tmp - uiPrev - 1;
668          if( (Int)rDuCpbRemovalDelayMinus1[ i ] < 0 )
669          {
670            rDuCpbRemovalDelayMinus1[ i ] = 0;
671          }
672          else if (tmp > 0 && flag == 1)
673          {
674            tmp --;
675          }
676          accum += rDuCpbRemovalDelayMinus1[ i ] + 1;
677          uiPrev = accum;
678        }
679      }
680    }
681   
682    if( m_pcCfg->getPictureTimingSEIEnabled() )
683    {
684      pictureTimingSEI->m_picStruct = (isField && slice->getPic()->isTopField())? 1 : isField? 2 : 0;
685      seiMessages.push_back(pictureTimingSEI);
686
687      if ( m_pcCfg->getScalableNestingSEIEnabled() ) // put picture timing SEI into scalable nesting SEI
688      {
689          SEIPictureTiming *pictureTimingSEIcopy = new SEIPictureTiming();
690          pictureTimingSEI->copyTo(*pictureTimingSEIcopy);
691          nestedSeiMessages.push_back(pictureTimingSEIcopy);
692        }
693    }
694
695    if( m_pcCfg->getDecodingUnitInfoSEIEnabled() && hrd->getSubPicCpbParamsPresentFlag() )
696    {
697      for( Int i = 0; i < ( pictureTimingSEI->m_numDecodingUnitsMinus1 + 1 ); i ++ )
698      {
699        SEIDecodingUnitInfo *duInfoSEI = new SEIDecodingUnitInfo();
700        duInfoSEI->m_decodingUnitIdx = i;
701        duInfoSEI->m_duSptCpbRemovalDelay = pictureTimingSEI->m_duCpbRemovalDelayMinus1[i] + 1;
702        duInfoSEI->m_dpbOutputDuDelayPresentFlag = false;
703        duInfoSEI->m_picSptDpbOutputDuDelay = picSptDpbOutputDuDelay;
704
705        duInfoSeiMessages.push_back(duInfoSEI);
706      }
707    }
708  }
709}
710
711Void TEncGOP::xUpdateDuData(AccessUnit &testAU, std::deque<DUData> &duData)
712{
713  if (duData.empty())
714  {
715    return;
716  }
717  // fix first
718  UInt numNalUnits = (UInt)testAU.size();
719  UInt numRBSPBytes = 0;
720  for (AccessUnit::const_iterator it = testAU.begin(); it != testAU.end(); it++)
721  {
722    numRBSPBytes += UInt((*it)->m_nalUnitData.str().size());
723  }
724  duData[0].accumBitsDU += ( numRBSPBytes << 3 );
725  duData[0].accumNalsDU += numNalUnits;
726
727  // adapt cumulative sums for all following DUs
728  // and add one DU info SEI, if enabled
729  for (Int i=1; i<duData.size(); i++)
730  {
731    if (m_pcCfg->getDecodingUnitInfoSEIEnabled())
732    {
733      numNalUnits  += 1;
734      numRBSPBytes += ( 5 << 3 );
735    }
736    duData[i].accumBitsDU += numRBSPBytes; // probably around 5 bytes
737    duData[i].accumNalsDU += numNalUnits;
738  }
739
740  // The last DU may have a trailing SEI
741  if (m_pcCfg->getDecodedPictureHashSEIEnabled())
742  {
743    duData.back().accumBitsDU += ( 20 << 3 ); // probably around 20 bytes - should be further adjusted, e.g. by type
744    duData.back().accumNalsDU += 1;
745  }
746
747}
748Void TEncGOP::xUpdateTimingSEI(SEIPictureTiming *pictureTimingSEI, std::deque<DUData> &duData, const TComSPS *sps)
749{
750  if (!pictureTimingSEI)
751  {
752    return;
753  }
754  const TComVUI *vui = sps->getVuiParameters();
755  const TComHRD *hrd = vui->getHrdParameters();
756  if( hrd->getSubPicCpbParamsPresentFlag() )
757  {
758    Int i;
759    UInt64 ui64Tmp;
760    UInt uiPrev = 0;
761    UInt numDU = ( pictureTimingSEI->m_numDecodingUnitsMinus1 + 1 );
762    std::vector<UInt> &rDuCpbRemovalDelayMinus1 = pictureTimingSEI->m_duCpbRemovalDelayMinus1;
763    UInt maxDiff = ( hrd->getTickDivisorMinus2() + 2 ) - 1;
764
765    for( i = 0; i < numDU; i ++ )
766    {
767      pictureTimingSEI->m_numNalusInDuMinus1[ i ]       = ( i == 0 ) ? ( duData[i].accumNalsDU - 1 ) : ( duData[i].accumNalsDU- duData[i-1].accumNalsDU - 1 );
768    }
769
770    if( numDU == 1 )
771    {
772      rDuCpbRemovalDelayMinus1[ 0 ] = 0; /* don't care */
773    }
774    else
775    {
776      rDuCpbRemovalDelayMinus1[ numDU - 1 ] = 0;/* by definition */
777      UInt tmp = 0;
778      UInt accum = 0;
779
780      for( i = ( numDU - 2 ); i >= 0; i -- )
781      {
782        ui64Tmp = ( ( ( duData[numDU - 1].accumBitsDU  - duData[i].accumBitsDU ) * ( vui->getTimingInfo()->getTimeScale() / vui->getTimingInfo()->getNumUnitsInTick() ) * ( hrd->getTickDivisorMinus2() + 2 ) ) / ( m_pcCfg->getTargetBitrate() ) );
783        if( (UInt)ui64Tmp > maxDiff )
784        {
785          tmp ++;
786        }
787      }
788      uiPrev = 0;
789
790      UInt flag = 0;
791      for( i = ( numDU - 2 ); i >= 0; i -- )
792      {
793        flag = 0;
794        ui64Tmp = ( ( ( duData[numDU - 1].accumBitsDU  - duData[i].accumBitsDU ) * ( vui->getTimingInfo()->getTimeScale() / vui->getTimingInfo()->getNumUnitsInTick() ) * ( hrd->getTickDivisorMinus2() + 2 ) ) / ( m_pcCfg->getTargetBitrate() ) );
795
796        if( (UInt)ui64Tmp > maxDiff )
797        {
798          if(uiPrev >= maxDiff - tmp)
799          {
800            ui64Tmp = uiPrev + 1;
801            flag = 1;
802          }
803          else                            ui64Tmp = maxDiff - tmp + 1;
804        }
805        rDuCpbRemovalDelayMinus1[ i ] = (UInt)ui64Tmp - uiPrev - 1;
806        if( (Int)rDuCpbRemovalDelayMinus1[ i ] < 0 )
807        {
808          rDuCpbRemovalDelayMinus1[ i ] = 0;
809        }
810        else if (tmp > 0 && flag == 1)
811        {
812          tmp --;
813        }
814        accum += rDuCpbRemovalDelayMinus1[ i ] + 1;
815        uiPrev = accum;
816      }
817    }
818  }
819}
820Void TEncGOP::xUpdateDuInfoSEI(SEIMessages &duInfoSeiMessages, SEIPictureTiming *pictureTimingSEI)
821{
822  if (duInfoSeiMessages.empty() || (pictureTimingSEI == NULL))
823  {
824    return;
825  }
826
827  Int i=0;
828
829  for (SEIMessages::iterator du = duInfoSeiMessages.begin(); du!= duInfoSeiMessages.end(); du++)
830  {
831    SEIDecodingUnitInfo *duInfoSEI = (SEIDecodingUnitInfo*) (*du);
832    duInfoSEI->m_decodingUnitIdx = i;
833    duInfoSEI->m_duSptCpbRemovalDelay = pictureTimingSEI->m_duCpbRemovalDelayMinus1[i] + 1;
834    duInfoSEI->m_dpbOutputDuDelayPresentFlag = false;
835    i++;
836  }
837}
838
839static Void
840cabac_zero_word_padding(TComSlice *const pcSlice, TComPic *const pcPic, const std::size_t binCountsInNalUnits, const std::size_t numBytesInVclNalUnits, std::ostringstream &nalUnitData, const Bool cabacZeroWordPaddingEnabled)
841{
842  const TComSPS &sps=*(pcSlice->getSPS());
843  const Int log2subWidthCxsubHeightC = (pcPic->getComponentScaleX(COMPONENT_Cb)+pcPic->getComponentScaleY(COMPONENT_Cb));
844  const Int minCuWidth  = pcPic->getMinCUWidth();
845  const Int minCuHeight = pcPic->getMinCUHeight();
846  const Int paddedWidth = ((sps.getPicWidthInLumaSamples()  + minCuWidth  - 1) / minCuWidth) * minCuWidth;
847  const Int paddedHeight= ((sps.getPicHeightInLumaSamples() + minCuHeight - 1) / minCuHeight) * minCuHeight;
848  const Int rawBits = paddedWidth * paddedHeight *
849                         (sps.getBitDepth(CHANNEL_TYPE_LUMA) + 2*(sps.getBitDepth(CHANNEL_TYPE_CHROMA)>>log2subWidthCxsubHeightC));
850  const std::size_t threshold = (32/3)*numBytesInVclNalUnits + (rawBits/32);
851  if (binCountsInNalUnits >= threshold)
852  {
853    // need to add additional cabac zero words (each one accounts for 3 bytes (=00 00 03)) to increase numBytesInVclNalUnits
854    const std::size_t targetNumBytesInVclNalUnits = ((binCountsInNalUnits - (rawBits/32))*3+31)/32;
855
856    if (targetNumBytesInVclNalUnits>numBytesInVclNalUnits) // It should be!
857    {
858      const std::size_t numberOfAdditionalBytesNeeded=targetNumBytesInVclNalUnits - numBytesInVclNalUnits;
859      const std::size_t numberOfAdditionalCabacZeroWords=(numberOfAdditionalBytesNeeded+2)/3;
860      const std::size_t numberOfAdditionalCabacZeroBytes=numberOfAdditionalCabacZeroWords*3;
861      if (cabacZeroWordPaddingEnabled)
862      {
863        std::vector<Char> zeroBytesPadding(numberOfAdditionalCabacZeroBytes, Char(0));
864        for(std::size_t i=0; i<numberOfAdditionalCabacZeroWords; i++)
865        {
866          zeroBytesPadding[i*3+2]=3;  // 00 00 03
867        }
868        nalUnitData.write(&(zeroBytesPadding[0]), numberOfAdditionalCabacZeroBytes);
869        printf("Adding %d bytes of padding\n", UInt(numberOfAdditionalCabacZeroWords*3));
870      }
871      else
872      {
873        printf("Standard would normally require adding %d bytes of padding\n", UInt(numberOfAdditionalCabacZeroWords*3));
874      }
875    }
876  }
877}
878
879class EfficientFieldIRAPMapping
880{
881  private:
882    Int  IRAPGOPid;
883    Bool IRAPtoReorder;
884    Bool swapIRAPForward;
885
886  public:
887    EfficientFieldIRAPMapping() :
888      IRAPGOPid(-1),
889      IRAPtoReorder(false),
890      swapIRAPForward(false)
891    { }
892
893    Void initialize(const Bool isField, const Int gopSize, const Int POCLast, const Int numPicRcvd, const Int lastIDR, TEncGOP *pEncGop, TEncCfg *pCfg);
894
895    Int adjustGOPid(const Int gopID);
896    Int restoreGOPid(const Int gopID);
897    Int GetIRAPGOPid() const { return IRAPGOPid; }
898};
899
900Void EfficientFieldIRAPMapping::initialize(const Bool isField, const Int gopSize, const Int POCLast, const Int numPicRcvd, const Int lastIDR, TEncGOP *pEncGop, TEncCfg *pCfg )
901{
902  if(isField)
903  {
904    Int pocCurr;
905    for ( Int iGOPid=0; iGOPid < gopSize; iGOPid++ )
906    {
907      // determine actual POC
908      if(POCLast == 0) //case first frame or first top field
909      {
910        pocCurr=0;
911      }
912      else if(POCLast == 1 && isField) //case first bottom field, just like the first frame, the poc computation is not right anymore, we set the right value
913      {
914        pocCurr = 1;
915      }
916      else
917      {
918        pocCurr = POCLast - numPicRcvd + pCfg->getGOPEntry(iGOPid).m_POC - isField;
919      }
920
921      // check if POC corresponds to IRAP
922      NalUnitType tmpUnitType = pEncGop->getNalUnitType(pocCurr, lastIDR, isField);
923      if(tmpUnitType >= NAL_UNIT_CODED_SLICE_BLA_W_LP && tmpUnitType <= NAL_UNIT_CODED_SLICE_CRA) // if picture is an IRAP
924      {
925        if(pocCurr%2 == 0 && iGOPid < gopSize-1 && pCfg->getGOPEntry(iGOPid).m_POC == pCfg->getGOPEntry(iGOPid+1).m_POC-1)
926        { // if top field and following picture in enc order is associated bottom field
927          IRAPGOPid = iGOPid;
928          IRAPtoReorder = true;
929          swapIRAPForward = true; 
930          break;
931        }
932        if(pocCurr%2 != 0 && iGOPid > 0 && pCfg->getGOPEntry(iGOPid).m_POC == pCfg->getGOPEntry(iGOPid-1).m_POC+1)
933        {
934          // if picture is an IRAP remember to process it first
935          IRAPGOPid = iGOPid;
936          IRAPtoReorder = true;
937          swapIRAPForward = false; 
938          break;
939        }
940      }
941    }
942  }
943}
944
945Int EfficientFieldIRAPMapping::adjustGOPid(const Int GOPid)
946{
947  if(IRAPtoReorder)
948  {
949    if(swapIRAPForward)
950    {
951      if(GOPid == IRAPGOPid)
952      {
953        return IRAPGOPid +1;
954      }
955      else if(GOPid == IRAPGOPid +1)
956      {
957        return IRAPGOPid;
958      }
959    }
960    else
961    {
962      if(GOPid == IRAPGOPid -1)
963      {
964        return IRAPGOPid;
965      }
966      else if(GOPid == IRAPGOPid)
967      {
968        return IRAPGOPid -1;
969      }
970    }
971  }
972  return GOPid;
973}
974
975Int EfficientFieldIRAPMapping::restoreGOPid(const Int GOPid)
976{
977  if(IRAPtoReorder)
978  {
979    if(swapIRAPForward)
980    {
981      if(GOPid == IRAPGOPid)
982      {
983        IRAPtoReorder = false;
984        return IRAPGOPid +1;
985      }
986      else if(GOPid == IRAPGOPid +1)
987      {
988        return GOPid -1;
989      }
990    }
991    else
992    {
993      if(GOPid == IRAPGOPid)
994      {
995        return IRAPGOPid -1;
996      }
997      else if(GOPid == IRAPGOPid -1)
998      {
999        IRAPtoReorder = false;
1000        return IRAPGOPid;
1001      }
1002    }
1003  }
1004  return GOPid;
1005}
1006
1007
1008static UInt calculateCollocatedFromL1Flag(TEncCfg *pCfg, const Int GOPid, const Int gopSize)
1009{
1010  Int iCloseLeft=1, iCloseRight=-1;
1011  for(Int i = 0; i<pCfg->getGOPEntry(GOPid).m_numRefPics; i++)
1012  {
1013    Int iRef = pCfg->getGOPEntry(GOPid).m_referencePics[i];
1014    if(iRef>0&&(iRef<iCloseRight||iCloseRight==-1))
1015    {
1016      iCloseRight=iRef;
1017    }
1018    else if(iRef<0&&(iRef>iCloseLeft||iCloseLeft==1))
1019    {
1020      iCloseLeft=iRef;
1021    }
1022  }
1023  if(iCloseRight>-1)
1024  {
1025    iCloseRight=iCloseRight+pCfg->getGOPEntry(GOPid).m_POC-1;
1026  }
1027  if(iCloseLeft<1)
1028  {
1029    iCloseLeft=iCloseLeft+pCfg->getGOPEntry(GOPid).m_POC-1;
1030    while(iCloseLeft<0)
1031    {
1032      iCloseLeft+=gopSize;
1033    }
1034  }
1035  Int iLeftQP=0, iRightQP=0;
1036  for(Int i=0; i<gopSize; i++)
1037  {
1038    if(pCfg->getGOPEntry(i).m_POC==(iCloseLeft%gopSize)+1)
1039    {
1040      iLeftQP= pCfg->getGOPEntry(i).m_QPOffset;
1041    }
1042    if (pCfg->getGOPEntry(i).m_POC==(iCloseRight%gopSize)+1)
1043    {
1044      iRightQP=pCfg->getGOPEntry(i).m_QPOffset;
1045    }
1046  }
1047  if(iCloseRight>-1&&iRightQP<iLeftQP)
1048  {
1049    return 0;
1050  }
1051  else
1052  {
1053    return 1;
1054  }
1055}
1056
1057// ====================================================================================================================
1058// Public member functions
1059// ====================================================================================================================
1060#if NH_MV
1061Void TEncGOP::initGOP( Int iPOCLast, Int iNumPicRcvd, TComList<TComPic*>& rcListPic, TComList<TComPicYuv*>& rcListPicYuvRecOut, std::list<AccessUnit>& accessUnitsInGOP)
1062{
1063  xInitGOP( iPOCLast, iNumPicRcvd, false );
1064  m_iNumPicCoded = 0;
1065}
1066#endif
1067#if NH_MV
1068Void TEncGOP::compressPicInGOP( Int iPOCLast, Int iNumPicRcvd, TComList<TComPic*>& rcListPic, 
1069                                TComList<TComPicYuv*>& rcListPicYuvRecOut,  std::list<AccessUnit>& accessUnitsInGOP, 
1070                                Bool isField, Bool isTff, const InputColourSpaceConversion snr_conversion, const Bool printFrameMSE, Int iGOPid )
1071#else
1072Void TEncGOP::compressGOP( Int iPOCLast, Int iNumPicRcvd, TComList<TComPic*>& rcListPic,
1073                           TComList<TComPicYuv*>& rcListPicYuvRecOut, std::list<AccessUnit>& accessUnitsInGOP,
1074                           Bool isField, Bool isTff, const InputColourSpaceConversion snr_conversion, const Bool printFrameMSE )
1075#endif
1076{
1077  // TODO: Split this function up.
1078
1079  TComPic*        pcPic = NULL;
1080  TComPicYuv*     pcPicYuvRecOut;
1081  TComSlice*      pcSlice;
1082  TComOutputBitstream  *pcBitstreamRedirect;
1083  pcBitstreamRedirect = new TComOutputBitstream;
1084  AccessUnit::iterator  itLocationToPushSliceHeaderNALU; // used to store location where NALU containing slice header is to be inserted
1085#if !NH_MV
1086  xInitGOP( iPOCLast, iNumPicRcvd, isField );
1087#endif
1088
1089  m_iNumPicCoded = 0;
1090  SEIMessages leadingSeiMessages;
1091  SEIMessages nestedSeiMessages;
1092  SEIMessages duInfoSeiMessages;
1093  SEIMessages trailingSeiMessages;
1094  std::deque<DUData> duData;
1095  SEIDecodingUnitInfo decodingUnitInfoSEI;
1096
1097  EfficientFieldIRAPMapping effFieldIRAPMap;
1098  if (m_pcCfg->getEfficientFieldIRAPEnabled())
1099  {
1100   effFieldIRAPMap.initialize(isField, m_iGopSize, iPOCLast, iNumPicRcvd, m_iLastIDR, this, m_pcCfg);
1101  }
1102
1103  // reset flag indicating whether pictures have been encoded
1104#if !NH_MV
1105  for ( Int iGOPid=0; iGOPid < m_iGopSize; iGOPid++ )
1106#endif
1107  {
1108    m_pcCfg->setEncodedFlag(iGOPid, false);
1109  }
1110#if !NH_MV
1111  for ( Int iGOPid=0; iGOPid < m_iGopSize; iGOPid++ )
1112#endif
1113  {
1114    if (m_pcCfg->getEfficientFieldIRAPEnabled())
1115    {
1116      iGOPid=effFieldIRAPMap.adjustGOPid(iGOPid);
1117    }
1118
1119    //-- For time output for each slice
1120    clock_t iBeforeTime = clock();
1121
1122    UInt uiColDir = calculateCollocatedFromL1Flag(m_pcCfg, iGOPid, m_iGopSize);
1123
1124    /////////////////////////////////////////////////////////////////////////////////////////////////// Initial to start encoding
1125    Int iTimeOffset;
1126    Int pocCurr;
1127    if(iPOCLast == 0) //case first frame or first top field
1128    {
1129      pocCurr=0;
1130      iTimeOffset = 1;
1131    }
1132    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
1133    {
1134      pocCurr = 1;
1135      iTimeOffset = 1;
1136    }
1137    else
1138    {
1139      pocCurr = iPOCLast - iNumPicRcvd + m_pcCfg->getGOPEntry(iGOPid).m_POC - ((isField && m_iGopSize>1) ? 1:0);
1140      iTimeOffset = m_pcCfg->getGOPEntry(iGOPid).m_POC;
1141    }
1142
1143    if(pocCurr>=m_pcCfg->getFramesToBeEncoded())
1144    {
1145      if (m_pcCfg->getEfficientFieldIRAPEnabled())
1146      {
1147        iGOPid=effFieldIRAPMap.restoreGOPid(iGOPid);
1148      }
1149#if NH_MV
1150      delete pcBitstreamRedirect;
1151      return;
1152#else
1153      continue;
1154#endif
1155    }
1156
1157    if( getNalUnitType(pocCurr, m_iLastIDR, isField) == NAL_UNIT_CODED_SLICE_IDR_W_RADL || getNalUnitType(pocCurr, m_iLastIDR, isField) == NAL_UNIT_CODED_SLICE_IDR_N_LP )
1158    {
1159      m_iLastIDR = pocCurr;
1160    }
1161    // start a new access unit: create an entry in the list of output access units
1162    accessUnitsInGOP.push_back(AccessUnit());
1163    AccessUnit& accessUnit = accessUnitsInGOP.back();
1164    xGetBuffer( rcListPic, rcListPicYuvRecOut, iNumPicRcvd, iTimeOffset, pcPic, pcPicYuvRecOut, pocCurr, isField );
1165
1166    //  Slice data initialization
1167    pcPic->clearSliceBuffer();
1168    pcPic->allocateNewSlice();
1169    m_pcSliceEncoder->setSliceIdx(0);
1170    pcPic->setCurrSliceIdx(0);
1171#if NH_MV
1172    m_pcSliceEncoder->initEncSlice ( pcPic, iPOCLast, pocCurr, iGOPid, pcSlice, m_pcEncTop->getVPS(), getLayerId(), isField  );     
1173#else
1174    m_pcSliceEncoder->initEncSlice ( pcPic, iPOCLast, pocCurr, iGOPid, pcSlice, isField );
1175#endif
1176
1177    //Set Frame/Field coding
1178    pcSlice->getPic()->setField(isField);
1179
1180    pcSlice->setLastIDR(m_iLastIDR);
1181    pcSlice->setSliceIdx(0);
1182#if NH_MV
1183    pcSlice->setRefPicSetInterLayer ( &m_refPicSetInterLayer0, &m_refPicSetInterLayer1 ); 
1184    pcPic  ->setLayerId     ( getLayerId()   );
1185    pcPic  ->setViewId      ( getViewId()    );   
1186#if !NH_3D
1187    pcSlice->setLayerId     ( getLayerId() );
1188    pcSlice->setViewId      ( getViewId()  );   
1189    pcSlice->setVPS         ( m_pcEncTop->getVPS() );
1190#else
1191    pcPic  ->setViewIndex   ( getViewIndex() ); 
1192    pcPic  ->setIsDepth( getIsDepth() );
1193    pcSlice->setCamparaSlice( pcPic->getCodedScale(), pcPic->getCodedOffset() );   
1194#endif
1195#endif
1196    //set default slice level flag to the same as SPS level flag
1197    pcSlice->setLFCrossSliceBoundaryFlag(  pcSlice->getPPS()->getLoopFilterAcrossSlicesEnabledFlag()  );
1198#if NH_MV
1199    // Set the nal unit type
1200    pcSlice->setNalUnitType(getNalUnitType(pocCurr, m_iLastIDR, isField));
1201    if( pcSlice->getSliceType() == B_SLICE )
1202    {
1203      if( m_pcCfg->getGOPEntry( ( pcSlice->getRapPicFlag() && getLayerId() > 0 ) ? MAX_GOP : iGOPid ).m_sliceType == 'P' ) 
1204      { 
1205        pcSlice->setSliceType( P_SLICE );
1206      }
1207    }
1208
1209// To be checked!
1210    if( pcSlice->getSliceType() == B_SLICE )
1211    {
1212      if( m_pcCfg->getGOPEntry( ( pcSlice->getRapPicFlag() && getLayerId() > 0 ) ? MAX_GOP : iGOPid ).m_sliceType == 'I' ) 
1213      { 
1214        pcSlice->setSliceType( I_SLICE );
1215      }
1216    }
1217#else
1218
1219    if(pcSlice->getSliceType()==B_SLICE&&m_pcCfg->getGOPEntry(iGOPid).m_sliceType=='P')
1220    {
1221      pcSlice->setSliceType(P_SLICE);
1222    }
1223    if(pcSlice->getSliceType()==B_SLICE&&m_pcCfg->getGOPEntry(iGOPid).m_sliceType=='I')
1224    {
1225      pcSlice->setSliceType(I_SLICE);
1226    }
1227   
1228    // Set the nal unit type
1229    pcSlice->setNalUnitType(getNalUnitType(pocCurr, m_iLastIDR, isField));
1230#endif
1231    if(pcSlice->getTemporalLayerNonReferenceFlag())
1232    {
1233      if (pcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_TRAIL_R &&
1234          !(m_iGopSize == 1 && pcSlice->getSliceType() == I_SLICE))
1235        // Add this condition to avoid POC issues with encoder_intra_main.cfg configuration (see #1127 in bug tracker)
1236      {
1237        pcSlice->setNalUnitType(NAL_UNIT_CODED_SLICE_TRAIL_N);
1238      }
1239      if(pcSlice->getNalUnitType()==NAL_UNIT_CODED_SLICE_RADL_R)
1240      {
1241        pcSlice->setNalUnitType(NAL_UNIT_CODED_SLICE_RADL_N);
1242      }
1243      if(pcSlice->getNalUnitType()==NAL_UNIT_CODED_SLICE_RASL_R)
1244      {
1245        pcSlice->setNalUnitType(NAL_UNIT_CODED_SLICE_RASL_N);
1246      }
1247    }
1248    if (m_pcCfg->getEfficientFieldIRAPEnabled())
1249    {
1250    if ( pcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_LP
1251      || pcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_RADL
1252      || pcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_N_LP
1253      || pcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_W_RADL
1254      || pcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_N_LP
1255      || pcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_CRA )  // IRAP picture
1256    {
1257      m_associatedIRAPType = pcSlice->getNalUnitType();
1258      m_associatedIRAPPOC = pocCurr;
1259    }
1260    pcSlice->setAssociatedIRAPType(m_associatedIRAPType);
1261    pcSlice->setAssociatedIRAPPOC(m_associatedIRAPPOC);
1262    }
1263    // Do decoding refresh marking if any
1264    pcSlice->decodingRefreshMarking(m_pocCRA, m_bRefreshPending, rcListPic, m_pcCfg->getEfficientFieldIRAPEnabled());
1265    m_pcEncTop->selectReferencePictureSet(pcSlice, pocCurr, iGOPid);
1266    pcSlice->getRPS()->setNumberOfLongtermPictures(0);
1267    if (!m_pcCfg->getEfficientFieldIRAPEnabled())
1268    {
1269    if ( pcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_LP
1270      || pcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_RADL
1271      || pcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_N_LP
1272      || pcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_W_RADL
1273      || pcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_N_LP
1274      || pcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_CRA )  // IRAP picture
1275    {
1276      m_associatedIRAPType = pcSlice->getNalUnitType();
1277      m_associatedIRAPPOC = pocCurr;
1278    }
1279    pcSlice->setAssociatedIRAPType(m_associatedIRAPType);
1280    pcSlice->setAssociatedIRAPPOC(m_associatedIRAPPOC);
1281    }
1282    if ((pcSlice->checkThatAllRefPicsAreAvailable(rcListPic, pcSlice->getRPS(), false, m_iLastRecoveryPicPOC, m_pcCfg->getDecodingRefreshType() == 3) != 0) || (pcSlice->isIRAP()) 
1283      || (m_pcCfg->getEfficientFieldIRAPEnabled() && isField && pcSlice->getAssociatedIRAPType() >= NAL_UNIT_CODED_SLICE_BLA_W_LP && pcSlice->getAssociatedIRAPType() <= NAL_UNIT_CODED_SLICE_CRA && pcSlice->getAssociatedIRAPPOC() == pcSlice->getPOC()+1)
1284      )
1285    {
1286      pcSlice->createExplicitReferencePictureSetFromReference(rcListPic, pcSlice->getRPS(), pcSlice->isIRAP(), m_iLastRecoveryPicPOC, m_pcCfg->getDecodingRefreshType() == 3, m_pcCfg->getEfficientFieldIRAPEnabled());
1287    }
1288
1289    pcSlice->applyReferencePictureSet(rcListPic, pcSlice->getRPS());
1290
1291    if(pcSlice->getTLayer() > 0 
1292      &&  !( pcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_RADL_N     // Check if not a leading picture
1293          || pcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_RADL_R
1294          || pcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_RASL_N
1295          || pcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_RASL_R )
1296        )
1297    {
1298      if(pcSlice->isTemporalLayerSwitchingPoint(rcListPic) || pcSlice->getSPS()->getTemporalIdNestingFlag())
1299      {
1300        if(pcSlice->getTemporalLayerNonReferenceFlag())
1301        {
1302          pcSlice->setNalUnitType(NAL_UNIT_CODED_SLICE_TSA_N);
1303        }
1304        else
1305        {
1306          pcSlice->setNalUnitType(NAL_UNIT_CODED_SLICE_TSA_R);
1307        }
1308      }
1309      else if(pcSlice->isStepwiseTemporalLayerSwitchingPointCandidate(rcListPic))
1310      {
1311        Bool isSTSA=true;
1312        for(Int ii=iGOPid+1;(ii<m_pcCfg->getGOPSize() && isSTSA==true);ii++)
1313        {
1314          Int lTid= m_pcCfg->getGOPEntry(ii).m_temporalId;
1315          if(lTid==pcSlice->getTLayer())
1316          {
1317            const TComReferencePictureSet* nRPS = pcSlice->getSPS()->getRPSList()->getReferencePictureSet(ii);
1318            for(Int jj=0;jj<nRPS->getNumberOfPictures();jj++)
1319            {
1320              if(nRPS->getUsed(jj))
1321              {
1322                Int tPoc=m_pcCfg->getGOPEntry(ii).m_POC+nRPS->getDeltaPOC(jj);
1323                Int kk=0;
1324                for(kk=0;kk<m_pcCfg->getGOPSize();kk++)
1325                {
1326                  if(m_pcCfg->getGOPEntry(kk).m_POC==tPoc)
1327                  {
1328                    break;
1329                  }
1330                }
1331                Int tTid=m_pcCfg->getGOPEntry(kk).m_temporalId;
1332                if(tTid >= pcSlice->getTLayer())
1333                {
1334                  isSTSA=false;
1335                  break;
1336                }
1337              }
1338            }
1339          }
1340        }
1341        if(isSTSA==true)
1342        {
1343          if(pcSlice->getTemporalLayerNonReferenceFlag())
1344          {
1345            pcSlice->setNalUnitType(NAL_UNIT_CODED_SLICE_STSA_N);
1346          }
1347          else
1348          {
1349            pcSlice->setNalUnitType(NAL_UNIT_CODED_SLICE_STSA_R);
1350          }
1351        }
1352      }
1353    }
1354    arrangeLongtermPicturesInRPS(pcSlice, rcListPic);
1355    TComRefPicListModification* refPicListModification = pcSlice->getRefPicListModification();
1356    refPicListModification->setRefPicListModificationFlagL0(0);
1357    refPicListModification->setRefPicListModificationFlagL1(0);
1358#if NH_MV
1359    if ( pcSlice->getPPS()->getNumExtraSliceHeaderBits() > 0 )
1360    {
1361      // Some more sophisticated algorithm to determine discardable_flag might be added here.
1362      pcSlice->setDiscardableFlag           ( false );     
1363    }   
1364
1365    const TComVPS*           vps = pcSlice->getVPS();     
1366#if NH_3D
1367    Int numDirectRefLayers = vps    ->getNumRefListLayers( getLayerId() ); 
1368#else
1369    Int numDirectRefLayers = vps    ->getNumDirectRefLayers( getLayerId() ); 
1370#endif
1371#if NH_3D
1372    pcSlice->setIvPicLists( m_ivPicLists );         
1373
1374    Int gopNum = (pcSlice->getRapPicFlag() && getLayerId() > 0) ? MAX_GOP : iGOPid;
1375    GOPEntry gopEntry      = m_pcCfg->getGOPEntry( gopNum );     
1376#else
1377    GOPEntry gopEntry      = m_pcCfg->getGOPEntry( (pcSlice->getRapPicFlag() && getLayerId() > 0) ? MAX_GOP : iGOPid );     
1378#endif
1379
1380
1381   
1382    Bool interLayerPredLayerIdcPresentFlag = false; 
1383    if ( getLayerId() > 0 && !vps->getAllRefLayersActiveFlag() && numDirectRefLayers > 0 )
1384    {         
1385      pcSlice->setInterLayerPredEnabledFlag ( gopEntry.m_numActiveRefLayerPics > 0 );     
1386      if ( pcSlice->getInterLayerPredEnabledFlag() && numDirectRefLayers > 1 )
1387      {
1388        if ( !vps->getMaxOneActiveRefLayerFlag() )
1389        {   
1390          pcSlice->setNumInterLayerRefPicsMinus1( gopEntry.m_numActiveRefLayerPics - 1 ); 
1391        }
1392#if NH_3D
1393        if ( gopEntry.m_numActiveRefLayerPics != vps->getNumRefListLayers( getLayerId() ) )
1394#else
1395        if ( gopEntry.m_numActiveRefLayerPics != vps->getNumDirectRefLayers( getLayerId() ) )
1396#endif
1397        {       
1398          interLayerPredLayerIdcPresentFlag = true; 
1399          for (Int i = 0; i < gopEntry.m_numActiveRefLayerPics; i++ )
1400          {
1401            pcSlice->setInterLayerPredLayerIdc( i, gopEntry.m_interLayerPredLayerIdc[ i ] ); 
1402          }
1403        }
1404      }
1405    }
1406    if ( !interLayerPredLayerIdcPresentFlag )
1407    {
1408      for( Int i = 0; i < pcSlice->getNumActiveRefLayerPics(); i++ )   
1409      {
1410        pcSlice->setInterLayerPredLayerIdc(i, pcSlice->getRefLayerPicIdc( i ) );
1411      }
1412    }
1413
1414
1415    assert( pcSlice->getNumActiveRefLayerPics() == gopEntry.m_numActiveRefLayerPics ); 
1416   
1417#if NH_3D
1418    if ( m_pcEncTop->decProcAnnexI() )
1419    {   
1420      pcSlice->deriveInCmpPredAndCpAvailFlag( ); 
1421      if ( pcSlice->getInCmpPredAvailFlag() )
1422      {     
1423        pcSlice->setInCompPredFlag( gopEntry.m_interCompPredFlag ); 
1424      }
1425      else
1426      {
1427        if (gopEntry.m_interCompPredFlag )
1428        {
1429          if ( gopNum == MAX_GOP)
1430          {
1431            printf( "\nError: FrameI_l%d cannot enable inter-component prediction.\n", pcSlice->getVPS()->getLayerIdInVps( getLayerId() ) );
1432          }
1433          else
1434          {
1435            printf( "\nError: Frame%d_l%d cannot enable inter-component prediction.\n", gopNum, pcSlice->getVPS()->getLayerIdInVps( getLayerId() ) );
1436          }
1437         
1438          exit(EXIT_FAILURE);
1439        }
1440      }
1441      pcSlice->init3dToolParameters(); 
1442      pcSlice->checkInCompPredRefLayers(); 
1443    }   
1444
1445#if NH_3D_IV_MERGE
1446    // This needs to be done after initialization of 3D tool parameters.
1447    pcSlice->setMaxNumMergeCand      ( m_pcCfg->getMaxNumMergeCand()   + ( ( pcSlice->getMpiFlag( ) || pcSlice->getIvMvPredFlag( ) || pcSlice->getViewSynthesisPredFlag( )   ) ? 1 : 0 ));
1448#endif
1449#endif
1450
1451    pcSlice->createInterLayerReferencePictureSet( m_ivPicLists, m_refPicSetInterLayer0, m_refPicSetInterLayer1 ); 
1452    pcSlice->setNumRefIdx(REF_PIC_LIST_0,min(gopEntry.m_numRefPicsActive,( pcSlice->getRPS()->getNumberOfPictures() + (Int) m_refPicSetInterLayer0.size() + (Int) m_refPicSetInterLayer1.size()) ) );
1453    pcSlice->setNumRefIdx(REF_PIC_LIST_1,min(gopEntry.m_numRefPicsActive,( pcSlice->getRPS()->getNumberOfPictures() + (Int) m_refPicSetInterLayer0.size() + (Int) m_refPicSetInterLayer1.size()) ) );
1454
1455    std::vector< TComPic* >    tempRefPicLists[2];
1456    std::vector< Bool     >    usedAsLongTerm [2];
1457    Int       numPocTotalCurr;
1458
1459    pcSlice->getTempRefPicLists( rcListPic, m_refPicSetInterLayer0, m_refPicSetInterLayer1, tempRefPicLists, usedAsLongTerm, numPocTotalCurr, true );
1460   
1461
1462    xSetRefPicListModificationsMv( tempRefPicLists, pcSlice, iGOPid );   
1463#else
1464    pcSlice->setNumRefIdx(REF_PIC_LIST_0,min(m_pcCfg->getGOPEntry(iGOPid).m_numRefPicsActive,pcSlice->getRPS()->getNumberOfPictures()));
1465    pcSlice->setNumRefIdx(REF_PIC_LIST_1,min(m_pcCfg->getGOPEntry(iGOPid).m_numRefPicsActive,pcSlice->getRPS()->getNumberOfPictures()));
1466#endif
1467    //  Set reference list
1468#if NH_MV   
1469    pcSlice->setRefPicList( tempRefPicLists, usedAsLongTerm, numPocTotalCurr ); 
1470#else
1471    pcSlice->setRefPicList ( rcListPic );
1472#endif
1473#if NH_3D_NBDV
1474    pcSlice->setDefaultRefView();
1475#endif
1476#if H_3D_ARP
1477    //GT: This seems to be broken when layerId in vps is not equal to layerId in nuh
1478    pcSlice->setARPStepNum(m_ivPicLists);
1479    if(pcSlice->getARPStepNum() > 1)
1480    {
1481      for(Int iLayerId = 0; iLayerId < getLayerId(); iLayerId ++ )
1482      {
1483        Int  iViewIdx =   pcSlice->getVPS()->getViewIndex(iLayerId);
1484        Bool bIsDepth = ( pcSlice->getVPS()->getDepthId  ( iLayerId ) == 1 );
1485        if( iViewIdx<getViewIndex() && !bIsDepth )
1486        {
1487          pcSlice->setBaseViewRefPicList( m_ivPicLists->getPicList( iLayerId ), iViewIdx );
1488        }
1489      }
1490    }
1491#endif
1492#if H_3D_IC
1493    pcSlice->setICEnableCandidate( m_aICEnableCandidate );         
1494    pcSlice->setICEnableNum( m_aICEnableNum );         
1495#endif
1496
1497    //  Slice info. refinement
1498#if NH_MV
1499    if ( pcSlice->getSliceType() == B_SLICE )
1500    {
1501      if( m_pcCfg->getGOPEntry( ( pcSlice->getRapPicFlag() == true && getLayerId() > 0 ) ? MAX_GOP : iGOPid ).m_sliceType == 'P' ) 
1502      { 
1503        pcSlice->setSliceType( P_SLICE ); 
1504      }
1505    }
1506#else
1507    if ( (pcSlice->getSliceType() == B_SLICE) && (pcSlice->getNumRefIdx(REF_PIC_LIST_1) == 0) )
1508    {
1509      pcSlice->setSliceType ( P_SLICE );
1510    }
1511#endif
1512    pcSlice->setEncCABACTableIdx(m_pcSliceEncoder->getEncCABACTableIdx());
1513
1514    if (pcSlice->getSliceType() == B_SLICE)
1515    {
1516      pcSlice->setColFromL0Flag(1-uiColDir);
1517      Bool bLowDelay = true;
1518      Int  iCurrPOC  = pcSlice->getPOC();
1519      Int iRefIdx = 0;
1520
1521      for (iRefIdx = 0; iRefIdx < pcSlice->getNumRefIdx(REF_PIC_LIST_0) && bLowDelay; iRefIdx++)
1522      {
1523        if ( pcSlice->getRefPic(REF_PIC_LIST_0, iRefIdx)->getPOC() > iCurrPOC )
1524        {
1525          bLowDelay = false;
1526        }
1527      }
1528      for (iRefIdx = 0; iRefIdx < pcSlice->getNumRefIdx(REF_PIC_LIST_1) && bLowDelay; iRefIdx++)
1529      {
1530        if ( pcSlice->getRefPic(REF_PIC_LIST_1, iRefIdx)->getPOC() > iCurrPOC )
1531        {
1532          bLowDelay = false;
1533        }
1534      }
1535
1536      pcSlice->setCheckLDC(bLowDelay);
1537    }
1538    else
1539    {
1540      pcSlice->setCheckLDC(true);
1541    }
1542
1543    uiColDir = 1-uiColDir;
1544
1545    //-------------------------------------------------------------
1546    pcSlice->setRefPOCList();
1547
1548    pcSlice->setList1IdxToList0Idx();
1549#if H_3D_TMVP
1550    if(pcSlice->getLayerId())
1551      pcSlice->generateAlterRefforTMVP();
1552#endif
1553
1554    if (m_pcEncTop->getTMVPModeId() == 2)
1555    {
1556      if (iGOPid == 0) // first picture in SOP (i.e. forward B)
1557      {
1558        pcSlice->setEnableTMVPFlag(0);
1559      }
1560      else
1561      {
1562        // Note: pcSlice->getColFromL0Flag() is assumed to be always 0 and getcolRefIdx() is always 0.
1563        pcSlice->setEnableTMVPFlag(1);
1564      }
1565    }
1566    else if (m_pcEncTop->getTMVPModeId() == 1)
1567    {
1568      pcSlice->setEnableTMVPFlag(1);
1569    }
1570    else
1571    {
1572      pcSlice->setEnableTMVPFlag(0);
1573    }
1574#if NH_MV
1575    if( pcSlice->getIdrPicFlag() )
1576    {
1577      pcSlice->setEnableTMVPFlag(0);
1578    }
1579#endif
1580
1581#if NH_3D_VSO
1582  // Should be moved to TEncTop !!!
1583  Bool bUseVSO = m_pcEncTop->getUseVSO();
1584 
1585  TComRdCost* pcRdCost = m_pcEncTop->getRdCost();   
1586
1587  pcRdCost->setUseVSO( bUseVSO );
1588
1589  // SAIT_VSO_EST_A0033
1590  pcRdCost->setUseEstimatedVSD( m_pcEncTop->getUseEstimatedVSD() );
1591
1592  if ( bUseVSO )
1593  {
1594    Int iVSOMode = m_pcEncTop->getVSOMode();
1595    pcRdCost->setVSOMode( iVSOMode  );
1596    pcRdCost->setAllowNegDist( m_pcEncTop->getAllowNegDist() );
1597
1598    // SAIT_VSO_EST_A0033
1599#if H_3D_FCO
1600    Bool flagRec;
1601    flagRec =  ((m_pcEncTop->getIvPicLists()->getPicYuv( pcSlice->getViewIndex(), false, pcSlice->getPOC(), true) == NULL) ? false: true);
1602    pcRdCost->setVideoRecPicYuv( m_pcEncTop->getIvPicLists()->getPicYuv( pcSlice->getViewIndex(), false, pcSlice->getPOC(), flagRec ) );
1603    pcRdCost->setDepthPicYuv   ( m_pcEncTop->getIvPicLists()->getPicYuv( pcSlice->getViewIndex(), true, pcSlice->getPOC(), false ) );
1604#else
1605    pcRdCost->setVideoRecPicYuv( m_pcEncTop->getIvPicLists()->getPicYuv( pcSlice->getViewIndex(), false , pcSlice->getPOC(), true ) );
1606    pcRdCost->setDepthPicYuv   ( m_pcEncTop->getIvPicLists()->getPicYuv( pcSlice->getViewIndex(), true  , pcSlice->getPOC(), false ) );
1607#endif
1608
1609    // LGE_WVSO_A0119
1610    Bool bUseWVSO  = m_pcEncTop->getUseWVSO();
1611    pcRdCost->setUseWVSO( bUseWVSO );
1612
1613  }
1614#endif
1615
1616    /////////////////////////////////////////////////////////////////////////////////////////////////// Compress a slice
1617    //  Slice compression
1618    if (m_pcCfg->getUseASR())
1619    {
1620      m_pcSliceEncoder->setSearchRange(pcSlice);
1621    }
1622
1623    Bool bGPBcheck=false;
1624    if ( pcSlice->getSliceType() == B_SLICE)
1625    {
1626      if ( pcSlice->getNumRefIdx(RefPicList( 0 ) ) == pcSlice->getNumRefIdx(RefPicList( 1 ) ) )
1627      {
1628        bGPBcheck=true;
1629        Int i;
1630        for ( i=0; i < pcSlice->getNumRefIdx(RefPicList( 1 ) ); i++ )
1631        {
1632          if ( pcSlice->getRefPOC(RefPicList(1), i) != pcSlice->getRefPOC(RefPicList(0), i) )
1633          {
1634            bGPBcheck=false;
1635            break;
1636          }
1637        }
1638      }
1639    }
1640    if(bGPBcheck)
1641    {
1642      pcSlice->setMvdL1ZeroFlag(true);
1643    }
1644    else
1645    {
1646      pcSlice->setMvdL1ZeroFlag(false);
1647    }
1648    pcPic->getSlice(pcSlice->getSliceIdx())->setMvdL1ZeroFlag(pcSlice->getMvdL1ZeroFlag());
1649
1650
1651    Double lambda            = 0.0;
1652    Int actualHeadBits       = 0;
1653    Int actualTotalBits      = 0;
1654    Int estimatedBits        = 0;
1655    Int tmpBitsBeforeWriting = 0;
1656    if ( m_pcCfg->getUseRateCtrl() ) // TODO: does this work with multiple slices and slice-segments?
1657    {
1658      Int frameLevel = m_pcRateCtrl->getRCSeq()->getGOPID2Level( iGOPid );
1659      if ( pcPic->getSlice(0)->getSliceType() == I_SLICE )
1660      {
1661        frameLevel = 0;
1662      }
1663      m_pcRateCtrl->initRCPic( frameLevel );
1664
1665#if KWU_RC_MADPRED_E0227
1666      if(m_pcCfg->getLayerId() != 0)
1667      {
1668        m_pcRateCtrl->getRCPic()->setIVPic( m_pcEncTop->getEncTop()->getTEncTop(0)->getRateCtrl()->getRCPic() );
1669      }
1670#endif
1671
1672      estimatedBits = m_pcRateCtrl->getRCPic()->getTargetBits();
1673
1674      Int sliceQP = m_pcCfg->getInitialQP();
1675      if ( ( pcSlice->getPOC() == 0 && m_pcCfg->getInitialQP() > 0 ) || ( frameLevel == 0 && m_pcCfg->getForceIntraQP() ) ) // QP is specified
1676      {
1677        Int    NumberBFrames = ( m_pcCfg->getGOPSize() - 1 );
1678        Double dLambda_scale = 1.0 - Clip3( 0.0, 0.5, 0.05*(Double)NumberBFrames );
1679        Double dQPFactor     = 0.57*dLambda_scale;
1680        Int    SHIFT_QP      = 12;
1681        Int    bitdepth_luma_qp_scale = 0;
1682        Double qp_temp = (Double) sliceQP + bitdepth_luma_qp_scale - SHIFT_QP;
1683        lambda = dQPFactor*pow( 2.0, qp_temp/3.0 );
1684      }
1685      else if ( frameLevel == 0 )   // intra case, but use the model
1686      {
1687        m_pcSliceEncoder->calCostSliceI(pcPic); // TODO: This only analyses the first slice segment - what about the others?
1688
1689        if ( m_pcCfg->getIntraPeriod() != 1 )   // do not refine allocated bits for all intra case
1690        {
1691          Int bits = m_pcRateCtrl->getRCSeq()->getLeftAverageBits();
1692          bits = m_pcRateCtrl->getRCPic()->getRefineBitsForIntra( bits );
1693          if ( bits < 200 )
1694          {
1695            bits = 200;
1696          }
1697          m_pcRateCtrl->getRCPic()->setTargetBits( bits );
1698        }
1699
1700        list<TEncRCPic*> listPreviousPicture = m_pcRateCtrl->getPicList();
1701        m_pcRateCtrl->getRCPic()->getLCUInitTargetBits();
1702        lambda  = m_pcRateCtrl->getRCPic()->estimatePicLambda( listPreviousPicture, pcSlice->getSliceType());
1703        sliceQP = m_pcRateCtrl->getRCPic()->estimatePicQP( lambda, listPreviousPicture );
1704      }
1705      else    // normal case
1706      {
1707#if KWU_RC_MADPRED_E0227
1708        if(m_pcRateCtrl->getLayerID() != 0)
1709        {
1710          list<TEncRCPic*> listPreviousPicture = m_pcRateCtrl->getPicList();
1711          lambda  = m_pcRateCtrl->getRCPic()->estimatePicLambdaIV( listPreviousPicture, pcSlice->getPOC() );
1712          sliceQP = m_pcRateCtrl->getRCPic()->estimatePicQP( lambda, listPreviousPicture );
1713        }
1714        else
1715        {
1716#endif
1717        list<TEncRCPic*> listPreviousPicture = m_pcRateCtrl->getPicList();
1718        lambda  = m_pcRateCtrl->getRCPic()->estimatePicLambda( listPreviousPicture, pcSlice->getSliceType());
1719        sliceQP = m_pcRateCtrl->getRCPic()->estimatePicQP( lambda, listPreviousPicture );
1720#if KWU_RC_MADPRED_E0227
1721        }
1722#endif
1723      }
1724
1725      sliceQP = Clip3( -pcSlice->getSPS()->getQpBDOffset(CHANNEL_TYPE_LUMA), MAX_QP, sliceQP );
1726      m_pcRateCtrl->getRCPic()->setPicEstQP( sliceQP );
1727
1728      m_pcSliceEncoder->resetQP( pcPic, sliceQP, lambda );
1729    }
1730
1731    UInt uiNumSliceSegments = 1;
1732
1733#if NH_3D_NBDV
1734      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.
1735      {
1736        Int iColPoc = pcSlice->getRefPOC(RefPicList(1 - pcSlice->getColFromL0Flag()), pcSlice->getColRefIdx());
1737        pcPic->setNumDdvCandPics(pcPic->getDisCandRefPictures(iColPoc));
1738      }
1739#endif
1740#if NH_3D
1741      pcSlice->setDepthToDisparityLUTs(); 
1742
1743#endif
1744
1745#if NH_3D_NBDV
1746      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.
1747      {
1748        pcPic->checkTemporalIVRef();
1749      }
1750
1751      if(pcSlice->getIsDepth())
1752      {
1753        pcPic->checkTextureRef();
1754      }
1755#endif
1756    // Allocate some coders, now the number of tiles are known.
1757    const Int numSubstreamsColumns = (pcSlice->getPPS()->getNumTileColumnsMinus1() + 1);
1758    const Int numSubstreamRows     = pcSlice->getPPS()->getEntropyCodingSyncEnabledFlag() ? pcPic->getFrameHeightInCtus() : (pcSlice->getPPS()->getNumTileRowsMinus1() + 1);
1759    const Int numSubstreams        = numSubstreamRows * numSubstreamsColumns;
1760    std::vector<TComOutputBitstream> substreamsOut(numSubstreams);
1761
1762    // now compress (trial encode) the various slice segments (slices, and dependent slices)
1763    {
1764      const UInt numberOfCtusInFrame=pcPic->getPicSym()->getNumberOfCtusInFrame();
1765      pcSlice->setSliceCurStartCtuTsAddr( 0 );
1766      pcSlice->setSliceSegmentCurStartCtuTsAddr( 0 );
1767
1768      for(UInt nextCtuTsAddr = 0; nextCtuTsAddr < numberOfCtusInFrame; )
1769      {
1770        m_pcSliceEncoder->precompressSlice( pcPic );
1771        m_pcSliceEncoder->compressSlice   ( pcPic, false );
1772
1773        const UInt curSliceSegmentEnd = pcSlice->getSliceSegmentCurEndCtuTsAddr();
1774        if (curSliceSegmentEnd < numberOfCtusInFrame)
1775        {
1776          const Bool bNextSegmentIsDependentSlice=curSliceSegmentEnd<pcSlice->getSliceCurEndCtuTsAddr();
1777          const UInt sliceBits=pcSlice->getSliceBits();
1778          pcPic->allocateNewSlice();
1779          // prepare for next slice
1780          pcPic->setCurrSliceIdx                    ( uiNumSliceSegments );
1781          m_pcSliceEncoder->setSliceIdx             ( uiNumSliceSegments   );
1782          pcSlice = pcPic->getSlice                 ( uiNumSliceSegments   );
1783          assert(pcSlice->getPPS()!=0);
1784          pcSlice->copySliceInfo                    ( pcPic->getSlice(uiNumSliceSegments-1)  );
1785          pcSlice->setSliceIdx                      ( uiNumSliceSegments   );
1786          if (bNextSegmentIsDependentSlice)
1787          {
1788            pcSlice->setSliceBits(sliceBits);
1789          }
1790          else
1791          {
1792            pcSlice->setSliceCurStartCtuTsAddr      ( curSliceSegmentEnd );
1793            pcSlice->setSliceBits(0);
1794          }
1795          pcSlice->setDependentSliceSegmentFlag(bNextSegmentIsDependentSlice);
1796          pcSlice->setSliceSegmentCurStartCtuTsAddr ( curSliceSegmentEnd );
1797          // TODO: optimise cabac_init during compress slice to improve multi-slice operation
1798          // pcSlice->setEncCABACTableIdx(m_pcSliceEncoder->getEncCABACTableIdx());
1799          uiNumSliceSegments ++;
1800        }
1801        nextCtuTsAddr = curSliceSegmentEnd;
1802      }
1803    }
1804
1805    duData.clear();
1806    pcSlice = pcPic->getSlice(0);
1807
1808    // SAO parameter estimation using non-deblocked pixels for CTU bottom and right boundary areas
1809    if( pcSlice->getSPS()->getUseSAO() && m_pcCfg->getSaoCtuBoundary() )
1810    {
1811      m_pcSAO->getPreDBFStatistics(pcPic);
1812    }
1813
1814    //-- Loop filter
1815    Bool bLFCrossTileBoundary = pcSlice->getPPS()->getLoopFilterAcrossTilesEnabledFlag();
1816    m_pcLoopFilter->setCfg(bLFCrossTileBoundary);
1817    if ( m_pcCfg->getDeblockingFilterMetric() )
1818    {
1819      applyDeblockingFilterMetric(pcPic, uiNumSliceSegments);
1820    }
1821    m_pcLoopFilter->loopFilterPic( pcPic );
1822
1823    /////////////////////////////////////////////////////////////////////////////////////////////////// File writing
1824    // Set entropy coder
1825    m_pcEntropyCoder->setEntropyCoder   ( m_pcCavlcCoder );
1826    if ( m_bSeqFirst )
1827    {
1828      // write various parameter sets
1829      actualTotalBits += xWriteParameterSets(accessUnit, pcSlice);
1830#if PPS_FIX_DEPTH
1831      if(!pcSlice->getIsDepth() || !pcSlice->getViewIndex() )
1832      {
1833#endif
1834#if PPS_FIX_DEPTH
1835      }
1836#endif
1837
1838
1839      // create prefix SEI messages at the beginning of the sequence
1840      assert(leadingSeiMessages.empty());
1841      xCreateIRAPLeadingSEIMessages(leadingSeiMessages, pcSlice->getSPS(), pcSlice->getPPS());
1842
1843      m_bSeqFirst = false;
1844    }
1845
1846    // reset presence of BP SEI indication
1847    m_bufferingPeriodSEIPresentInAU = false;
1848    // create prefix SEI associated with a picture
1849    xCreatePerPictureSEIMessages(iGOPid, leadingSeiMessages, nestedSeiMessages, pcSlice);
1850
1851    /* use the main bitstream buffer for storing the marshalled picture */
1852    m_pcEntropyCoder->setBitstream(NULL);
1853
1854    pcSlice = pcPic->getSlice(0);
1855
1856    if (pcSlice->getSPS()->getUseSAO())
1857    {
1858      Bool sliceEnabled[MAX_NUM_COMPONENT];
1859      TComBitCounter tempBitCounter;
1860      tempBitCounter.resetBits();
1861      m_pcEncTop->getRDGoOnSbacCoder()->setBitstream(&tempBitCounter);
1862      m_pcSAO->initRDOCabacCoder(m_pcEncTop->getRDGoOnSbacCoder(), pcSlice);
1863      m_pcSAO->SAOProcess(pcPic, sliceEnabled, pcPic->getSlice(0)->getLambdas(), m_pcCfg->getTestSAODisableAtPictureLevel(), m_pcCfg->getSaoEncodingRate(), m_pcCfg->getSaoEncodingRateChroma(), m_pcCfg->getSaoCtuBoundary());
1864      m_pcSAO->PCMLFDisableProcess(pcPic);
1865      m_pcEncTop->getRDGoOnSbacCoder()->setBitstream(NULL);
1866
1867      //assign SAO slice header
1868      for(Int s=0; s< uiNumSliceSegments; s++)
1869      {
1870        pcPic->getSlice(s)->setSaoEnabledFlag(CHANNEL_TYPE_LUMA, sliceEnabled[COMPONENT_Y]);
1871        assert(sliceEnabled[COMPONENT_Cb] == sliceEnabled[COMPONENT_Cr]);
1872        pcPic->getSlice(s)->setSaoEnabledFlag(CHANNEL_TYPE_CHROMA, sliceEnabled[COMPONENT_Cb]);
1873      }
1874    }
1875
1876    // pcSlice is currently slice 0.
1877    std::size_t binCountsInNalUnits   = 0; // For implementation of cabac_zero_word stuffing (section 7.4.3.10)
1878    std::size_t numBytesInVclNalUnits = 0; // For implementation of cabac_zero_word stuffing (section 7.4.3.10)
1879
1880    for( UInt sliceSegmentStartCtuTsAddr = 0, sliceIdxCount=0; sliceSegmentStartCtuTsAddr < pcPic->getPicSym()->getNumberOfCtusInFrame(); sliceIdxCount++, sliceSegmentStartCtuTsAddr=pcSlice->getSliceSegmentCurEndCtuTsAddr() )
1881    {
1882      pcSlice = pcPic->getSlice(sliceIdxCount);
1883      if(sliceIdxCount > 0 && pcSlice->getSliceType()!= I_SLICE)
1884      {
1885        pcSlice->checkColRefIdx(sliceIdxCount, pcPic);
1886      }
1887      pcPic->setCurrSliceIdx(sliceIdxCount);
1888      m_pcSliceEncoder->setSliceIdx(sliceIdxCount);
1889
1890      pcSlice->setRPS(pcPic->getSlice(0)->getRPS());
1891      pcSlice->setRPSidx(pcPic->getSlice(0)->getRPSidx());
1892
1893      for ( UInt ui = 0 ; ui < numSubstreams; ui++ )
1894      {
1895        substreamsOut[ui].clear();
1896      }
1897
1898      m_pcEntropyCoder->setEntropyCoder   ( m_pcCavlcCoder );
1899      m_pcEntropyCoder->resetEntropy      ( pcSlice );
1900      /* start slice NALunit */
1901#if NH_MV
1902      OutputNALUnit nalu( pcSlice->getNalUnitType(), pcSlice->getTLayer(), getLayerId() );
1903#else
1904      OutputNALUnit nalu( pcSlice->getNalUnitType(), pcSlice->getTLayer() );
1905#endif
1906      m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
1907
1908      pcSlice->setNoRaslOutputFlag(false);
1909      if (pcSlice->isIRAP())
1910      {
1911        if (pcSlice->getNalUnitType() >= NAL_UNIT_CODED_SLICE_BLA_W_LP && pcSlice->getNalUnitType() <= NAL_UNIT_CODED_SLICE_IDR_N_LP)
1912        {
1913          pcSlice->setNoRaslOutputFlag(true);
1914        }
1915        //the inference for NoOutputPriorPicsFlag
1916        // KJS: This cannot happen at the encoder
1917        if (!m_bFirst && pcSlice->isIRAP() && pcSlice->getNoRaslOutputFlag())
1918        {
1919          if (pcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_CRA)
1920          {
1921            pcSlice->setNoOutputPriorPicsFlag(true);
1922          }
1923        }
1924      }
1925
1926      pcSlice->setEncCABACTableIdx(m_pcSliceEncoder->getEncCABACTableIdx());
1927
1928      tmpBitsBeforeWriting = m_pcEntropyCoder->getNumberOfWrittenBits();
1929      m_pcEntropyCoder->encodeSliceHeader(pcSlice);
1930      actualHeadBits += ( m_pcEntropyCoder->getNumberOfWrittenBits() - tmpBitsBeforeWriting );
1931
1932      pcSlice->setFinalized(true);
1933
1934      pcSlice->clearSubstreamSizes(  );
1935      {
1936        UInt numBinsCoded = 0;
1937        m_pcSliceEncoder->encodeSlice(pcPic, &(substreamsOut[0]), numBinsCoded);
1938        binCountsInNalUnits+=numBinsCoded;
1939      }
1940
1941      {
1942        // Construct the final bitstream by concatenating substreams.
1943        // The final bitstream is either nalu.m_Bitstream or pcBitstreamRedirect;
1944        // Complete the slice header info.
1945        m_pcEntropyCoder->setEntropyCoder   ( m_pcCavlcCoder );
1946        m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
1947        m_pcEntropyCoder->encodeTilesWPPEntryPoint( pcSlice );
1948
1949        // Append substreams...
1950        TComOutputBitstream *pcOut = pcBitstreamRedirect;
1951        const Int numZeroSubstreamsAtStartOfSlice  = pcPic->getSubstreamForCtuAddr(pcSlice->getSliceSegmentCurStartCtuTsAddr(), false, pcSlice);
1952        const Int numSubstreamsToCode  = pcSlice->getNumberOfSubstreamSizes()+1;
1953        for ( UInt ui = 0 ; ui < numSubstreamsToCode; ui++ )
1954        {
1955          pcOut->addSubstream(&(substreamsOut[ui+numZeroSubstreamsAtStartOfSlice]));
1956        }
1957      }
1958
1959      // If current NALU is the first NALU of slice (containing slice header) and more NALUs exist (due to multiple dependent slices) then buffer it.
1960      // 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.
1961      Bool bNALUAlignedWrittenToList    = false; // used to ensure current NALU is not written more than once to the NALU list.
1962      xAttachSliceDataToNalUnit(nalu, pcBitstreamRedirect);
1963      accessUnit.push_back(new NALUnitEBSP(nalu));
1964      actualTotalBits += UInt(accessUnit.back()->m_nalUnitData.str().size()) * 8;
1965      numBytesInVclNalUnits += (std::size_t)(accessUnit.back()->m_nalUnitData.str().size());
1966      bNALUAlignedWrittenToList = true;
1967
1968      if (!bNALUAlignedWrittenToList)
1969      {
1970        nalu.m_Bitstream.writeAlignZero();
1971        accessUnit.push_back(new NALUnitEBSP(nalu));
1972      }
1973
1974      if( ( m_pcCfg->getPictureTimingSEIEnabled() || m_pcCfg->getDecodingUnitInfoSEIEnabled() ) &&
1975          ( pcSlice->getSPS()->getVuiParametersPresentFlag() ) &&
1976          ( ( pcSlice->getSPS()->getVuiParameters()->getHrdParameters()->getNalHrdParametersPresentFlag() )
1977         || ( pcSlice->getSPS()->getVuiParameters()->getHrdParameters()->getVclHrdParametersPresentFlag() ) ) &&
1978          ( pcSlice->getSPS()->getVuiParameters()->getHrdParameters()->getSubPicCpbParamsPresentFlag() ) )
1979      {
1980          UInt numNalus = 0;
1981        UInt numRBSPBytes = 0;
1982        for (AccessUnit::const_iterator it = accessUnit.begin(); it != accessUnit.end(); it++)
1983        {
1984          numRBSPBytes += UInt((*it)->m_nalUnitData.str().size());
1985          numNalus ++;
1986        }
1987        duData.push_back(DUData());
1988        duData.back().accumBitsDU = ( numRBSPBytes << 3 );
1989        duData.back().accumNalsDU = numNalus;
1990      }
1991    } // end iteration over slices
1992
1993    // cabac_zero_words processing
1994    cabac_zero_word_padding(pcSlice, pcPic, binCountsInNalUnits, numBytesInVclNalUnits, accessUnit.back()->m_nalUnitData, m_pcCfg->getCabacZeroWordPaddingEnabled());
1995#if NH_3D
1996      pcPic->compressMotion(2); 
1997#else
1998    pcPic->compressMotion();
1999#endif
2000#if NH_MV
2001      m_pocLastCoded = pcPic->getPOC();
2002#endif
2003
2004    //-- For time output for each slice
2005    Double dEncTime = (Double)(clock()-iBeforeTime) / CLOCKS_PER_SEC;
2006
2007    std::string digestStr;
2008    if (m_pcCfg->getDecodedPictureHashSEIEnabled())
2009    {
2010      SEIDecodedPictureHash *decodedPictureHashSei = new SEIDecodedPictureHash();
2011      m_seiEncoder.initDecodedPictureHashSEI(decodedPictureHashSei, pcPic, digestStr, pcSlice->getSPS()->getBitDepths());
2012      trailingSeiMessages.push_back(decodedPictureHashSei);
2013    }
2014    xWriteTrailingSEIMessages(trailingSeiMessages, accessUnit, pcSlice->getTLayer(), pcSlice->getSPS());
2015
2016    m_pcCfg->setEncodedFlag(iGOPid, true);
2017
2018    xCalculateAddPSNRs( isField, isTff, iGOPid, pcPic, accessUnit, rcListPic, dEncTime, snr_conversion, printFrameMSE );
2019
2020    if (!digestStr.empty())
2021    {
2022      if(m_pcCfg->getDecodedPictureHashSEIEnabled() == 1)
2023      {
2024        printf(" [MD5:%s]", digestStr.c_str());
2025      }
2026      else if(m_pcCfg->getDecodedPictureHashSEIEnabled() == 2)
2027      {
2028        printf(" [CRC:%s]", digestStr.c_str());
2029      }
2030      else if(m_pcCfg->getDecodedPictureHashSEIEnabled() == 3)
2031      {
2032        printf(" [Checksum:%s]", digestStr.c_str());
2033      }
2034    }
2035
2036    if ( m_pcCfg->getUseRateCtrl() )
2037    {
2038      Double avgQP     = m_pcRateCtrl->getRCPic()->calAverageQP();
2039      Double avgLambda = m_pcRateCtrl->getRCPic()->calAverageLambda();
2040      if ( avgLambda < 0.0 )
2041      {
2042        avgLambda = lambda;
2043      }
2044
2045      m_pcRateCtrl->getRCPic()->updateAfterPicture( actualHeadBits, actualTotalBits, avgQP, avgLambda, pcSlice->getSliceType());
2046      m_pcRateCtrl->getRCPic()->addToPictureLsit( m_pcRateCtrl->getPicList() );
2047
2048      m_pcRateCtrl->getRCSeq()->updateAfterPic( actualTotalBits );
2049      if ( pcSlice->getSliceType() != I_SLICE )
2050      {
2051        m_pcRateCtrl->getRCGOP()->updateAfterPicture( actualTotalBits );
2052      }
2053      else    // for intra picture, the estimated bits are used to update the current status in the GOP
2054      {
2055        m_pcRateCtrl->getRCGOP()->updateAfterPicture( estimatedBits );
2056      }
2057    }
2058
2059    xCreatePictureTimingSEI(m_pcCfg->getEfficientFieldIRAPEnabled()?effFieldIRAPMap.GetIRAPGOPid():0, leadingSeiMessages, nestedSeiMessages, duInfoSeiMessages, pcSlice, isField, duData);
2060    if (m_pcCfg->getScalableNestingSEIEnabled())
2061    {
2062      xCreateScalableNestingSEI (leadingSeiMessages, nestedSeiMessages);
2063    }
2064    xWriteLeadingSEIMessages(leadingSeiMessages, duInfoSeiMessages, accessUnit, pcSlice->getTLayer(), pcSlice->getSPS(), duData);
2065    xWriteDuSEIMessages(duInfoSeiMessages, accessUnit, pcSlice->getTLayer(), pcSlice->getSPS(), duData);
2066
2067    pcPic->getPicYuvRec()->copyToPic(pcPicYuvRecOut);
2068
2069    pcPic->setReconMark   ( true );
2070#if NH_MV
2071      TComSlice::markIvRefPicsAsShortTerm( m_refPicSetInterLayer0, m_refPicSetInterLayer1 ); 
2072      std::vector<Int> temp; 
2073      TComSlice::markCurrPic( pcPic ); 
2074#endif
2075    m_bFirst = false;
2076    m_iNumPicCoded++;
2077    m_totalCoded ++;
2078    /* logging: insert a newline at end of picture period */
2079    printf("\n");
2080    fflush(stdout);
2081
2082    if (m_pcCfg->getEfficientFieldIRAPEnabled())
2083    {
2084    iGOPid=effFieldIRAPMap.restoreGOPid(iGOPid);
2085    }
2086  } // iGOPid-loop
2087
2088  delete pcBitstreamRedirect;
2089
2090#if !NH_MV
2091  assert ( (m_iNumPicCoded == iNumPicRcvd) );
2092#endif
2093}
2094
2095Void TEncGOP::printOutSummary(UInt uiNumAllPicCoded, Bool isField, const Bool printMSEBasedSNR, const Bool printSequenceMSE, const BitDepths &bitDepths)
2096{
2097  assert (uiNumAllPicCoded == m_gcAnalyzeAll.getNumPic());
2098
2099
2100  //--CFG_KDY
2101  const Int rateMultiplier=(isField?2:1);
2102  m_gcAnalyzeAll.setFrmRate( m_pcCfg->getFrameRate()*rateMultiplier );
2103  m_gcAnalyzeI.setFrmRate( m_pcCfg->getFrameRate()*rateMultiplier );
2104  m_gcAnalyzeP.setFrmRate( m_pcCfg->getFrameRate()*rateMultiplier );
2105  m_gcAnalyzeB.setFrmRate( m_pcCfg->getFrameRate()*rateMultiplier );
2106  const ChromaFormat chFmt = m_pcCfg->getChromaFormatIdc();
2107
2108  //-- all
2109#if NH_MV
2110  printf( "\n\nSUMMARY -------------------------------------------- LayerId %2d\n", getLayerId() );   
2111#else
2112  printf( "\n\nSUMMARY --------------------------------------------------------\n" );
2113#endif
2114  m_gcAnalyzeAll.printOut('a', chFmt, printMSEBasedSNR, printSequenceMSE, bitDepths);
2115
2116  printf( "\n\nI Slices--------------------------------------------------------\n" );
2117  m_gcAnalyzeI.printOut('i', chFmt, printMSEBasedSNR, printSequenceMSE, bitDepths);
2118
2119  printf( "\n\nP Slices--------------------------------------------------------\n" );
2120  m_gcAnalyzeP.printOut('p', chFmt, printMSEBasedSNR, printSequenceMSE, bitDepths);
2121
2122  printf( "\n\nB Slices--------------------------------------------------------\n" );
2123  m_gcAnalyzeB.printOut('b', chFmt, printMSEBasedSNR, printSequenceMSE, bitDepths);
2124
2125  if (!m_pcCfg->getSummaryOutFilename().empty())
2126  {
2127    m_gcAnalyzeAll.printSummary(chFmt, printSequenceMSE, bitDepths, m_pcCfg->getSummaryOutFilename());
2128  }
2129
2130  if (!m_pcCfg->getSummaryPicFilenameBase().empty())
2131  {
2132    m_gcAnalyzeI.printSummary(chFmt, printSequenceMSE, bitDepths, m_pcCfg->getSummaryPicFilenameBase()+"I.txt");
2133    m_gcAnalyzeP.printSummary(chFmt, printSequenceMSE, bitDepths, m_pcCfg->getSummaryPicFilenameBase()+"P.txt");
2134    m_gcAnalyzeB.printSummary(chFmt, printSequenceMSE, bitDepths, m_pcCfg->getSummaryPicFilenameBase()+"B.txt");
2135  }
2136
2137  if(isField)
2138  {
2139    //-- interlaced summary
2140    m_gcAnalyzeAll_in.setFrmRate( m_pcCfg->getFrameRate());
2141    m_gcAnalyzeAll_in.setBits(m_gcAnalyzeAll.getBits());
2142    // prior to the above statement, the interlace analyser does not contain the correct total number of bits.
2143
2144    printf( "\n\nSUMMARY INTERLACED ---------------------------------------------\n" );
2145    m_gcAnalyzeAll_in.printOut('a', chFmt, printMSEBasedSNR, printSequenceMSE, bitDepths);
2146
2147    if (!m_pcCfg->getSummaryOutFilename().empty())
2148    {
2149      m_gcAnalyzeAll_in.printSummary(chFmt, printSequenceMSE, bitDepths, m_pcCfg->getSummaryOutFilename());
2150    }
2151  }
2152
2153  printf("\nRVM: %.3lf\n" , xCalculateRVM());
2154}
2155
2156#if NH_3D_VSO
2157Void TEncGOP::preLoopFilterPicAll( TComPic* pcPic, Dist64& ruiDist )
2158#else
2159Void TEncGOP::preLoopFilterPicAll( TComPic* pcPic, UInt64& ruiDist )
2160#endif
2161{
2162  Bool bCalcDist = false;
2163  m_pcLoopFilter->setCfg(m_pcCfg->getLFCrossTileBoundaryFlag());
2164  m_pcLoopFilter->loopFilterPic( pcPic );
2165
2166  if (!bCalcDist)
2167  {
2168    ruiDist = xFindDistortionFrame(pcPic->getPicYuvOrg(), pcPic->getPicYuvRec(), pcPic->getPicSym()->getSPS().getBitDepths());
2169  }
2170}
2171
2172// ====================================================================================================================
2173// Protected member functions
2174// ====================================================================================================================
2175
2176
2177Void TEncGOP::xInitGOP( Int iPOCLast, Int iNumPicRcvd, Bool isField )
2178{
2179  assert( iNumPicRcvd > 0 );
2180  //  Exception for the first frames
2181  if ( ( isField && (iPOCLast == 0 || iPOCLast == 1) ) || (!isField  && (iPOCLast == 0))  )
2182  {
2183    m_iGopSize    = 1;
2184  }
2185  else
2186  {
2187    m_iGopSize    = m_pcCfg->getGOPSize();
2188  }
2189  assert (m_iGopSize > 0);
2190
2191  return;
2192}
2193
2194
2195Void TEncGOP::xGetBuffer( TComList<TComPic*>&      rcListPic,
2196                         TComList<TComPicYuv*>&    rcListPicYuvRecOut,
2197                         Int                       iNumPicRcvd,
2198                         Int                       iTimeOffset,
2199                         TComPic*&                 rpcPic,
2200                         TComPicYuv*&              rpcPicYuvRecOut,
2201                         Int                       pocCurr,
2202                         Bool                      isField)
2203{
2204  Int i;
2205  //  Rec. output
2206  TComList<TComPicYuv*>::iterator     iterPicYuvRec = rcListPicYuvRecOut.end();
2207
2208  if (isField && pocCurr > 1 && m_iGopSize!=1)
2209  {
2210    iTimeOffset--;
2211  }
2212
2213  for ( i = 0; i < (iNumPicRcvd - iTimeOffset + 1); i++ )
2214  {
2215    iterPicYuvRec--;
2216  }
2217
2218  rpcPicYuvRecOut = *(iterPicYuvRec);
2219
2220  //  Current pic.
2221  TComList<TComPic*>::iterator        iterPic       = rcListPic.begin();
2222  while (iterPic != rcListPic.end())
2223  {
2224    rpcPic = *(iterPic);
2225    rpcPic->setCurrSliceIdx(0);
2226    if (rpcPic->getPOC() == pocCurr)
2227    {
2228      break;
2229    }
2230    iterPic++;
2231  }
2232
2233#if !NH_MV
2234  assert (rpcPic != NULL);
2235#endif
2236  assert (rpcPic->getPOC() == pocCurr);
2237
2238  return;
2239}
2240
2241#if NH_3D_VSO
2242Dist64 TEncGOP::xFindDistortionFrame (TComPicYuv* pcPic0, TComPicYuv* pcPic1, const BitDepths &bitDepths)
2243#else
2244UInt64 TEncGOP::xFindDistortionFrame (TComPicYuv* pcPic0, TComPicYuv* pcPic1, const BitDepths &bitDepths)
2245#endif
2246{
2247#if NH_3D_VSO
2248  Dist64  uiTotalDiff = 0;
2249#else
2250  UInt64  uiTotalDiff = 0;
2251#endif
2252
2253  for(Int chan=0; chan<pcPic0 ->getNumberValidComponents(); chan++)
2254  {
2255    const ComponentID ch=ComponentID(chan);
2256    Pel*  pSrc0   = pcPic0 ->getAddr(ch);
2257    Pel*  pSrc1   = pcPic1 ->getAddr(ch);
2258    UInt  uiShift     = 2 * DISTORTION_PRECISION_ADJUSTMENT(bitDepths.recon[toChannelType(ch)]-8);
2259
2260    const Int   iStride = pcPic0->getStride(ch);
2261    const Int   iWidth  = pcPic0->getWidth(ch);
2262    const Int   iHeight = pcPic0->getHeight(ch);
2263
2264    for(Int y = 0; y < iHeight; y++ )
2265    {
2266      for(Int x = 0; x < iWidth; x++ )
2267      {
2268        Intermediate_Int iTemp = pSrc0[x] - pSrc1[x];
2269        uiTotalDiff += UInt64((iTemp*iTemp) >> uiShift);
2270      }
2271      pSrc0 += iStride;
2272      pSrc1 += iStride;
2273    }
2274  }
2275
2276  return uiTotalDiff;
2277}
2278
2279Void TEncGOP::xCalculateAddPSNRs( const Bool isField, const Bool isFieldTopFieldFirst, const Int iGOPid, TComPic* pcPic, const AccessUnit&accessUnit, TComList<TComPic*> &rcListPic, const Double dEncTime, const InputColourSpaceConversion snr_conversion, const Bool printFrameMSE )
2280{
2281  xCalculateAddPSNR( pcPic, pcPic->getPicYuvRec(), accessUnit, dEncTime, snr_conversion, printFrameMSE );
2282
2283  //In case of field coding, compute the interlaced PSNR for both fields
2284  if(isField)
2285  {
2286    Bool bothFieldsAreEncoded = false;
2287    Int correspondingFieldPOC = pcPic->getPOC();
2288    Int currentPicGOPPoc = m_pcCfg->getGOPEntry(iGOPid).m_POC;
2289    if(pcPic->getPOC() == 0)
2290    {
2291      // particular case for POC 0 and 1.
2292      // If they are not encoded first and separately from other pictures, we need to change this
2293      // POC 0 is always encoded first then POC 1 is encoded
2294      bothFieldsAreEncoded = false;
2295    }
2296    else if(pcPic->getPOC() == 1)
2297    {
2298      // if we are at POC 1, POC 0 has been encoded for sure
2299      correspondingFieldPOC = 0;
2300      bothFieldsAreEncoded = true;
2301    }
2302    else
2303    {
2304      if(pcPic->getPOC()%2 == 1)
2305      {
2306        correspondingFieldPOC -= 1; // all odd POC are associated with the preceding even POC (e.g poc 1 is associated to poc 0)
2307        currentPicGOPPoc      -= 1;
2308      }
2309      else
2310      {
2311        correspondingFieldPOC += 1; // all even POC are associated with the following odd POC (e.g poc 0 is associated to poc 1)
2312        currentPicGOPPoc      += 1;
2313      }
2314      for(Int i = 0; i < m_iGopSize; i ++)
2315      {
2316        if(m_pcCfg->getGOPEntry(i).m_POC == currentPicGOPPoc)
2317        {
2318          bothFieldsAreEncoded = m_pcCfg->getGOPEntry(i).m_isEncoded;
2319          break;
2320        }
2321      }
2322    }
2323
2324    if(bothFieldsAreEncoded)
2325    {
2326      //get complementary top field
2327      TComList<TComPic*>::iterator   iterPic = rcListPic.begin();
2328      while ((*iterPic)->getPOC() != correspondingFieldPOC)
2329      {
2330        iterPic ++;
2331      }
2332      TComPic* correspondingFieldPic = *(iterPic);
2333
2334      if( (pcPic->isTopField() && isFieldTopFieldFirst) || (!pcPic->isTopField() && !isFieldTopFieldFirst))
2335      {
2336        xCalculateInterlacedAddPSNR(pcPic, correspondingFieldPic, pcPic->getPicYuvRec(), correspondingFieldPic->getPicYuvRec(), snr_conversion, printFrameMSE );
2337      }
2338      else
2339      {
2340        xCalculateInterlacedAddPSNR(correspondingFieldPic, pcPic, correspondingFieldPic->getPicYuvRec(), pcPic->getPicYuvRec(), snr_conversion, printFrameMSE );
2341      }
2342    }
2343  }
2344}
2345
2346Void TEncGOP::xCalculateAddPSNR( TComPic* pcPic, TComPicYuv* pcPicD, const AccessUnit& accessUnit, Double dEncTime, const InputColourSpaceConversion conversion, const Bool printFrameMSE )
2347{
2348  Double  dPSNR[MAX_NUM_COMPONENT];
2349
2350  for(Int i=0; i<MAX_NUM_COMPONENT; i++)
2351  {
2352    dPSNR[i]=0.0;
2353  }
2354
2355  TComPicYuv cscd;
2356  if (conversion!=IPCOLOURSPACE_UNCHANGED)
2357  {
2358    cscd.create(pcPicD->getWidth(COMPONENT_Y), pcPicD->getHeight(COMPONENT_Y), pcPicD->getChromaFormat(), pcPicD->getWidth(COMPONENT_Y), pcPicD->getHeight(COMPONENT_Y), 0, false);
2359    TVideoIOYuv::ColourSpaceConvert(*pcPicD, cscd, conversion, false);
2360  }
2361  TComPicYuv &picd=(conversion==IPCOLOURSPACE_UNCHANGED)?*pcPicD : cscd;
2362
2363  //===== calculate PSNR =====
2364  Double MSEyuvframe[MAX_NUM_COMPONENT] = {0, 0, 0};
2365
2366  for(Int chan=0; chan<pcPicD->getNumberValidComponents(); chan++)
2367  {
2368    const ComponentID ch=ComponentID(chan);
2369    const TComPicYuv *pOrgPicYuv =(conversion!=IPCOLOURSPACE_UNCHANGED) ? pcPic ->getPicYuvTrueOrg() : pcPic ->getPicYuvOrg();
2370    const Pel*  pOrg       = pOrgPicYuv->getAddr(ch);
2371    const Int   iOrgStride = pOrgPicYuv->getStride(ch);
2372    Pel*  pRec    = picd.getAddr(ch);
2373    const Int   iRecStride = picd.getStride(ch);
2374
2375    const Int   iWidth  = pcPicD->getWidth (ch) - (m_pcEncTop->getPad(0) >> pcPic->getComponentScaleX(ch));
2376    const Int   iHeight = pcPicD->getHeight(ch) - ((m_pcEncTop->getPad(1) >> (pcPic->isField()?1:0)) >> pcPic->getComponentScaleY(ch));
2377
2378    Int   iSize   = iWidth*iHeight;
2379
2380    UInt64 uiSSDtemp=0;
2381    for(Int y = 0; y < iHeight; y++ )
2382    {
2383      for(Int x = 0; x < iWidth; x++ )
2384      {
2385        Intermediate_Int iDiff = (Intermediate_Int)( pOrg[x] - pRec[x] );
2386        uiSSDtemp   += iDiff * iDiff;
2387      }
2388      pOrg += iOrgStride;
2389      pRec += iRecStride;
2390    }
2391#if NH_3D_VSO
2392#if H_3D_VSO_SYNTH_DIST_OUT
2393  if ( m_pcRdCost->getUseRenModel() )
2394  {
2395    unsigned int maxval = 255 * (1<<(g_uiBitDepth + g_uiBitIncrement -8));
2396    Double fRefValueY = (double) maxval * maxval * iSize;
2397    Double fRefValueC = fRefValueY / 4.0;
2398    TRenModel*  pcRenModel = m_pcEncTop->getEncTop()->getRenModel();
2399    Int64 iDistVSOY, iDistVSOU, iDistVSOV;
2400    pcRenModel->getTotalSSE( iDistVSOY, iDistVSOU, iDistVSOV );
2401    dYPSNR = ( iDistVSOY ? 10.0 * log10( fRefValueY / (Double) iDistVSOY ) : 99.99 );
2402    dUPSNR = ( iDistVSOU ? 10.0 * log10( fRefValueC / (Double) iDistVSOU ) : 99.99 );
2403    dVPSNR = ( iDistVSOV ? 10.0 * log10( fRefValueC / (Double) iDistVSOV ) : 99.99 );
2404  }
2405  else
2406  {
2407#endif
2408#endif
2409    const Int maxval = 255 << (pcPic->getPicSym()->getSPS().getBitDepth(toChannelType(ch)) - 8);
2410    const Double fRefValue = (Double) maxval * maxval * iSize;
2411    dPSNR[ch]         = ( uiSSDtemp ? 10.0 * log10( fRefValue / (Double)uiSSDtemp ) : 999.99 );
2412    MSEyuvframe[ch]   = (Double)uiSSDtemp/(iSize);
2413  }
2414
2415#if NH_3D_VSO
2416#if H_3D_VSO_SYNTH_DIST_OUT
2417}
2418#endif
2419#endif 
2420  /* calculate the size of the access unit, excluding:
2421   *  - any AnnexB contributions (start_code_prefix, zero_byte, etc.,)
2422   *  - SEI NAL units
2423   */
2424  UInt numRBSPBytes = 0;
2425  for (AccessUnit::const_iterator it = accessUnit.begin(); it != accessUnit.end(); it++)
2426  {
2427    UInt numRBSPBytes_nal = UInt((*it)->m_nalUnitData.str().size());
2428    if (m_pcCfg->getSummaryVerboseness() > 0)
2429    {
2430    printf("*** %6s numBytesInNALunit: %u\n", nalUnitTypeToString((*it)->m_nalUnitType), numRBSPBytes_nal);
2431    }
2432    if ((*it)->m_nalUnitType != NAL_UNIT_PREFIX_SEI && (*it)->m_nalUnitType != NAL_UNIT_SUFFIX_SEI)
2433    {
2434      numRBSPBytes += numRBSPBytes_nal;
2435    }
2436  }
2437
2438  UInt uibits = numRBSPBytes * 8;
2439  m_vRVM_RP.push_back( uibits );
2440
2441  //===== add PSNR =====
2442  m_gcAnalyzeAll.addResult (dPSNR, (Double)uibits, MSEyuvframe);
2443
2444  TComSlice*  pcSlice = pcPic->getSlice(0);
2445  if (pcSlice->isIntra())
2446  {
2447    m_gcAnalyzeI.addResult (dPSNR, (Double)uibits, MSEyuvframe);
2448  }
2449  if (pcSlice->isInterP())
2450  {
2451    m_gcAnalyzeP.addResult (dPSNR, (Double)uibits, MSEyuvframe);
2452  }
2453  if (pcSlice->isInterB())
2454  {
2455    m_gcAnalyzeB.addResult (dPSNR, (Double)uibits, MSEyuvframe);
2456  }
2457
2458  Char c = (pcSlice->isIntra() ? 'I' : pcSlice->isInterP() ? 'P' : 'B');
2459  if (!pcSlice->isReferenced())
2460  {
2461    c += 32;
2462  }
2463
2464#if ADAPTIVE_QP_SELECTION
2465#if NH_MV
2466  printf("Layer %3d   POC %4d TId: %1d ( %c-SLICE, nQP %d QP %d ) %10d  bits",
2467    pcSlice->getLayerId(),
2468    pcSlice->getPOC(),
2469    pcSlice->getTLayer(),
2470    c,
2471    pcSlice->getSliceQpBase(),
2472    pcSlice->getSliceQp(),
2473    uibits );
2474#else
2475  printf("POC %4d TId: %1d ( %c-SLICE, nQP %d QP %d ) %10d bits",
2476         pcSlice->getPOC(),
2477         pcSlice->getTLayer(),
2478         c,
2479         pcSlice->getSliceQpBase(),
2480         pcSlice->getSliceQp(),
2481         uibits );
2482#endif
2483#else
2484#if NH_MV
2485  printf("Layer %3d   POC %4d TId: %1d ( %c-SLICE, QP %d ) %10d bits",
2486    pcSlice->getLayerId(),
2487    pcSlice->getPOC()-pcSlice->getLastIDR(),
2488    pcSlice->getTLayer(),
2489    c,
2490    pcSlice->getSliceQp(),
2491    uibits );
2492#else
2493  printf("POC %4d TId: %1d ( %c-SLICE, QP %d ) %10d bits",
2494         pcSlice->getPOC()-pcSlice->getLastIDR(),
2495         pcSlice->getTLayer(),
2496         c,
2497         pcSlice->getSliceQp(),
2498         uibits );
2499#endif
2500#endif
2501#if NH_MV
2502  printf(" [Y %8.4lf dB    U %8.4lf dB    V %8.4lf dB]", dPSNR[COMPONENT_Y], dPSNR[COMPONENT_Cb], dPSNR[COMPONENT_Cr] );
2503#else
2504  printf(" [Y %6.4lf dB    U %6.4lf dB    V %6.4lf dB]", dPSNR[COMPONENT_Y], dPSNR[COMPONENT_Cb], dPSNR[COMPONENT_Cr] );
2505#endif
2506  if (printFrameMSE)
2507  {
2508    printf(" [Y MSE %6.4lf  U MSE %6.4lf  V MSE %6.4lf]", MSEyuvframe[COMPONENT_Y], MSEyuvframe[COMPONENT_Cb], MSEyuvframe[COMPONENT_Cr] );
2509  }
2510  printf(" [ET %5.0f ]", dEncTime );
2511
2512  for (Int iRefList = 0; iRefList < 2; iRefList++)
2513  {
2514    printf(" [L%d ", iRefList);
2515    for (Int iRefIndex = 0; iRefIndex < pcSlice->getNumRefIdx(RefPicList(iRefList)); iRefIndex++)
2516    {
2517#if NH_MV
2518      if( pcSlice->getLayerId() != pcSlice->getRefLayerId( RefPicList(iRefList), iRefIndex ) )
2519      {
2520        printf( "V%d ", pcSlice->getRefLayerId( RefPicList(iRefList), iRefIndex ) );
2521      }
2522      else
2523      {
2524#endif
2525      printf ("%d ", pcSlice->getRefPOC(RefPicList(iRefList), iRefIndex)-pcSlice->getLastIDR());
2526#if NH_MV
2527      }
2528#endif
2529    }
2530    printf("]");
2531  }
2532
2533  cscd.destroy();
2534}
2535
2536Void TEncGOP::xCalculateInterlacedAddPSNR( TComPic* pcPicOrgFirstField, TComPic* pcPicOrgSecondField,
2537                                           TComPicYuv* pcPicRecFirstField, TComPicYuv* pcPicRecSecondField,
2538                                           const InputColourSpaceConversion conversion, const Bool printFrameMSE )
2539{
2540
2541#if  NH_MV
2542  assert( 0 ); // Field coding and MV need to be aligned.
2543#else
2544
2545  const TComSPS &sps=pcPicOrgFirstField->getPicSym()->getSPS();
2546  Double  dPSNR[MAX_NUM_COMPONENT];
2547  TComPic    *apcPicOrgFields[2]={pcPicOrgFirstField, pcPicOrgSecondField};
2548  TComPicYuv *apcPicRecFields[2]={pcPicRecFirstField, pcPicRecSecondField};
2549
2550  for(Int i=0; i<MAX_NUM_COMPONENT; i++)
2551  {
2552    dPSNR[i]=0.0;
2553  }
2554
2555  TComPicYuv cscd[2 /* first/second field */];
2556  if (conversion!=IPCOLOURSPACE_UNCHANGED)
2557  {
2558    for(UInt fieldNum=0; fieldNum<2; fieldNum++)
2559    {
2560      TComPicYuv &reconField=*(apcPicRecFields[fieldNum]);
2561      cscd[fieldNum].create(reconField.getWidth(COMPONENT_Y), reconField.getHeight(COMPONENT_Y), reconField.getChromaFormat(), reconField.getWidth(COMPONENT_Y), reconField.getHeight(COMPONENT_Y), 0, false);
2562      TVideoIOYuv::ColourSpaceConvert(reconField, cscd[fieldNum], conversion, false);
2563      apcPicRecFields[fieldNum]=cscd+fieldNum;
2564    }
2565  }
2566
2567  //===== calculate PSNR =====
2568  Double MSEyuvframe[MAX_NUM_COMPONENT] = {0, 0, 0};
2569
2570  assert(apcPicRecFields[0]->getChromaFormat()==apcPicRecFields[1]->getChromaFormat());
2571  const UInt numValidComponents=apcPicRecFields[0]->getNumberValidComponents();
2572
2573  for(Int chan=0; chan<numValidComponents; chan++)
2574  {
2575    const ComponentID ch=ComponentID(chan);
2576    assert(apcPicRecFields[0]->getWidth(ch)==apcPicRecFields[1]->getWidth(ch));
2577    assert(apcPicRecFields[0]->getHeight(ch)==apcPicRecFields[1]->getHeight(ch));
2578
2579    UInt64 uiSSDtemp=0;
2580    const Int   iWidth  = apcPicRecFields[0]->getWidth (ch) - (m_pcEncTop->getPad(0) >> apcPicRecFields[0]->getComponentScaleX(ch));
2581    const Int   iHeight = apcPicRecFields[0]->getHeight(ch) - ((m_pcEncTop->getPad(1) >> 1) >> apcPicRecFields[0]->getComponentScaleY(ch));
2582
2583    Int   iSize   = iWidth*iHeight;
2584
2585    for(UInt fieldNum=0; fieldNum<2; fieldNum++)
2586    {
2587      TComPic *pcPic=apcPicOrgFields[fieldNum];
2588      TComPicYuv *pcPicD=apcPicRecFields[fieldNum];
2589
2590      const Pel*  pOrg    = (conversion!=IPCOLOURSPACE_UNCHANGED) ? pcPic ->getPicYuvTrueOrg()->getAddr(ch) : pcPic ->getPicYuvOrg()->getAddr(ch);
2591      Pel*  pRec    = pcPicD->getAddr(ch);
2592      const Int   iStride = pcPicD->getStride(ch);
2593
2594
2595      for(Int y = 0; y < iHeight; y++ )
2596      {
2597        for(Int x = 0; x < iWidth; x++ )
2598        {
2599          Intermediate_Int iDiff = (Intermediate_Int)( pOrg[x] - pRec[x] );
2600          uiSSDtemp   += iDiff * iDiff;
2601        }
2602        pOrg += iStride;
2603        pRec += iStride;
2604      }
2605    }
2606    const Int maxval = 255 << (sps.getBitDepth(toChannelType(ch)) - 8);
2607    const Double fRefValue = (Double) maxval * maxval * iSize*2;
2608    dPSNR[ch]         = ( uiSSDtemp ? 10.0 * log10( fRefValue / (Double)uiSSDtemp ) : 999.99 );
2609    MSEyuvframe[ch]   = (Double)uiSSDtemp/(iSize*2);
2610  }
2611
2612  UInt uibits = 0; // the number of bits for the pair is not calculated here - instead the overall total is used elsewhere.
2613
2614  //===== add PSNR =====
2615  m_gcAnalyzeAll_in.addResult (dPSNR, (Double)uibits, MSEyuvframe);
2616
2617  printf("\n                                      Interlaced frame %d: [Y %6.4lf dB    U %6.4lf dB    V %6.4lf dB]", pcPicOrgSecondField->getPOC()/2 , dPSNR[COMPONENT_Y], dPSNR[COMPONENT_Cb], dPSNR[COMPONENT_Cr] );
2618  if (printFrameMSE)
2619  {
2620    printf(" [Y MSE %6.4lf  U MSE %6.4lf  V MSE %6.4lf]", MSEyuvframe[COMPONENT_Y], MSEyuvframe[COMPONENT_Cb], MSEyuvframe[COMPONENT_Cr] );
2621  }
2622
2623  for(UInt fieldNum=0; fieldNum<2; fieldNum++)
2624  {
2625    cscd[fieldNum].destroy();
2626  }
2627#endif
2628}
2629
2630/** Function for deciding the nal_unit_type.
2631 * \param pocCurr POC of the current picture
2632 * \param lastIDR  POC of the last IDR picture
2633 * \param isField  true to indicate field coding
2634 * \returns the NAL unit type of the picture
2635 * This function checks the configuration and returns the appropriate nal_unit_type for the picture.
2636 */
2637NalUnitType TEncGOP::getNalUnitType(Int pocCurr, Int lastIDR, Bool isField)
2638{
2639  if (pocCurr == 0)
2640  {
2641    return NAL_UNIT_CODED_SLICE_IDR_W_RADL;
2642  }
2643
2644  if(m_pcCfg->getEfficientFieldIRAPEnabled() && isField && pocCurr == 1)
2645  {
2646    // to avoid the picture becoming an IRAP
2647    return NAL_UNIT_CODED_SLICE_TRAIL_R;
2648  }
2649
2650  if(m_pcCfg->getDecodingRefreshType() != 3 && (pocCurr - isField) % m_pcCfg->getIntraPeriod() == 0)
2651  {
2652    if (m_pcCfg->getDecodingRefreshType() == 1)
2653    {
2654      return NAL_UNIT_CODED_SLICE_CRA;
2655    }
2656    else if (m_pcCfg->getDecodingRefreshType() == 2)
2657    {
2658      return NAL_UNIT_CODED_SLICE_IDR_W_RADL;
2659    }
2660  }
2661  if(m_pocCRA>0)
2662  {
2663    if(pocCurr<m_pocCRA)
2664    {
2665      // All leading pictures are being marked as TFD pictures here since current encoder uses all
2666      // reference pictures while encoding leading pictures. An encoder can ensure that a leading
2667      // picture can be still decodable when random accessing to a CRA/CRANT/BLA/BLANT picture by
2668      // controlling the reference pictures used for encoding that leading picture. Such a leading
2669      // picture need not be marked as a TFD picture.
2670      return NAL_UNIT_CODED_SLICE_RASL_R;
2671    }
2672  }
2673  if (lastIDR>0)
2674  {
2675    if (pocCurr < lastIDR)
2676    {
2677      return NAL_UNIT_CODED_SLICE_RADL_R;
2678    }
2679  }
2680  return NAL_UNIT_CODED_SLICE_TRAIL_R;
2681}
2682
2683
2684Double TEncGOP::xCalculateRVM()
2685{
2686  Double dRVM = 0;
2687
2688  if( m_pcCfg->getGOPSize() == 1 && m_pcCfg->getIntraPeriod() != 1 && m_pcCfg->getFramesToBeEncoded() > RVM_VCEGAM10_M * 2 )
2689  {
2690    // calculate RVM only for lowdelay configurations
2691    std::vector<Double> vRL , vB;
2692    size_t N = m_vRVM_RP.size();
2693    vRL.resize( N );
2694    vB.resize( N );
2695
2696    Int i;
2697    Double dRavg = 0 , dBavg = 0;
2698    vB[RVM_VCEGAM10_M] = 0;
2699    for( i = RVM_VCEGAM10_M + 1 ; i < N - RVM_VCEGAM10_M + 1 ; i++ )
2700    {
2701      vRL[i] = 0;
2702      for( Int j = i - RVM_VCEGAM10_M ; j <= i + RVM_VCEGAM10_M - 1 ; j++ )
2703      {
2704        vRL[i] += m_vRVM_RP[j];
2705      }
2706      vRL[i] /= ( 2 * RVM_VCEGAM10_M );
2707      vB[i] = vB[i-1] + m_vRVM_RP[i] - vRL[i];
2708      dRavg += m_vRVM_RP[i];
2709      dBavg += vB[i];
2710    }
2711
2712    dRavg /= ( N - 2 * RVM_VCEGAM10_M );
2713    dBavg /= ( N - 2 * RVM_VCEGAM10_M );
2714
2715    Double dSigamB = 0;
2716    for( i = RVM_VCEGAM10_M + 1 ; i < N - RVM_VCEGAM10_M + 1 ; i++ )
2717    {
2718      Double tmp = vB[i] - dBavg;
2719      dSigamB += tmp * tmp;
2720    }
2721    dSigamB = sqrt( dSigamB / ( N - 2 * RVM_VCEGAM10_M ) );
2722
2723    Double f = sqrt( 12.0 * ( RVM_VCEGAM10_M - 1 ) / ( RVM_VCEGAM10_M + 1 ) );
2724
2725    dRVM = dSigamB / dRavg * f;
2726  }
2727
2728  return( dRVM );
2729}
2730/** Attaches the input bitstream to the stream in the output NAL unit
2731    Updates rNalu to contain concatenated bitstream. rpcBitstreamRedirect is cleared at the end of this function call.
2732 *  \param codedSliceData contains the coded slice data (bitstream) to be concatenated to rNalu
2733 *  \param rNalu          target NAL unit
2734 */
2735Void TEncGOP::xAttachSliceDataToNalUnit (OutputNALUnit& rNalu, TComOutputBitstream* codedSliceData)
2736{
2737  // Byte-align
2738  rNalu.m_Bitstream.writeByteAlignment();   // Slice header byte-alignment
2739
2740  // Perform bitstream concatenation
2741  if (codedSliceData->getNumberOfWrittenBits() > 0)
2742  {
2743    rNalu.m_Bitstream.addSubstream(codedSliceData);
2744  }
2745
2746  m_pcEntropyCoder->setBitstream(&rNalu.m_Bitstream);
2747
2748  codedSliceData->clear();
2749}
2750
2751// Function will arrange the long-term pictures in the decreasing order of poc_lsb_lt,
2752// and among the pictures with the same lsb, it arranges them in increasing delta_poc_msb_cycle_lt value
2753Void TEncGOP::arrangeLongtermPicturesInRPS(TComSlice *pcSlice, TComList<TComPic*>& rcListPic)
2754{
2755  TComReferencePictureSet *rps = pcSlice->getRPS();
2756  if(!rps->getNumberOfLongtermPictures())
2757  {
2758    return;
2759  }
2760
2761  // Arrange long-term reference pictures in the correct order of LSB and MSB,
2762  // and assign values for pocLSBLT and MSB present flag
2763  Int longtermPicsPoc[MAX_NUM_REF_PICS], longtermPicsLSB[MAX_NUM_REF_PICS], indices[MAX_NUM_REF_PICS];
2764  Int longtermPicsMSB[MAX_NUM_REF_PICS];
2765  Bool mSBPresentFlag[MAX_NUM_REF_PICS];
2766  ::memset(longtermPicsPoc, 0, sizeof(longtermPicsPoc));    // Store POC values of LTRP
2767  ::memset(longtermPicsLSB, 0, sizeof(longtermPicsLSB));    // Store POC LSB values of LTRP
2768  ::memset(longtermPicsMSB, 0, sizeof(longtermPicsMSB));    // Store POC LSB values of LTRP
2769  ::memset(indices        , 0, sizeof(indices));            // Indices to aid in tracking sorted LTRPs
2770  ::memset(mSBPresentFlag , 0, sizeof(mSBPresentFlag));     // Indicate if MSB needs to be present
2771
2772  // Get the long-term reference pictures
2773  Int offset = rps->getNumberOfNegativePictures() + rps->getNumberOfPositivePictures();
2774  Int i, ctr = 0;
2775  Int maxPicOrderCntLSB = 1 << pcSlice->getSPS()->getBitsForPOC();
2776  for(i = rps->getNumberOfPictures() - 1; i >= offset; i--, ctr++)
2777  {
2778    longtermPicsPoc[ctr] = rps->getPOC(i);                                  // LTRP POC
2779    longtermPicsLSB[ctr] = getLSB(longtermPicsPoc[ctr], maxPicOrderCntLSB); // LTRP POC LSB
2780    indices[ctr]      = i;
2781    longtermPicsMSB[ctr] = longtermPicsPoc[ctr] - longtermPicsLSB[ctr];
2782  }
2783  Int numLongPics = rps->getNumberOfLongtermPictures();
2784  assert(ctr == numLongPics);
2785
2786  // Arrange pictures in decreasing order of MSB;
2787  for(i = 0; i < numLongPics; i++)
2788  {
2789    for(Int j = 0; j < numLongPics - 1; j++)
2790    {
2791      if(longtermPicsMSB[j] < longtermPicsMSB[j+1])
2792      {
2793        std::swap(longtermPicsPoc[j], longtermPicsPoc[j+1]);
2794        std::swap(longtermPicsLSB[j], longtermPicsLSB[j+1]);
2795        std::swap(longtermPicsMSB[j], longtermPicsMSB[j+1]);
2796        std::swap(indices[j]        , indices[j+1]        );
2797      }
2798    }
2799  }
2800
2801  for(i = 0; i < numLongPics; i++)
2802  {
2803    // Check if MSB present flag should be enabled.
2804    // Check if the buffer contains any pictures that have the same LSB.
2805    TComList<TComPic*>::iterator  iterPic = rcListPic.begin();
2806    TComPic*                      pcPic;
2807    while ( iterPic != rcListPic.end() )
2808    {
2809      pcPic = *iterPic;
2810      if( (getLSB(pcPic->getPOC(), maxPicOrderCntLSB) == longtermPicsLSB[i])   &&     // Same LSB
2811                                      (pcPic->getSlice(0)->isReferenced())     &&    // Reference picture
2812                                        (pcPic->getPOC() != longtermPicsPoc[i])    )  // Not the LTRP itself
2813      {
2814        mSBPresentFlag[i] = true;
2815        break;
2816      }
2817      iterPic++;
2818    }
2819  }
2820
2821  // tempArray for usedByCurr flag
2822  Bool tempArray[MAX_NUM_REF_PICS]; ::memset(tempArray, 0, sizeof(tempArray));
2823  for(i = 0; i < numLongPics; i++)
2824  {
2825    tempArray[i] = rps->getUsed(indices[i]);
2826  }
2827  // Now write the final values;
2828  ctr = 0;
2829  Int currMSB = 0, currLSB = 0;
2830  // currPicPoc = currMSB + currLSB
2831  currLSB = getLSB(pcSlice->getPOC(), maxPicOrderCntLSB);
2832  currMSB = pcSlice->getPOC() - currLSB;
2833
2834  for(i = rps->getNumberOfPictures() - 1; i >= offset; i--, ctr++)
2835  {
2836    rps->setPOC                   (i, longtermPicsPoc[ctr]);
2837    rps->setDeltaPOC              (i, - pcSlice->getPOC() + longtermPicsPoc[ctr]);
2838    rps->setUsed                  (i, tempArray[ctr]);
2839    rps->setPocLSBLT              (i, longtermPicsLSB[ctr]);
2840    rps->setDeltaPocMSBCycleLT    (i, (currMSB - (longtermPicsPoc[ctr] - longtermPicsLSB[ctr])) / maxPicOrderCntLSB);
2841    rps->setDeltaPocMSBPresentFlag(i, mSBPresentFlag[ctr]);
2842
2843    assert(rps->getDeltaPocMSBCycleLT(i) >= 0);   // Non-negative value
2844  }
2845  for(i = rps->getNumberOfPictures() - 1, ctr = 1; i >= offset; i--, ctr++)
2846  {
2847    for(Int j = rps->getNumberOfPictures() - 1 - ctr; j >= offset; j--)
2848    {
2849      // Here at the encoder we know that we have set the full POC value for the LTRPs, hence we
2850      // don't have to check the MSB present flag values for this constraint.
2851      assert( rps->getPOC(i) != rps->getPOC(j) ); // If assert fails, LTRP entry repeated in RPS!!!
2852    }
2853  }
2854}
2855
2856Void TEncGOP::applyDeblockingFilterMetric( TComPic* pcPic, UInt uiNumSlices )
2857{
2858  TComPicYuv* pcPicYuvRec = pcPic->getPicYuvRec();
2859  Pel* Rec    = pcPicYuvRec->getAddr(COMPONENT_Y);
2860  Pel* tempRec = Rec;
2861  Int  stride = pcPicYuvRec->getStride(COMPONENT_Y);
2862  UInt log2maxTB = pcPic->getSlice(0)->getSPS()->getQuadtreeTULog2MaxSize();
2863  UInt maxTBsize = (1<<log2maxTB);
2864  const UInt minBlockArtSize = 8;
2865  const UInt picWidth = pcPicYuvRec->getWidth(COMPONENT_Y);
2866  const UInt picHeight = pcPicYuvRec->getHeight(COMPONENT_Y);
2867  const UInt noCol = (picWidth>>log2maxTB);
2868  const UInt noRows = (picHeight>>log2maxTB);
2869  assert(noCol > 1);
2870  assert(noRows > 1);
2871  UInt64 *colSAD = (UInt64*)malloc(noCol*sizeof(UInt64));
2872  UInt64 *rowSAD = (UInt64*)malloc(noRows*sizeof(UInt64));
2873  UInt colIdx = 0;
2874  UInt rowIdx = 0;
2875  Pel p0, p1, p2, q0, q1, q2;
2876
2877  Int qp = pcPic->getSlice(0)->getSliceQp();
2878  const Int bitDepthLuma=pcPic->getSlice(0)->getSPS()->getBitDepth(CHANNEL_TYPE_LUMA);
2879  Int bitdepthScale = 1 << (bitDepthLuma-8);
2880  Int beta = TComLoopFilter::getBeta( qp ) * bitdepthScale;
2881  const Int thr2 = (beta>>2);
2882  const Int thr1 = 2*bitdepthScale;
2883  UInt a = 0;
2884
2885  memset(colSAD, 0, noCol*sizeof(UInt64));
2886  memset(rowSAD, 0, noRows*sizeof(UInt64));
2887
2888  if (maxTBsize > minBlockArtSize)
2889  {
2890    // Analyze vertical artifact edges
2891    for(Int c = maxTBsize; c < picWidth; c += maxTBsize)
2892    {
2893      for(Int r = 0; r < picHeight; r++)
2894      {
2895        p2 = Rec[c-3];
2896        p1 = Rec[c-2];
2897        p0 = Rec[c-1];
2898        q0 = Rec[c];
2899        q1 = Rec[c+1];
2900        q2 = Rec[c+2];
2901        a = ((abs(p2-(p1<<1)+p0)+abs(q0-(q1<<1)+q2))<<1);
2902        if ( thr1 < a && a < thr2)
2903        {
2904          colSAD[colIdx] += abs(p0 - q0);
2905        }
2906        Rec += stride;
2907      }
2908      colIdx++;
2909      Rec = tempRec;
2910    }
2911
2912    // Analyze horizontal artifact edges
2913    for(Int r = maxTBsize; r < picHeight; r += maxTBsize)
2914    {
2915      for(Int c = 0; c < picWidth; c++)
2916      {
2917        p2 = Rec[c + (r-3)*stride];
2918        p1 = Rec[c + (r-2)*stride];
2919        p0 = Rec[c + (r-1)*stride];
2920        q0 = Rec[c + r*stride];
2921        q1 = Rec[c + (r+1)*stride];
2922        q2 = Rec[c + (r+2)*stride];
2923        a = ((abs(p2-(p1<<1)+p0)+abs(q0-(q1<<1)+q2))<<1);
2924        if (thr1 < a && a < thr2)
2925        {
2926          rowSAD[rowIdx] += abs(p0 - q0);
2927        }
2928      }
2929      rowIdx++;
2930    }
2931  }
2932
2933  UInt64 colSADsum = 0;
2934  UInt64 rowSADsum = 0;
2935  for(Int c = 0; c < noCol-1; c++)
2936  {
2937    colSADsum += colSAD[c];
2938  }
2939  for(Int r = 0; r < noRows-1; r++)
2940  {
2941    rowSADsum += rowSAD[r];
2942  }
2943
2944  colSADsum <<= 10;
2945  rowSADsum <<= 10;
2946  colSADsum /= (noCol-1);
2947  colSADsum /= picHeight;
2948  rowSADsum /= (noRows-1);
2949  rowSADsum /= picWidth;
2950
2951  UInt64 avgSAD = ((colSADsum + rowSADsum)>>1);
2952  avgSAD >>= (bitDepthLuma-8);
2953
2954  if ( avgSAD > 2048 )
2955  {
2956    avgSAD >>= 9;
2957    Int offset = Clip3(2,6,(Int)avgSAD);
2958    for (Int i=0; i<uiNumSlices; i++)
2959    {
2960      pcPic->getSlice(i)->setDeblockingFilterOverrideFlag(true);
2961      pcPic->getSlice(i)->setDeblockingFilterDisable(false);
2962      pcPic->getSlice(i)->setDeblockingFilterBetaOffsetDiv2( offset );
2963      pcPic->getSlice(i)->setDeblockingFilterTcOffsetDiv2( offset );
2964    }
2965  }
2966  else
2967  {
2968    for (Int i=0; i<uiNumSlices; i++)
2969    {
2970      pcPic->getSlice(i)->setDeblockingFilterOverrideFlag(false);
2971      pcPic->getSlice(i)->setDeblockingFilterDisable(        pcPic->getSlice(i)->getPPS()->getPicDisableDeblockingFilterFlag() );
2972      pcPic->getSlice(i)->setDeblockingFilterBetaOffsetDiv2( pcPic->getSlice(i)->getPPS()->getDeblockingFilterBetaOffsetDiv2() );
2973      pcPic->getSlice(i)->setDeblockingFilterTcOffsetDiv2(   pcPic->getSlice(i)->getPPS()->getDeblockingFilterTcOffsetDiv2()   );
2974    }
2975  }
2976
2977  free(colSAD);
2978  free(rowSAD);
2979}
2980
2981#if NH_MV
2982Void TEncGOP::xSetRefPicListModificationsMv( std::vector<TComPic*> tempPicLists[2], TComSlice* pcSlice, UInt iGOPid )
2983{ 
2984 
2985  if( pcSlice->getSliceType() == I_SLICE || !(pcSlice->getPPS()->getListsModificationPresentFlag()) || pcSlice->getNumActiveRefLayerPics() == 0 )
2986  {
2987    return;
2988  }
2989 
2990  GOPEntry ge = m_pcCfg->getGOPEntry( (pcSlice->getRapPicFlag() && ( pcSlice->getLayerId( ) > 0) ) ? MAX_GOP : iGOPid );
2991  assert( ge.m_numActiveRefLayerPics == pcSlice->getNumActiveRefLayerPics() ); 
2992
2993  Int numPicsInTempList     = pcSlice->getNumRpsCurrTempList(); 
2994
2995  // GT: check if SliceType should be checked here.
2996  for (Int li = 0; li < 2; li ++) // Loop over lists L0 and L1
2997  {
2998    Int numPicsInFinalRefList = pcSlice->getNumRefIdx( ( li == 0 ) ? REF_PIC_LIST_0 : REF_PIC_LIST_1 ); 
2999           
3000    Int finalIdxToTempIdxMap[16];
3001    for( Int k = 0; k < 16; k++ )
3002    {
3003      finalIdxToTempIdxMap[ k ] = -1;
3004    }
3005
3006    Bool isModified = false;
3007    if ( numPicsInTempList > 1 )
3008    {
3009      for( Int k = 0; k < pcSlice->getNumActiveRefLayerPics(); k++ )
3010      {
3011        // get position in temp. list
3012        Int refPicLayerId = pcSlice->getRefPicLayerId(k);
3013        Int idxInTempList = 0; 
3014        for (; idxInTempList < numPicsInTempList; idxInTempList++)
3015        {
3016          if ( (tempPicLists[li][idxInTempList])->getLayerId() == refPicLayerId )
3017          {
3018            break; 
3019          }
3020        }
3021
3022        Int idxInFinalList = ge.m_interViewRefPosL[ li ][ k ];
3023       
3024        // Add negative from behind
3025        idxInFinalList = ( idxInFinalList < 0 )? ( numPicsInTempList + idxInFinalList ) : idxInFinalList; 
3026       
3027        Bool curIsModified = ( idxInFinalList != idxInTempList ) && ( ( idxInTempList < numPicsInFinalRefList ) || ( idxInFinalList < numPicsInFinalRefList ) ) ;
3028        if ( curIsModified )
3029        {
3030          isModified = true; 
3031          assert( finalIdxToTempIdxMap[ idxInFinalList ] == -1 ); // Assert when two inter layer reference pictures are sorted to the same position
3032        }
3033        finalIdxToTempIdxMap[ idxInFinalList ] = idxInTempList;             
3034      }
3035    }
3036
3037    TComRefPicListModification* refPicListModification = pcSlice->getRefPicListModification();
3038    refPicListModification->setRefPicListModificationFlagL( li, isModified ); 
3039
3040    if( isModified )
3041    {
3042      Int refIdx = 0;
3043     
3044      for( Int i = 0; i < numPicsInFinalRefList; i++ )
3045      {
3046        if( finalIdxToTempIdxMap[i] >= 0 ) 
3047        {
3048          refPicListModification->setRefPicSetIdxL( li, i, finalIdxToTempIdxMap[i] );
3049        }
3050        else
3051        {
3052          ///* Fill gaps with temporal references *///
3053          // Forward inter layer reference pictures
3054          while( ( refIdx < numPicsInTempList ) && ( tempPicLists[li][refIdx]->getLayerId() != getLayerId())  )
3055          {
3056            refIdx++; 
3057          }
3058          refPicListModification->setRefPicSetIdxL( li, i, refIdx );
3059          refIdx++;
3060        }
3061      }
3062    }
3063  }
3064}
3065#endif
3066//! \}
Note: See TracBrowser for help on using the repository browser.