Changeset 1273 in SHVCSoftware

Timestamp:

15 Jul 2015, 20:51:59 (9 years ago)

Author:

seregin

Message:

port rev 4306 and rev 4307

Location:

branches/SHM-dev/source

Files:

• App/TAppDecoder/TAppDecCfg.cpp (modified) (1 diff)
• App/TAppDecoder/TAppDecTop.cpp (modified) (1 diff)
• App/TAppEncoder/TAppEncCfg.cpp (modified) (2 diffs)
• App/TAppEncoder/TAppEncTop.cpp (modified) (1 diff)
• Lib/TLibCommon/SEI.cpp (modified) (3 diffs)
• Lib/TLibCommon/SEI.h (modified) (6 diffs)
• Lib/TLibCommon/TComPicYuv.h (modified) (1 diff)
• Lib/TLibCommon/TComPicYuvMD5.cpp (modified) (6 diffs)
• Lib/TLibCommon/TComSlice.cpp (modified) (3 diffs)
• Lib/TLibCommon/TComSlice.h (modified) (9 diffs)
• Lib/TLibCommon/TypeDef.h (modified) (2 diffs)
• Lib/TLibDecoder/SEIread.cpp (modified) (3 diffs)
• Lib/TLibDecoder/TDecGop.cpp (modified) (3 diffs)
• Lib/TLibEncoder/SEIEncoder.cpp (added)
• Lib/TLibEncoder/SEIEncoder.h (added)
• Lib/TLibEncoder/SEIwrite.cpp (modified) (4 diffs)
• Lib/TLibEncoder/SEIwrite.h (modified) (2 diffs)
• Lib/TLibEncoder/TEncCfg.h (modified) (1 diff)
• Lib/TLibEncoder/TEncGOP.cpp (modified) (27 diffs)
• Lib/TLibEncoder/TEncGOP.h (modified) (7 diffs)
• Lib/TLibEncoder/TEncTop.cpp (modified) (2 diffs)

branches/SHM-dev/source/App/TAppDecoder/TAppDecCfg.cpp

@@ -116 +116 @@
                                                                                    "\t1: check hash in SEI messages if available in the bitstream\n"
                                                                                    "\t0: ignore SEI message")
-  ("SEIpictureDigest",          m_decodedPictureHashSEIEnabled,        1,          "deprecated alias for SEIDecodedPictureHash")
   ("SEINoDisplay",              m_decodedNoDisplaySEIEnabled,          true,       "Control handling of decoded no display SEI messages")
   ("TarDecLayerIdSetFile,l",    cfg_TargetDecLayerIdSetFile,           string(""), "targetDecLayerIdSet file name. The file should include white space separated LayerId values to be decoded. Omitting the option or a value of -1 in the file decodes all layers.")

branches/SHM-dev/source/App/TAppDecoder/TAppDecTop.cpp

@@ -1544 +1544 @@
         this->setMetadataFileRefresh(false);
 
-        TComDigest recon_digest;
+        TComPictureHash recon_digest;
         Int numChar = calcMD5(*pic->getPicYuvRec(), recon_digest);
-        fprintf(fptr, "%8d%9d    MD5:%s\n", pic->getLayerId(), pic->getSlice(0)->getPOC(), digestToString(recon_digest, numChar).c_str());
+        fprintf(fptr, "%8d%9d    MD5:%s\n", pic->getLayerId(), pic->getSlice(0)->getPOC(), hashToString(recon_digest, numChar).c_str());
         fclose(fptr);
       }

branches/SHM-dev/source/App/TAppEncoder/TAppEncCfg.cpp

@@ -1401 +1401 @@
                                                                                                                "\t1: use MD5\n"
                                                                                                                "\t0: disable")
-  ("SEIpictureDigest",                                m_decodedPictureHashSEIEnabled,                       0, "deprecated alias for SEIDecodedPictureHash")
   ("TMVPMode",                                        m_TMVPModeId,                                         1, "TMVP mode 0: TMVP disable for all slices. 1: TMVP enable for all slices (default) 2: TMVP enable for certain slices only")
   ("FEN",                                             m_bUseFastEnc,                                    false, "fast encoder setting")
@@ -4135 +4134 @@
   if((m_numTileColumnsMinus1 <= 0) && (m_numTileRowsMinus1 <= 0) && m_tmctsSEIEnabled)
   {
-    printf("SEITempMotionConstrainedTileSets is set to false to disable 'temporal_motion_constrained_tile_sets' SEI because there are no tiles enabled\n");
+    printf("Warning: SEITempMotionConstrainedTileSets is set to false to disable temporal motion-constrained tile sets SEI message because there are no tiles enabled.\n");
     m_tmctsSEIEnabled = false;
   }

branches/SHM-dev/source/App/TAppEncoder/TAppEncTop.cpp

@@ -1604 +1604 @@
         numDU ++;
       }
-      vps->getBspHrd(i)->setNumDU( numDU );
+      //vps->getBspHrd(i)->setNumDU( numDU );
       vps->setBspHrdParameters( i, pcCfgLayer->getFrameRate(), numDU, pcCfgLayer->getTargetBitrate(), ( pcCfgLayer->getIntraPeriod() > 0 ) );
     }

branches/SHM-dev/source/Lib/TLibCommon/SEI.cpp

@@ -42 +42 @@
 Int  Table_exp_indicator[32] = {0, 10, 12, 16, 20, 25, 32, 40, 50, 64, 80, 100, 125, 160, 200, 250, 320, 400, 500, 640, 800, 1000, 1250, 1600, 2000, 2500, 3200, 4000, 5000, 6400, 8000, -1};
 
-#if SUB_BITSTREAM_PROPERTY_SEI
-SEISubBitstreamProperty::SEISubBitstreamProperty()
-{
-  m_activeVpsId             = -1;
-  m_numAdditionalSubStreams = 0;
-  ::memset(m_subBitstreamMode       , 0, sizeof(m_subBitstreamMode));
-  ::memset(m_outputLayerSetIdxToVps , 0, sizeof(m_outputLayerSetIdxToVps));
-  ::memset(m_highestSublayerId      , 0, sizeof(m_highestSublayerId));
-  ::memset(m_avgBitRate             , 0, sizeof(m_avgBitRate));
-  ::memset(m_maxBitRate             , 0, sizeof(m_maxBitRate));
-}
-#endif
-
 SEIMessages getSeisByType(SEIMessages &seiList, SEI::PayloadType seiType)
 {
@@ -99 +86 @@
 }
 
+void SEIBufferingPeriod::copyTo (SEIBufferingPeriod& target)
+{
+  target.m_bpSeqParameterSetId = m_bpSeqParameterSetId;
+  target.m_rapCpbParamsPresentFlag = m_rapCpbParamsPresentFlag;
+  target.m_cpbDelayOffset = m_cpbDelayOffset;
+  target.m_dpbDelayOffset = m_dpbDelayOffset;
+  target.m_concatenationFlag = m_concatenationFlag;
+  target.m_auCpbRemovalDelayDelta = m_auCpbRemovalDelayDelta;
+  ::memcpy(target.m_initialCpbRemovalDelay, m_initialCpbRemovalDelay, sizeof(m_initialCpbRemovalDelay));
+  ::memcpy(target.m_initialCpbRemovalDelayOffset, m_initialCpbRemovalDelayOffset, sizeof(m_initialCpbRemovalDelayOffset));
+  ::memcpy(target.m_initialAltCpbRemovalDelay, m_initialAltCpbRemovalDelay, sizeof(m_initialAltCpbRemovalDelay));
+  ::memcpy(target.m_initialAltCpbRemovalDelayOffset, m_initialAltCpbRemovalDelayOffset, sizeof(m_initialAltCpbRemovalDelayOffset));
+}
+
+void SEIPictureTiming::copyTo (SEIPictureTiming& target)
+{
+  target.m_picStruct = m_picStruct;
+  target.m_sourceScanType = m_sourceScanType;
+  target.m_duplicateFlag = m_duplicateFlag;
+
+  target.m_auCpbRemovalDelay = m_auCpbRemovalDelay;
+  target.m_picDpbOutputDelay = m_picDpbOutputDelay;
+  target.m_picDpbOutputDuDelay = m_picDpbOutputDuDelay;
+  target.m_numDecodingUnitsMinus1 = m_numDecodingUnitsMinus1;
+  target.m_duCommonCpbRemovalDelayFlag = m_duCommonCpbRemovalDelayFlag;
+  target.m_duCommonCpbRemovalDelayMinus1 = m_duCommonCpbRemovalDelayMinus1;
+
+  target.m_numNalusInDuMinus1 = m_numNalusInDuMinus1;
+  target.m_duCpbRemovalDelayMinus1 = m_duCpbRemovalDelayMinus1;
+}
 
 // Static member
@@ -169 +186 @@
 }
 
+
+#if SUB_BITSTREAM_PROPERTY_SEI
+SEISubBitstreamProperty::SEISubBitstreamProperty()
+{
+  m_activeVpsId             = -1;
+  m_numAdditionalSubStreams = 0;
+  ::memset(m_subBitstreamMode       , 0, sizeof(m_subBitstreamMode));
+  ::memset(m_outputLayerSetIdxToVps , 0, sizeof(m_outputLayerSetIdxToVps));
+  ::memset(m_highestSublayerId      , 0, sizeof(m_highestSublayerId));
+  ::memset(m_avgBitRate             , 0, sizeof(m_avgBitRate));
+  ::memset(m_maxBitRate             , 0, sizeof(m_maxBitRate));
+}
+#endif
+
 #if Q0074_COLOUR_REMAPPING_SEI
 Void  SEIColourRemappingInfo::copyFrom( SEIColourRemappingInfo const * SeiCriInput)

branches/SHM-dev/source/Lib/TLibCommon/SEI.h

@@ -166 +166 @@
   } method;
 
-  TComDigest m_digest;
+  TComPictureHash m_pictureHash;
 };
 
@@ -196 +196 @@
 public:
   PayloadType payloadType() const { return BUFFERING_PERIOD; }
+  void copyTo (SEIBufferingPeriod& target);
 
   SEIBufferingPeriod()
@@ -233 +234 @@
 public:
   PayloadType payloadType() const { return PICTURE_TIMING; }
+  void copyTo (SEIPictureTiming& target);
 
   SEIPictureTiming()
@@ -239 +241 @@
   , m_duplicateFlag           (false)
   , m_picDpbOutputDuDelay     (0)
-  , m_numNalusInDuMinus1      (NULL)
-  , m_duCpbRemovalDelayMinus1 (NULL)
   {}
   virtual ~SEIPictureTiming()
   {
-    if( m_numNalusInDuMinus1 != NULL )
-    {
-      delete m_numNalusInDuMinus1;
-    }
-    if( m_duCpbRemovalDelayMinus1  != NULL )
-    {
-      delete m_duCpbRemovalDelayMinus1;
-    }
   }
 
@@ -264 +256 @@
   Bool  m_duCommonCpbRemovalDelayFlag;
   UInt  m_duCommonCpbRemovalDelayMinus1;
-  UInt* m_numNalusInDuMinus1;
-  UInt* m_duCpbRemovalDelayMinus1;
+  std::vector<UInt> m_numNalusInDuMinus1;
+  std::vector<UInt> m_duCpbRemovalDelayMinus1;
 };
 
@@ -714 +706 @@
 
 #if Q0074_COLOUR_REMAPPING_SEI
+struct TComSEIColourRemappingInfo
+{
+  std::string             m_colourRemapSEIFile;
+  Int                     m_colourRemapSEIId;
+  Bool                    m_colourRemapSEICancelFlag;
+  Bool                    m_colourRemapSEIPersistenceFlag;
+  Bool                    m_colourRemapSEIVideoSignalInfoPresentFlag;
+  Bool                    m_colourRemapSEIFullRangeFlag;
+  Int                     m_colourRemapSEIPrimaries;
+  Int                     m_colourRemapSEITransferFunction;
+  Int                     m_colourRemapSEIMatrixCoefficients;
+  Int                     m_colourRemapSEIInputBitDepth;
+  Int                     m_colourRemapSEIBitDepth;
+  Int                     m_colourRemapSEIPreLutNumValMinus1[3];
+  Int*                    m_colourRemapSEIPreLutCodedValue[3];
+  Int*                    m_colourRemapSEIPreLutTargetValue[3];
+  Bool                    m_colourRemapSEIMatrixPresentFlag;
+  Int                     m_colourRemapSEILog2MatrixDenom;
+  Int                     m_colourRemapSEICoeffs[3][3];
+  Int                     m_colourRemapSEIPostLutNumValMinus1[3];
+  Int*                    m_colourRemapSEIPostLutCodedValue[3];
+  Int*                    m_colourRemapSEIPostLutTargetValue[3];
+};
+
 class SEIColourRemappingInfo : public SEI
 {

branches/SHM-dev/source/Lib/TLibCommon/TComPicYuv.h

@@ -182 +182 @@
 
 // These functions now return the length of the digest strings.
-UInt calcChecksum(const TComPicYuv& pic, TComDigest &digest);
-UInt calcCRC     (const TComPicYuv& pic, TComDigest &digest);
-UInt calcMD5     (const TComPicYuv& pic, TComDigest &digest);
-std::string digestToString(const TComDigest &digest, Int numChar);
+UInt calcChecksum(const TComPicYuv& pic, TComPictureHash &digest);
+UInt calcCRC     (const TComPicYuv& pic, TComPictureHash &digest);
+UInt calcMD5     (const TComPicYuv& pic, TComPictureHash &digest);
+std::string hashToString(const TComPictureHash &digest, Int numChar);
 //! \}
 

branches/SHM-dev/source/Lib/TLibCommon/TComPicYuvMD5.cpp

@@ -87 +87 @@
 
 
-UInt compCRC(Int bitdepth, const Pel* plane, UInt width, UInt height, UInt stride, TComDigest &digest)
+UInt compCRC(Int bitdepth, const Pel* plane, UInt width, UInt height, UInt stride, TComPictureHash &digest)
 {
   UInt crcMsb;
@@ -127 +127 @@
 }
 
-UInt calcCRC(const TComPicYuv& pic, TComDigest &digest)
+UInt calcCRC(const TComPicYuv& pic, TComPictureHash &digest)
 {
   UInt digestLen=0;
@@ -139 +139 @@
 }
 
-UInt compChecksum(Int bitdepth, const Pel* plane, UInt width, UInt height, UInt stride, TComDigest &digest)
+UInt compChecksum(Int bitdepth, const Pel* plane, UInt width, UInt height, UInt stride, TComPictureHash &digest)
 {
   UInt checksum = 0;
@@ -165 +165 @@
 }
 
-UInt calcChecksum(const TComPicYuv& pic, TComDigest &digest)
+UInt calcChecksum(const TComPicYuv& pic, TComPictureHash &digest)
 {
   UInt digestLen=0;
@@ -183 +183 @@
  * uses little-endian two byte words; 8bit data uses single byte words.
  */
-UInt calcMD5(const TComPicYuv& pic, TComDigest &digest)
+UInt calcMD5(const TComPicYuv& pic, TComPictureHash &digest)
 {
   /* choose an md5_plane packing function based on the system bitdepth */
@@ -207 +207 @@
 }
 
-std::string digestToString(const TComDigest &digest, Int numChar)
+std::string hashToString(const TComPictureHash &digest, Int numChar)
 {
   static const Char* hex = "0123456789abcdef";

branches/SHM-dev/source/Lib/TLibCommon/TComSlice.cpp

@@ -2130 +2130 @@
 }
 
-Void TComSPS::setHrdParameters( UInt frameRate, UInt numDU, UInt bitRate, Bool randomAccess )
+Void TComSPS::setHrdParameters( UInt frameRate, Bool useSubCpbParams, UInt bitRate, Bool randomAccess )
 {
   if( !getVuiParametersPresentFlag() )
@@ -2176 +2176 @@
   hrd->setVclHrdParametersPresentFlag( rateCnt );
 
-  hrd->setSubPicCpbParamsPresentFlag( ( numDU > 1 ) );
+  hrd->setSubPicCpbParamsPresentFlag( useSubCpbParams );
 
   if( hrd->getSubPicCpbParamsPresentFlag() )
@@ -2223 +2223 @@
     bitrateValue = bitRate;
     cpbSizeValue = bitRate;                                     // 1 second
-    duCpbSizeValue = bitRate/numDU;
+    // DU CPB size could be smaller, but we don't know how 
+    // in how many DUs the slice segment settings will result 
+    // (used to be: bitRate/numDU)
+    duCpbSizeValue = bitRate;
     duBitRateValue = bitRate;
 

branches/SHM-dev/source/Lib/TLibCommon/TComSlice.h

@@ -310 +310 @@
   UInt m_cpbRemovalDelayLengthMinus1;
   UInt m_dpbOutputDelayLengthMinus1;
-  UInt m_numDU;
   HrdSubLayerInfo m_HRD[MAX_TLAYER];
 
@@ -396 +395 @@
   Bool    getCbrFlag( Int layer, Int cpbcnt, Int nalOrVcl ) const                    { return m_HRD[layer].cbrFlag[cpbcnt][nalOrVcl];             }
 
-  Void    setNumDU( UInt value )                                                     { m_numDU = value;                                           }
-  UInt    getNumDU( ) const                                                          { return m_numDU;                                            }
   Bool    getCpbDpbDelaysPresentFlag( ) const                      { return getNalHrdParametersPresentFlag() || getVclHrdParametersPresentFlag(); }
 
@@ -1205 +1202 @@
     , m_log2MaxMvLengthHorizontal         (15)
     , m_log2MaxMvLengthVertical           (15)
- {}
+  {}
 
   virtual           ~TComVUI() {}
@@ -1525 +1522 @@
   Bool                   getScalingListPresentFlag() const                                               { return m_scalingListPresentFlag;                                     }
   Void                   setScalingListPresentFlag( Bool b )                                             { m_scalingListPresentFlag  = b;                                       }
-
   Void                   setScalingList( TComScalingList *scalingList);
   TComScalingList&       getScalingList()                                                                { return m_scalingList;                                                }
@@ -1541 +1537 @@
   TComVUI*               getVuiParameters()                                                              { return &m_vuiParameters;                                             }
   const TComVUI*         getVuiParameters() const                                                        { return &m_vuiParameters;                                             }
-  Void                   setHrdParameters( UInt frameRate, UInt numDU, UInt bitRate, Bool randomAccess );
-
+  Void                   setHrdParameters( UInt frameRate, Bool useSubCpbParams, UInt bitRate, Bool randomAccess );
   const TComPTL*         getPTL() const                                                                  { return &m_pcPTL;                                                     }
   TComPTL*               getPTL()                                                                        { return &m_pcPTL;                                                     }
@@ -1571 +1566 @@
 };
 
+
 /// Reference Picture Lists class
 
@@ -1597 +1593 @@
   Void    setRefPicSetIdxL1(UInt idx, UInt refPicSetIdx) { assert(idx<REF_PIC_LIST_NUM_IDX); m_RefPicSetIdxL1[idx] = refPicSetIdx; }
 };
-
 
 /// PPS class
@@ -1803 +1798 @@
   Bool                   getScalingListPresentFlag() const                                { return m_scalingListPresentFlag;              }
   Void                   setScalingListPresentFlag( Bool b )                              { m_scalingListPresentFlag  = b;                }
-
   TComScalingList&       getScalingList()                                                 { return m_scalingList;                         }
   const TComScalingList& getScalingList() const                                           { return m_scalingList;                         }
@@ -2399 +2393 @@
 };// END CLASS DEFINITION TComSlice
 
+
 Void calculateParameterSetChangedFlag(Bool &bChanged, const std::vector<UChar> *pOldData, const std::vector<UChar> *pNewData);
 

branches/SHM-dev/source/Lib/TLibCommon/TypeDef.h

@@ -864 +864 @@
 
 
-struct TComDigest
+struct TComPictureHash
 {
   std::vector<UChar> hash;
 
-  Bool operator==(const TComDigest &other) const
+  Bool operator==(const TComPictureHash &other) const
   {
     if (other.hash.size() != hash.size())
@@ -884 +884 @@
   }
 
-  Bool operator!=(const TComDigest &other) const
+  Bool operator!=(const TComPictureHash &other) const
   {
     return !(*this == other);

branches/SHM-dev/source/Lib/TLibDecoder/SEIread.cpp

@@ -341 +341 @@
 #endif
 #if SUB_BITSTREAM_PROPERTY_SEI
-   case SEI::SUB_BITSTREAM_PROPERTY:
-     sei = new SEISubBitstreamProperty;
-     xParseSEISubBitstreamProperty((SEISubBitstreamProperty&) *sei, vps, pDecodedMessageOutputStream);
-     break;
+    case SEI::SUB_BITSTREAM_PROPERTY:
+      sei = new SEISubBitstreamProperty;
+      xParseSEISubBitstreamProperty((SEISubBitstreamProperty&) *sei, vps, pDecodedMessageOutputStream);
+      break;
 #endif
 #if O0164_MULTI_LAYER_HRD
-   case SEI::BSP_NESTING:
-     sei = new SEIBspNesting;
+    case SEI::BSP_NESTING:
+      sei = new SEIBspNesting;
 #if LAYERS_NOT_PRESENT_SEI
-     xParseSEIBspNesting((SEIBspNesting&) *sei, nalUnitType, vps, sps, *nestingSei, pDecodedMessageOutputStream);
-#else
-     xParseSEIBspNesting((SEIBspNesting&) *sei, nalUnitType, sps, *nestingSei, pDecodedMessageOutputStream);
-#endif
-     break;
-   case SEI::BSP_INITIAL_ARRIVAL_TIME:
-     sei = new SEIBspInitialArrivalTime;
-     xParseSEIBspInitialArrivalTime((SEIBspInitialArrivalTime&) *sei, vps, sps, *nestingSei, *bspNestingSei, pDecodedMessageOutputStream);
-     break;
+      xParseSEIBspNesting((SEIBspNesting&) *sei, nalUnitType, vps, sps, *nestingSei, pDecodedMessageOutputStream);
+#else
+      xParseSEIBspNesting((SEIBspNesting&) *sei, nalUnitType, sps, *nestingSei, pDecodedMessageOutputStream);
+#endif
+      break;
+    case SEI::BSP_INITIAL_ARRIVAL_TIME:
+      sei = new SEIBspInitialArrivalTime;
+      xParseSEIBspInitialArrivalTime((SEIBspInitialArrivalTime&) *sei, vps, sps, *nestingSei, *bspNestingSei, pDecodedMessageOutputStream);
+      break;
 #endif
 #if Q0189_TMVP_CONSTRAINTS
-   case SEI::TMVP_CONSTRAINTS:
-     sei =  new SEITMVPConstrains;
-     xParseSEITMVPConstraints((SEITMVPConstrains&) *sei, payloadSize, pDecodedMessageOutputStream);
-     break;
+    case SEI::TMVP_CONSTRAINTS:
+      sei =  new SEITMVPConstrains;
+      xParseSEITMVPConstraints((SEITMVPConstrains&) *sei, payloadSize, pDecodedMessageOutputStream);
+      break;
 #endif
 #if Q0247_FRAME_FIELD_INFO
-   case SEI::FRAME_FIELD_INFO:
-     sei =  new SEIFrameFieldInfo;
-     xParseSEIFrameFieldInfo    ((SEIFrameFieldInfo&) *sei, payloadSize, pDecodedMessageOutputStream);
-     break;
+    case SEI::FRAME_FIELD_INFO:
+      sei =  new SEIFrameFieldInfo;
+      xParseSEIFrameFieldInfo    ((SEIFrameFieldInfo&) *sei, payloadSize, pDecodedMessageOutputStream);
+      break;
 #endif
 #if P0123_ALPHA_CHANNEL_SEI
-   case SEI::ALPHA_CHANNEL_INFO:
-     sei = new SEIAlphaChannelInfo;
-     xParseSEIAlphaChannelInfo((SEIAlphaChannelInfo &) *sei, payloadSize, pDecodedMessageOutputStream);
-     break;
+    case SEI::ALPHA_CHANNEL_INFO:
+      sei = new SEIAlphaChannelInfo;
+      xParseSEIAlphaChannelInfo((SEIAlphaChannelInfo &) *sei, payloadSize, pDecodedMessageOutputStream);
+      break;
 #endif
 #if Q0096_OVERLAY_SEI
-   case SEI::OVERLAY_INFO:
-     sei = new SEIOverlayInfo;
-     xParseSEIOverlayInfo((SEIOverlayInfo&) *sei, payloadSize, pDecodedMessageOutputStream);
-     break;
+    case SEI::OVERLAY_INFO:
+      sei = new SEIOverlayInfo;
+      xParseSEIOverlayInfo((SEIOverlayInfo&) *sei, payloadSize, pDecodedMessageOutputStream);
+      break;
 #endif
 #endif //SVC_EXTENSION
-   default:
-     for (UInt i = 0; i < payloadSize; i++)
-     {
-       UInt seiByte;
-       sei_read_code (NULL, 8, seiByte, "unknown prefix SEI payload byte");
-     }
-     printf ("Unknown prefix SEI message (payloadType = %d) was found!\n", payloadType);
-     if (pDecodedMessageOutputStream)
-     {
-       (*pDecodedMessageOutputStream) << "Unknown prefix SEI message (payloadType = " << payloadType << ") was found!\n";
-     }
-     break;
+    default:
+      for (UInt i = 0; i < payloadSize; i++)
+      {
+        UInt seiByte;
+        sei_read_code (NULL, 8, seiByte, "unknown prefix SEI payload byte");
+      }
+      printf ("Unknown prefix SEI message (payloadType = %d) was found!\n", payloadType);
+      if (pDecodedMessageOutputStream)
+      {
+        (*pDecodedMessageOutputStream) << "Unknown prefix SEI message (payloadType = " << payloadType << ") was found!\n";
+      }
+      break;
     }
   }
@@ -539 +539 @@
   }
 
-  sei.m_digest.hash.clear();
+  sei.m_pictureHash.hash.clear();
   for(;bytesRead < payloadSize; bytesRead++)
   {
     sei_read_code( NULL, 8, val, traceString);
-    sei.m_digest.hash.push_back((UChar)val);
+    sei.m_pictureHash.hash.push_back((UChar)val);
     if (pDecodedMessageOutputStream)
     {
@@ -858 +858 @@
         sei.m_duCommonCpbRemovalDelayMinus1 = code;
       }
-      if( sei.m_numNalusInDuMinus1 != NULL )
-      {
-        delete sei.m_numNalusInDuMinus1;
-      }
-      sei.m_numNalusInDuMinus1 = new UInt[ ( sei.m_numDecodingUnitsMinus1 + 1 ) ];
-      if( sei.m_duCpbRemovalDelayMinus1  != NULL )
-      {
-        delete sei.m_duCpbRemovalDelayMinus1;
-      }
-      sei.m_duCpbRemovalDelayMinus1  = new UInt[ ( sei.m_numDecodingUnitsMinus1 + 1 ) ];
+      sei.m_numNalusInDuMinus1.resize(sei.m_numDecodingUnitsMinus1 + 1 );
+      sei.m_duCpbRemovalDelayMinus1.resize( sei.m_numDecodingUnitsMinus1 + 1 );
 
       for( i = 0; i <= sei.m_numDecodingUnitsMinus1; i ++ )

branches/SHM-dev/source/Lib/TLibDecoder/TDecGop.cpp

@@ -278 +278 @@
 {
   /* calculate MD5sum for entire reconstructed picture */
-  TComDigest recon_digest;
+  TComPictureHash recon_digest;
   Int numChar=0;
   const Char* hashType = "\0";
@@ -319 +319 @@
   {
     ok = "(OK)";
-    if (recon_digest != pictureHashSEI->m_digest)
+    if (recon_digest != pictureHashSEI->m_pictureHash)
     {
       ok = "(***ERROR***)";
@@ -326 +326 @@
   }
 
-  printf("[%s:%s,%s] ", hashType, digestToString(recon_digest, numChar).c_str(), ok);
+  printf("[%s:%s,%s] ", hashType, hashToString(recon_digest, numChar).c_str(), ok);
 
   if (mismatch)
   {
     g_md5_mismatch = true;
-    printf("[rx%s:%s] ", hashType, digestToString(pictureHashSEI->m_digest, numChar).c_str());
-  }
-}
-
+    printf("[rx%s:%s] ", hashType, hashToString(pictureHashSEI->m_pictureHash, numChar).c_str());
+  }
+}
 //! \}

branches/SHM-dev/source/Lib/TLibEncoder/SEIwrite.cpp

@@ -211 +211 @@
 
 /**
- * marshal a single SEI message sei, storing the marshalled representation
- * in bitstream bs.
+ * marshal all SEI messages in provided list into one bitstream bs
  */
 #if O0164_MULTI_LAYER_HRD
-Void SEIWriter::writeSEImessage(TComBitIf& bs, const SEI& sei, const TComVPS *vps, const TComSPS *sps, const SEIScalableNesting* nestingSei, const SEIBspNesting* bspNestingSei)
+Void SEIWriter::writeSEImessages(TComBitIf& bs, const SEIMessages &seiList, const TComVPS *vps, const TComSPS *sps, const SEIScalableNesting* nestingSei, const SEIBspNesting* bspNestingSei)
 #else
-Void SEIWriter::writeSEImessage(TComBitIf& bs, const SEI& sei, const TComSPS *sps)
-#endif
-{
-  /* calculate how large the payload data is */
-  /* TODO: this would be far nicer if it used vectored buffers */
-  TComBitCounter bs_count;
-  bs_count.resetBits();
-  setBitstream(&bs_count);
-
-
-#if ENC_DEC_TRACE
-  Bool traceEnable = g_HLSTraceEnable;
-  g_HLSTraceEnable = false;
-#endif
-#if O0164_MULTI_LAYER_HRD
-  xWriteSEIpayloadData(bs_count, sei, vps, sps, nestingSei, bspNestingSei);
-#else
-  xWriteSEIpayloadData(bs_count, sei, sps);
-#endif
-#if ENC_DEC_TRACE
-  g_HLSTraceEnable = traceEnable;
-#endif
-
-  UInt payload_data_num_bits = bs_count.getNumberOfWrittenBits();
-  assert(0 == payload_data_num_bits % 8);
-
-  setBitstream(&bs);
-
+Void SEIWriter::writeSEImessages(TComBitIf& bs, const SEIMessages &seiList, const TComSPS *sps)
+#endif
+{
 #if ENC_DEC_TRACE
   if (g_HLSTraceEnable)
-  {
     xTraceSEIHeader();
-  }
-#endif
-
-  UInt payloadType = sei.payloadType();
-  for (; payloadType >= 0xff; payloadType -= 0xff)
-  {
-    WRITE_CODE(0xff, 8, "payload_type");
-  }
-  WRITE_CODE(payloadType, 8, "payload_type");
-
-  UInt payloadSize = payload_data_num_bits/8;
-  for (; payloadSize >= 0xff; payloadSize -= 0xff)
-  {
-    WRITE_CODE(0xff, 8, "payload_size");
-  }
-  WRITE_CODE(payloadSize, 8, "payload_size");
-
-  /* payloadData */
+#endif
+
+  TComBitCounter bs_count;
+
+  for (SEIMessages::const_iterator sei=seiList.begin(); sei!=seiList.end(); sei++)
+  {
+    // calculate how large the payload data is
+    // TODO: this would be far nicer if it used vectored buffers
+    bs_count.resetBits();
+    setBitstream(&bs_count);
+
 #if ENC_DEC_TRACE
-  if (g_HLSTraceEnable)
-  {
-    xTraceSEIMessageType(sei.payloadType());
-  }
-#endif
-
+    Bool traceEnable = g_HLSTraceEnable;
+    g_HLSTraceEnable = false;
+#endif
 #if O0164_MULTI_LAYER_HRD
-  xWriteSEIpayloadData(bs, sei, vps, sps, nestingSei, bspNestingSei);
+    xWriteSEIpayloadData(bs_count, **sei, vps, sps, nestingSei, bspNestingSei);
 #else
-  xWriteSEIpayloadData(bs, sei, sps);
-#endif
+    xWriteSEIpayloadData(bs_count, **sei, sps);
+#endif
+#if ENC_DEC_TRACE
+    g_HLSTraceEnable = traceEnable;
+#endif
+    UInt payload_data_num_bits = bs_count.getNumberOfWrittenBits();
+    assert(0 == payload_data_num_bits % 8);
+
+    setBitstream(&bs);
+    UInt payloadType = (*sei)->payloadType();
+    for (; payloadType >= 0xff; payloadType -= 0xff)
+    {
+      WRITE_CODE(0xff, 8, "payload_type");
+    }
+    WRITE_CODE(payloadType, 8, "payload_type");
+
+    UInt payloadSize = payload_data_num_bits/8;
+    for (; payloadSize >= 0xff; payloadSize -= 0xff)
+    {
+      WRITE_CODE(0xff, 8, "payload_size");
+    }
+    WRITE_CODE(payloadSize, 8, "payload_size");
+
+    /* payloadData */
+#if ENC_DEC_TRACE
+    if (g_HLSTraceEnable)
+      xTraceSEIMessageType((*sei)->payloadType());
+#endif
+
+#if O0164_MULTI_LAYER_HRD
+    xWriteSEIpayloadData(bs, **sei, vps, sps, nestingSei, bspNestingSei);
+#else
+    xWriteSEIpayloadData(bs, **sei, sps);
+#endif
+  }
 }
 
@@ -316 +312 @@
   {
     WRITE_CODE(sei.method, 8, "hash_type");
-    for(UInt i=0; i<UInt(sei.m_digest.hash.size()); i++)
-    {
-      WRITE_CODE(sei.m_digest.hash[i], 8, traceString);
+    for(UInt i=0; i<UInt(sei.m_pictureHash.hash.size()); i++)
+    {
+      WRITE_CODE(sei.m_pictureHash.hash[i], 8, traceString);
     }
   }
@@ -795 +791 @@
 
   // write nested SEI messages
-  for (SEIMessages::const_iterator it = sei.m_nestedSEIs.begin(); it != sei.m_nestedSEIs.end(); it++)
-  {
-#if O0164_MULTI_LAYER_HRD
-    writeSEImessage(bs, *(*it), vps, sps, &sei);
+#if O0164_MULTI_LAYER_HRD  
+  writeSEImessages(bs, sei.m_nestedSEIs, vps, sps, &sei);
 #else
-    writeSEImessage(bs, *(*it), sps);
-#endif
-  }
+  writeSEImessages(bs, sei.m_nestedSEIs, sps);
+#endif
 }
 
@@ -1148 +1141 @@
   assert( sei.m_nestedSEIs.size() <= MAX_SEIS_IN_BSP_NESTING );
   WRITE_UVLC( (UInt)sei.m_nestedSEIs.size(), "num_seis_in_bsp_minus1" );
-
+  
   // write nested SEI messages
-  for (SEIMessages::const_iterator it = sei.m_nestedSEIs.begin(); it != sei.m_nestedSEIs.end(); it++)
-  {
-    writeSEImessage(bs, *(*it), vps, sps, &nestingSei, &sei);
-  }
+  writeSEImessages(bs, sei.m_nestedSEIs, vps, sps, &nestingSei, &sei);
 }
 

branches/SHM-dev/source/Lib/TLibEncoder/SEIwrite.h

@@ -51 +51 @@
 
 #if O0164_MULTI_LAYER_HRD
-  Void writeSEImessage(TComBitIf& bs, const SEI& sei, const TComVPS *vps, const TComSPS *sps, const SEIScalableNesting* nestingSei=NULL, const SEIBspNesting* bspNestingSei=NULL);
+  Void writeSEImessages(TComBitIf& bs, const SEIMessages &seiList, const TComVPS *vps, const TComSPS *sps, const SEIScalableNesting* nestingSei=NULL, const SEIBspNesting* bspNestingSei=NULL);
 #else
-  Void writeSEImessage(TComBitIf& bs, const SEI& sei, const TComSPS *sps);
+  Void writeSEImessages(TComBitIf& bs, const SEIMessages &seiList, const TComSPS *sps);
 #endif
 
@@ -110 +110 @@
 #endif
 #if Q0189_TMVP_CONSTRAINTS 
-Void xWriteSEITMVPConstraints(const SEITMVPConstrains &sei);
+  Void xWriteSEITMVPConstraints(const SEITMVPConstrains &sei);
 #endif
 #if Q0247_FRAME_FIELD_INFO

branches/SHM-dev/source/Lib/TLibEncoder/TEncCfg.h

@@ -444 +444 @@
 #endif
 #if Q0189_TMVP_CONSTRAINTS
-  Int       m_TMVPConstraintsSEIEnabled;
+  Int                                 m_TMVPConstraintsSEIEnabled;
 #endif
 #endif //SVC_EXTENSION

branches/SHM-dev/source/Lib/TLibEncoder/TEncGOP.cpp

@@ -53 +53 @@
 #endif
 
+#include <deque>
 using namespace std;
 
@@ -103 +104 @@
   ::memset(m_ltRefPicPocLsbSps, 0, sizeof(m_ltRefPicPocLsbSps));
   ::memset(m_ltRefPicUsedByCurrPicFlag, 0, sizeof(m_ltRefPicUsedByCurrPicFlag));
-  m_cpbRemovalDelay   = 0;
   m_lastBPSEI         = 0;
   xResetNonNestedSEIPresentFlags();
@@ -123 +123 @@
 
 #if Q0074_COLOUR_REMAPPING_SEI
-  for( Int c=0 ; c<3 ; c++)
-  {
-    m_colourRemapSEIPreLutCodedValue[c]   = NULL;
-    m_colourRemapSEIPreLutTargetValue[c]  = NULL;
-    m_colourRemapSEIPostLutCodedValue[c]  = NULL;
-    m_colourRemapSEIPostLutTargetValue[c] = NULL;
-  }
+  memset( m_seiColourRemappingInfo.m_colourRemapSEIPreLutCodedValue,   NULL, sizeof(m_seiColourRemappingInfo.m_colourRemapSEIPreLutCodedValue));
+  memset( m_seiColourRemappingInfo.m_colourRemapSEIPreLutTargetValue,  NULL, sizeof(m_seiColourRemappingInfo.m_colourRemapSEIPreLutTargetValue));
+  memset( m_seiColourRemappingInfo.m_colourRemapSEIPostLutCodedValue,  NULL, sizeof(m_seiColourRemappingInfo.m_colourRemapSEIPostLutCodedValue));
+  memset( m_seiColourRemappingInfo.m_colourRemapSEIPostLutTargetValue, NULL, sizeof(m_seiColourRemappingInfo.m_colourRemapSEIPostLutTargetValue));
 #endif
   return;
@@ -176 +173 @@
   m_pcEncTop     = pcTEncTop;
   m_pcCfg                = pcTEncTop;
+  m_seiEncoder.init(m_pcCfg, pcTEncTop, this);
   m_pcSliceEncoder       = pcTEncTop->getSliceEncoder();
   m_pcListPic            = pcTEncTop->getListPic();
@@ -216 +214 @@
 }
 
-SEIActiveParameterSets* TEncGOP::xCreateSEIActiveParameterSets (const TComSPS *sps)
-{
-  SEIActiveParameterSets *seiActiveParameterSets = new SEIActiveParameterSets();
-  seiActiveParameterSets->activeVPSId = m_pcCfg->getVPS()->getVPSId();
-  seiActiveParameterSets->m_selfContainedCvsFlag = false;
-  seiActiveParameterSets->m_noParameterSetUpdateFlag = false;  
+Int TEncGOP::xWriteVPS (AccessUnit &accessUnit, const TComVPS *vps)
+{
+  OutputNALUnit nalu(NAL_UNIT_VPS);
+  m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
+  m_pcEntropyCoder->encodeVPS(vps);
+  writeRBSPTrailingBits(nalu.m_Bitstream);
+  accessUnit.push_back(new NALUnitEBSP(nalu));
+  return (Int)(accessUnit.back()->m_nalUnitData.str().size()) * 8;
+}
+
+Int TEncGOP::xWriteSPS (AccessUnit &accessUnit, const TComSPS *sps)
+{
+#if SVC_EXTENSION
+  OutputNALUnit nalu(NAL_UNIT_SPS, 0, m_layerId);
+
+  if (m_pcEncTop->getVPS()->getNumDirectRefLayers(m_layerId) == 0 && m_pcEncTop->getVPS()->getNumAddLayerSets() > 0)
+  {
+    nalu.m_nuhLayerId = 0; // For independent base layer rewriting
+  }
+
+  // dependency constraint
+  assert( sps->getLayerId() == 0 || sps->getLayerId() == m_layerId || m_pcEncTop->getVPS()->getRecursiveRefLayerFlag(m_layerId, sps->getLayerId()) );
+#else
+  OutputNALUnit nalu(NAL_UNIT_SPS);
+#endif
+  m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
+  m_pcEntropyCoder->encodeSPS(sps);
+  writeRBSPTrailingBits(nalu.m_Bitstream);
+  accessUnit.push_back(new NALUnitEBSP(nalu));
+  return (Int)(accessUnit.back()->m_nalUnitData.str().size()) * 8;
+
+}
+
+Int TEncGOP::xWritePPS (AccessUnit &accessUnit, const TComPPS *pps)
+{
+#if SVC_EXTENSION
+  OutputNALUnit nalu(NAL_UNIT_PPS, 0, m_layerId);
+
+  if( m_pcEncTop->getVPS()->getNumDirectRefLayers(m_layerId) == 0 && m_pcEncTop->getVPS()->getNumAddLayerSets() > 0 )
+  {
+    // For independent base layer rewriting
+    nalu.m_nuhLayerId = 0;
+  }
+
+  // dependency constraint
+  assert( pps->getLayerId() == 0 || pps->getLayerId() == m_layerId || m_pcEncTop->getVPS()->getRecursiveRefLayerFlag(m_layerId, pps->getLayerId()) );
+#else
+  OutputNALUnit nalu(NAL_UNIT_PPS);
+#endif
+  m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
+#if SVC_EXTENSION && CGS_3D_ASYMLUT
+  m_pcEntropyCoder->encodePPS(pps, &m_Enc3DAsymLUTPPS);
+#else
+  m_pcEntropyCoder->encodePPS(pps);
+#endif
+  writeRBSPTrailingBits(nalu.m_Bitstream);
+  accessUnit.push_back(new NALUnitEBSP(nalu));
+  return (Int)(accessUnit.back()->m_nalUnitData.str().size()) * 8;
+}
+
+
+Int TEncGOP::xWriteParameterSets (AccessUnit &accessUnit, TComSlice *slice)
+{
+  Int actualTotalBits = 0;
+
+  actualTotalBits += xWriteVPS(accessUnit, m_pcEncTop->getVPS());
+  actualTotalBits += xWriteSPS(accessUnit, slice->getSPS());
+  actualTotalBits += xWritePPS(accessUnit, slice->getPPS());
+
+  return actualTotalBits;
+}
+
+// write SEI list into one NAL unit and add it to the Access unit at auPos
+#if O0164_MULTI_LAYER_HRD
+Void TEncGOP::xWriteSEI (NalUnitType naluType, SEIMessages& seiMessages, AccessUnit &accessUnit, AccessUnit::iterator &auPos, Int temporalId, const TComVPS *vps, const TComSPS *sps, const SEIScalableNesting* nestingSei, const SEIBspNesting* bspNestingSei)
+#else
+Void TEncGOP::xWriteSEI (NalUnitType naluType, SEIMessages& seiMessages, AccessUnit &accessUnit, AccessUnit::iterator &auPos, Int temporalId, const TComSPS *sps)
+#endif
+{
+  // don't do anything, if we get an empty list
+  if (seiMessages.empty())
+  {
+    return;
+  }
+#if O0164_MULTI_LAYER_HRD
+  OutputNALUnit nalu(naluType, temporalId, sps->getLayerId());
+  m_seiWriter.writeSEImessages(nalu.m_Bitstream, seiMessages, vps, sps, nestingSei, bspNestingSei);
+#else
+  OutputNALUnit nalu(naluType, temporalId);
+  m_seiWriter.writeSEImessages(nalu.m_Bitstream, seiMessages, sps);
+#endif
+  writeRBSPTrailingBits(nalu.m_Bitstream);
+  auPos = accessUnit.insert(auPos, new NALUnitEBSP(nalu));
+  auPos++;
+}
+
+#if O0164_MULTI_LAYER_HRD
+Void TEncGOP::xWriteSEISeparately (NalUnitType naluType, SEIMessages& seiMessages, AccessUnit &accessUnit, AccessUnit::iterator &auPos, Int temporalId, const TComVPS *vps, const TComSPS *sps, const SEIScalableNesting* nestingSei, const SEIBspNesting* bspNestingSei)
+#else
+Void TEncGOP::xWriteSEISeparately (NalUnitType naluType, SEIMessages& seiMessages, AccessUnit &accessUnit, AccessUnit::iterator &auPos, Int temporalId, const TComSPS *sps)
+#endif
+{
+  // don't do anything, if we get an empty list
+  if (seiMessages.empty())
+  {
+    return;
+  }
+  for (SEIMessages::const_iterator sei = seiMessages.begin(); sei!=seiMessages.end(); sei++ )
+  {
+    SEIMessages tmpMessages;
+    tmpMessages.push_back(*sei);
+#if O0164_MULTI_LAYER_HRD
+    OutputNALUnit nalu(naluType, temporalId, sps->getLayerId());
+    m_seiWriter.writeSEImessages(nalu.m_Bitstream, tmpMessages, vps, sps, nestingSei, bspNestingSei);
+#else
+    OutputNALUnit nalu(naluType, temporalId);
+    m_seiWriter.writeSEImessages(nalu.m_Bitstream, tmpMessages, sps);
+#endif
+    writeRBSPTrailingBits(nalu.m_Bitstream);
+    auPos = accessUnit.insert(auPos, new NALUnitEBSP(nalu));
+    auPos++;
+  }
+}
+
+Void TEncGOP::xClearSEIs(SEIMessages& seiMessages, Bool deleteMessages)
+{
+  if (deleteMessages)
+  {
+    deleteSEIs(seiMessages);
+  }
+  else
+  {
+    seiMessages.clear();
+  }
+}
+
+// write SEI messages as separate NAL units ordered
+#if O0164_MULTI_LAYER_HRD
+Void TEncGOP::xWriteLeadingSEIOrdered (SEIMessages& seiMessages, SEIMessages& duInfoSeiMessages, AccessUnit &accessUnit, Int temporalId,const TComVPS *vps, const TComSPS *sps, Bool testWrite, const SEIScalableNesting* nestingSei, const SEIBspNesting* bspNestingSei)
+#else
+Void TEncGOP::xWriteLeadingSEIOrdered (SEIMessages& seiMessages, SEIMessages& duInfoSeiMessages, AccessUnit &accessUnit, Int temporalId, const TComSPS *sps, Bool testWrite)
+#endif
+{
+  AccessUnit::iterator itNalu = accessUnit.begin();
+
+  while ( (itNalu!=accessUnit.end())&&
+    ( (*itNalu)->m_nalUnitType==NAL_UNIT_ACCESS_UNIT_DELIMITER 
+    || (*itNalu)->m_nalUnitType==NAL_UNIT_VPS
+    || (*itNalu)->m_nalUnitType==NAL_UNIT_SPS
+    || (*itNalu)->m_nalUnitType==NAL_UNIT_PPS
+    ))
+  {
+    itNalu++;
+  }
+
+  SEIMessages localMessages = seiMessages;
+  SEIMessages currentMessages;
+  
+#if ENC_DEC_TRACE
+  g_HLSTraceEnable = !testWrite;
+#endif
+  // The case that a specific SEI is not present is handled in xWriteSEI (empty list)
+
+  // Active parameter sets SEI must always be the first SEI
+  currentMessages = extractSeisByType(localMessages, SEI::ACTIVE_PARAMETER_SETS);
+  assert (currentMessages.size() <= 1);
+#if O0164_MULTI_LAYER_HRD
+  xWriteSEI(NAL_UNIT_PREFIX_SEI, currentMessages, accessUnit, itNalu, temporalId, vps, sps, nestingSei, bspNestingSei);
+#else
+  xWriteSEI(NAL_UNIT_PREFIX_SEI, currentMessages, accessUnit, itNalu, temporalId, sps);
+#endif
+  xClearSEIs(currentMessages, !testWrite);
+  
+  // Buffering period SEI must always be following active parameter sets
+  currentMessages = extractSeisByType(localMessages, SEI::BUFFERING_PERIOD);
+  assert (currentMessages.size() <= 1);
+#if O0164_MULTI_LAYER_HRD
+  xWriteSEI(NAL_UNIT_PREFIX_SEI, currentMessages, accessUnit, itNalu, temporalId, vps, sps, nestingSei, bspNestingSei);
+#else
+  xWriteSEI(NAL_UNIT_PREFIX_SEI, currentMessages, accessUnit, itNalu, temporalId, sps);
+#endif
+  xClearSEIs(currentMessages, !testWrite);
+
+  // Picture timing SEI must always be following buffering period
+  currentMessages = extractSeisByType(localMessages, SEI::PICTURE_TIMING);
+  assert (currentMessages.size() <= 1);
+#if O0164_MULTI_LAYER_HRD
+  xWriteSEI(NAL_UNIT_PREFIX_SEI, currentMessages, accessUnit, itNalu, temporalId, vps, sps, nestingSei, bspNestingSei);
+#else
+  xWriteSEI(NAL_UNIT_PREFIX_SEI, currentMessages, accessUnit, itNalu, temporalId, sps);
+#endif
+  xClearSEIs(currentMessages, !testWrite);
+
+  // Decoding unit info SEI must always be following picture timing
+  if (!duInfoSeiMessages.empty())
+  {
+    currentMessages.push_back(duInfoSeiMessages.front());
+    if (!testWrite)
+    {
+      duInfoSeiMessages.pop_front();
+    }
+#if O0164_MULTI_LAYER_HRD
+    xWriteSEI(NAL_UNIT_PREFIX_SEI, currentMessages, accessUnit, itNalu, temporalId, vps, sps, nestingSei, bspNestingSei);
+#else
+    xWriteSEI(NAL_UNIT_PREFIX_SEI, currentMessages, accessUnit, itNalu, temporalId, sps);
+#endif
+    xClearSEIs(currentMessages, !testWrite);
+  }
+
+  // Scalable nesting SEI must always be the following DU info
+  currentMessages = extractSeisByType(localMessages, SEI::SCALABLE_NESTING);
+#if O0164_MULTI_LAYER_HRD
+  xWriteSEISeparately(NAL_UNIT_PREFIX_SEI, currentMessages, accessUnit, itNalu, temporalId, vps, sps, nestingSei, bspNestingSei);
+#else
+  xWriteSEISeparately(NAL_UNIT_PREFIX_SEI, currentMessages, accessUnit, itNalu, temporalId, sps);
+#endif
+  xClearSEIs(currentMessages, !testWrite);
+
+  // And finally everything else one by one
+#if O0164_MULTI_LAYER_HRD
+  xWriteSEISeparately(NAL_UNIT_PREFIX_SEI, localMessages, accessUnit, itNalu, temporalId, vps, sps, nestingSei, bspNestingSei);
+#else
+  xWriteSEISeparately(NAL_UNIT_PREFIX_SEI, localMessages, accessUnit, itNalu, temporalId, sps);
+#endif
+  xClearSEIs(currentMessages, !testWrite);
+
+  if (!testWrite)
+  {
+    seiMessages.clear();
+  }
+}
+
+#if O0164_MULTI_LAYER_HRD
+Void TEncGOP::xWriteLeadingSEIMessages (SEIMessages& seiMessages, SEIMessages& duInfoSeiMessages, AccessUnit &accessUnit, Int temporalId,const TComVPS *vps, const TComSPS *sps, std::deque<DUData> &duData, const SEIScalableNesting* nestingSei, const SEIBspNesting* bspNestingSei)
+#else
+Void TEncGOP::xWriteLeadingSEIMessages (SEIMessages& seiMessages, SEIMessages& duInfoSeiMessages, AccessUnit &accessUnit, Int temporalId, const TComSPS *sps, std::deque<DUData> &duData)
+#endif
+{
+  AccessUnit testAU;
+  SEIMessages picTimingSEIs = getSeisByType(seiMessages, SEI::PICTURE_TIMING);
+  assert (picTimingSEIs.size() < 2);
+  SEIPictureTiming * picTiming = picTimingSEIs.empty() ? NULL : (SEIPictureTiming*) picTimingSEIs.front();
+
+  // test writing
+#if O0164_MULTI_LAYER_HRD
+  xWriteLeadingSEIOrdered(seiMessages, duInfoSeiMessages, testAU, temporalId, vps, sps, true, nestingSei, bspNestingSei);
+#else
+  xWriteLeadingSEIOrdered(seiMessages, duInfoSeiMessages, testAU, temporalId, sps, true);
+#endif
+  // update Timing and DU info SEI
+  xUpdateDuData(testAU, duData);
+  xUpdateTimingSEI(picTiming, duData, sps);
+  xUpdateDuInfoSEI(duInfoSeiMessages, picTiming);
+  // actual writing
+#if O0164_MULTI_LAYER_HRD
+  xWriteLeadingSEIOrdered(seiMessages, duInfoSeiMessages, accessUnit, temporalId, vps, sps, false, nestingSei, bspNestingSei);
+#else
+  xWriteLeadingSEIOrdered(seiMessages, duInfoSeiMessages, accessUnit, temporalId, sps, false);
+#endif
+
+  // testAU will automatically be cleaned up when losing scope
+}
+
+#if O0164_MULTI_LAYER_HRD
+Void TEncGOP::xWriteTrailingSEIMessages (SEIMessages& seiMessages, AccessUnit &accessUnit, Int temporalId, const TComVPS *vps, const TComSPS *sps, const SEIScalableNesting* nestingSei, const SEIBspNesting* bspNestingSei)
+#else
+Void TEncGOP::xWriteTrailingSEIMessages (SEIMessages& seiMessages, AccessUnit &accessUnit, Int temporalId, const TComSPS *sps)
+#endif
+{
+  // Note: using accessUnit.end() works only as long as this function is called after slice coding and before EOS/EOB NAL units
+  AccessUnit::iterator pos = accessUnit.end();
+#if O0164_MULTI_LAYER_HRD
+  xWriteSEISeparately(NAL_UNIT_SUFFIX_SEI, seiMessages, accessUnit, pos, temporalId, vps, sps, nestingSei, bspNestingSei);
+#else
+  xWriteSEISeparately(NAL_UNIT_SUFFIX_SEI, seiMessages, accessUnit, pos, temporalId, sps);
+#endif
+}
+
+#if O0164_MULTI_LAYER_HRD
+Void TEncGOP::xWriteDuSEIMessages (SEIMessages& duInfoSeiMessages, AccessUnit &accessUnit, Int temporalId, const TComVPS *vps, const TComSPS *sps, std::deque<DUData> &duData, const SEIScalableNesting* nestingSei, const SEIBspNesting* bspNestingSei)
+#else
+Void TEncGOP::xWriteDuSEIMessages (SEIMessages& duInfoSeiMessages, AccessUnit &accessUnit, Int temporalId, const TComSPS *sps, std::deque<DUData> &duData)
+#endif
+{
+  const TComHRD *hrd = sps->getVuiParameters()->getHrdParameters();
+
+  if( m_pcCfg->getDecodingUnitInfoSEIEnabled() && hrd->getSubPicCpbParamsPresentFlag() )
+  {
+    Int naluIdx = 0;
+    AccessUnit::iterator nalu = accessUnit.begin();
+
+    // skip over first DU, we have a DU info SEI there already
+    while (naluIdx < duData[0].accumNalsDU && nalu!=accessUnit.end())
+    {
+      naluIdx++;
+      nalu++;
+    }
+
+    SEIMessages::iterator duSEI = duInfoSeiMessages.begin();
+    // loop over remaining DUs
+    for (Int duIdx = 1; duIdx < duData.size(); duIdx++)
+    {
+      if (duSEI == duInfoSeiMessages.end())
+      {
+        // if the number of generated SEIs matches the number of DUs, this should not happen
+        assert (false);
+        return;
+      }
+      // write the next SEI
+      SEIMessages tmpSEI;
+      tmpSEI.push_back(*duSEI);
+#if O0164_MULTI_LAYER_HRD
+      xWriteSEI(NAL_UNIT_PREFIX_SEI, tmpSEI, accessUnit, nalu, temporalId, vps, sps, nestingSei, bspNestingSei);
+#else
+      xWriteSEI(NAL_UNIT_PREFIX_SEI, tmpSEI, accessUnit, nalu, temporalId, sps);
+#endif
+      // nalu points to the position after the SEI, so we have to increase the index as well
+      naluIdx++;
+      while ((naluIdx < duData[duIdx].accumNalsDU) && nalu!=accessUnit.end())
+      {
+        naluIdx++;
+        nalu++;
+      }
+      duSEI++;
+    }
+  }
+  deleteSEIs(duInfoSeiMessages);
+}
+
+
+Void TEncGOP::xCreateIRAPLeadingSEIMessages (SEIMessages& seiMessages, const TComSPS *sps, const TComPPS *pps)
+{
+  OutputNALUnit nalu(NAL_UNIT_PREFIX_SEI);
+
 #if R0247_SEI_ACTIVE
-  seiActiveParameterSets->numSpsIdsMinus1 = m_pcCfg->getNumLayer()-1;
-  seiActiveParameterSets->activeSeqParameterSetId.resize(seiActiveParameterSets->numSpsIdsMinus1 + 1);
-  seiActiveParameterSets->layerSpsIdx.resize(seiActiveParameterSets->numSpsIdsMinus1+ 1);  
-  for (Int c=0; c <= seiActiveParameterSets->numSpsIdsMinus1; c++)
-  {
-     seiActiveParameterSets->activeSeqParameterSetId[c] = c;
-  }
-  for (Int c=1; c <= seiActiveParameterSets->numSpsIdsMinus1; c++)
-  {
-     seiActiveParameterSets->layerSpsIdx[c] = c;
-  }
-#else
-  seiActiveParameterSets->numSpsIdsMinus1 = 0;
-  seiActiveParameterSets->activeSeqParameterSetId.resize(seiActiveParameterSets->numSpsIdsMinus1 + 1);
-  seiActiveParameterSets->activeSeqParameterSetId[0] = sps->getSPSId();
-#endif
-  return seiActiveParameterSets;
-}
-
-SEIFramePacking* TEncGOP::xCreateSEIFramePacking()
-{
-  SEIFramePacking *seiFramePacking = new SEIFramePacking();
-  seiFramePacking->m_arrangementId = m_pcCfg->getFramePackingArrangementSEIId();
-  seiFramePacking->m_arrangementCancelFlag = 0;
-  seiFramePacking->m_arrangementType = m_pcCfg->getFramePackingArrangementSEIType();
-  assert((seiFramePacking->m_arrangementType > 2) && (seiFramePacking->m_arrangementType < 6) );
-  seiFramePacking->m_quincunxSamplingFlag = m_pcCfg->getFramePackingArrangementSEIQuincunx();
-  seiFramePacking->m_contentInterpretationType = m_pcCfg->getFramePackingArrangementSEIInterpretation();
-  seiFramePacking->m_spatialFlippingFlag = 0;
-  seiFramePacking->m_frame0FlippedFlag = 0;
-  seiFramePacking->m_fieldViewsFlag = (seiFramePacking->m_arrangementType == 2);
-  seiFramePacking->m_currentFrameIsFrame0Flag = ((seiFramePacking->m_arrangementType == 5) && (m_iNumPicCoded&1));
-  seiFramePacking->m_frame0SelfContainedFlag = 0;
-  seiFramePacking->m_frame1SelfContainedFlag = 0;
-  seiFramePacking->m_frame0GridPositionX = 0;
-  seiFramePacking->m_frame0GridPositionY = 0;
-  seiFramePacking->m_frame1GridPositionX = 0;
-  seiFramePacking->m_frame1GridPositionY = 0;
-  seiFramePacking->m_arrangementReservedByte = 0;
-  seiFramePacking->m_arrangementPersistenceFlag = true;
-  seiFramePacking->m_upsampledAspectRatio = 0;
-  return seiFramePacking;
-}
-
-SEISegmentedRectFramePacking* TEncGOP::xCreateSEISegmentedRectFramePacking()
-{
-  SEISegmentedRectFramePacking *seiSegmentedRectFramePacking = new SEISegmentedRectFramePacking();
-  seiSegmentedRectFramePacking->m_arrangementCancelFlag = m_pcCfg->getSegmentedRectFramePackingArrangementSEICancel();
-  seiSegmentedRectFramePacking->m_contentInterpretationType = m_pcCfg->getSegmentedRectFramePackingArrangementSEIType();
-  seiSegmentedRectFramePacking->m_arrangementPersistenceFlag = m_pcCfg->getSegmentedRectFramePackingArrangementSEIPersistence();
-  return seiSegmentedRectFramePacking;
-}
-
-SEIDisplayOrientation* TEncGOP::xCreateSEIDisplayOrientation()
-{
-  SEIDisplayOrientation *seiDisplayOrientation = new SEIDisplayOrientation();
-  seiDisplayOrientation->cancelFlag = false;
-  seiDisplayOrientation->horFlip = false;
-  seiDisplayOrientation->verFlip = false;
-  seiDisplayOrientation->anticlockwiseRotation = m_pcCfg->getDisplayOrientationSEIAngle();
-  return seiDisplayOrientation;
-}
-SEIToneMappingInfo*  TEncGOP::xCreateSEIToneMappingInfo()
-{
-  SEIToneMappingInfo *seiToneMappingInfo = new SEIToneMappingInfo();
-  seiToneMappingInfo->m_toneMapId = m_pcCfg->getTMISEIToneMapId();
-  seiToneMappingInfo->m_toneMapCancelFlag = m_pcCfg->getTMISEIToneMapCancelFlag();
-  seiToneMappingInfo->m_toneMapPersistenceFlag = m_pcCfg->getTMISEIToneMapPersistenceFlag();
-
-  seiToneMappingInfo->m_codedDataBitDepth = m_pcCfg->getTMISEICodedDataBitDepth();
-  assert(seiToneMappingInfo->m_codedDataBitDepth >= 8 && seiToneMappingInfo->m_codedDataBitDepth <= 14);
-  seiToneMappingInfo->m_targetBitDepth = m_pcCfg->getTMISEITargetBitDepth();
-  assert(seiToneMappingInfo->m_targetBitDepth >= 1 && seiToneMappingInfo->m_targetBitDepth <= 17);
-  seiToneMappingInfo->m_modelId = m_pcCfg->getTMISEIModelID();
-  assert(seiToneMappingInfo->m_modelId >=0 &&seiToneMappingInfo->m_modelId<=4);
-
-  switch( seiToneMappingInfo->m_modelId)
-  {
-  case 0:
-    {
-      seiToneMappingInfo->m_minValue = m_pcCfg->getTMISEIMinValue();
-      seiToneMappingInfo->m_maxValue = m_pcCfg->getTMISEIMaxValue();
-      break;
-    }
-  case 1:
-    {
-      seiToneMappingInfo->m_sigmoidMidpoint = m_pcCfg->getTMISEISigmoidMidpoint();
-      seiToneMappingInfo->m_sigmoidWidth = m_pcCfg->getTMISEISigmoidWidth();
-      break;
-    }
-  case 2:
-    {
-      UInt num = 1u<<(seiToneMappingInfo->m_targetBitDepth);
-      seiToneMappingInfo->m_startOfCodedInterval.resize(num);
-      Int* ptmp = m_pcCfg->getTMISEIStartOfCodedInterva();
-      if(ptmp)
-      {
-        for(Int i=0; i<num;i++)
-        {
-          seiToneMappingInfo->m_startOfCodedInterval[i] = ptmp[i];
-        }
-      }
-      break;
-    }
-  case 3:
-    {
-      seiToneMappingInfo->m_numPivots = m_pcCfg->getTMISEINumPivots();
-      seiToneMappingInfo->m_codedPivotValue.resize(seiToneMappingInfo->m_numPivots);
-      seiToneMappingInfo->m_targetPivotValue.resize(seiToneMappingInfo->m_numPivots);
-      Int* ptmpcoded = m_pcCfg->getTMISEICodedPivotValue();
-      Int* ptmptarget = m_pcCfg->getTMISEITargetPivotValue();
-      if(ptmpcoded&&ptmptarget)
-      {
-        for(Int i=0; i<(seiToneMappingInfo->m_numPivots);i++)
-        {
-          seiToneMappingInfo->m_codedPivotValue[i]=ptmpcoded[i];
-          seiToneMappingInfo->m_targetPivotValue[i]=ptmptarget[i];
-         }
-       }
-       break;
-     }
-  case 4:
-     {
-       seiToneMappingInfo->m_cameraIsoSpeedIdc = m_pcCfg->getTMISEICameraIsoSpeedIdc();
-       seiToneMappingInfo->m_cameraIsoSpeedValue = m_pcCfg->getTMISEICameraIsoSpeedValue();
-       assert( seiToneMappingInfo->m_cameraIsoSpeedValue !=0 );
-       seiToneMappingInfo->m_exposureIndexIdc = m_pcCfg->getTMISEIExposurIndexIdc();
-       seiToneMappingInfo->m_exposureIndexValue = m_pcCfg->getTMISEIExposurIndexValue();
-       assert( seiToneMappingInfo->m_exposureIndexValue !=0 );
-       seiToneMappingInfo->m_exposureCompensationValueSignFlag = m_pcCfg->getTMISEIExposureCompensationValueSignFlag();
-       seiToneMappingInfo->m_exposureCompensationValueNumerator = m_pcCfg->getTMISEIExposureCompensationValueNumerator();
-       seiToneMappingInfo->m_exposureCompensationValueDenomIdc = m_pcCfg->getTMISEIExposureCompensationValueDenomIdc();
-       seiToneMappingInfo->m_refScreenLuminanceWhite = m_pcCfg->getTMISEIRefScreenLuminanceWhite();
-       seiToneMappingInfo->m_extendedRangeWhiteLevel = m_pcCfg->getTMISEIExtendedRangeWhiteLevel();
-       assert( seiToneMappingInfo->m_extendedRangeWhiteLevel >= 100 );
-       seiToneMappingInfo->m_nominalBlackLevelLumaCodeValue = m_pcCfg->getTMISEINominalBlackLevelLumaCodeValue();
-       seiToneMappingInfo->m_nominalWhiteLevelLumaCodeValue = m_pcCfg->getTMISEINominalWhiteLevelLumaCodeValue();
-       assert( seiToneMappingInfo->m_nominalWhiteLevelLumaCodeValue > seiToneMappingInfo->m_nominalBlackLevelLumaCodeValue );
-       seiToneMappingInfo->m_extendedWhiteLevelLumaCodeValue = m_pcCfg->getTMISEIExtendedWhiteLevelLumaCodeValue();
-       assert( seiToneMappingInfo->m_extendedWhiteLevelLumaCodeValue >= seiToneMappingInfo->m_nominalWhiteLevelLumaCodeValue );
-       break;
-    }
-  default:
-    {
-      assert(!"Undefined SEIToneMapModelId");
-      break;
-    }
-  }
-  return seiToneMappingInfo;
-}
-
-SEITempMotionConstrainedTileSets* TEncGOP::xCreateSEITempMotionConstrainedTileSets (const TComPPS *pps)
-{
-  SEITempMotionConstrainedTileSets *sei = new SEITempMotionConstrainedTileSets();
-  if(pps->getTilesEnabledFlag())
-  {
-    sei->m_mc_all_tiles_exact_sample_value_match_flag = false;
-    sei->m_each_tile_one_tile_set_flag                = false;
-    sei->m_limited_tile_set_display_flag              = false;
-    sei->setNumberOfTileSets((pps->getNumTileColumnsMinus1() + 1) * (pps->getNumTileRowsMinus1() + 1));
-
-    for(Int i=0; i < sei->getNumberOfTileSets(); i++)
-    {
-      sei->tileSetData(i).m_mcts_id = i;  //depends the application;
-      sei->tileSetData(i).setNumberOfTileRects(1);
-
-      for(Int j=0; j<sei->tileSetData(i).getNumberOfTileRects(); j++)
-      {
-        sei->tileSetData(i).topLeftTileIndex(j)     = i+j;
-        sei->tileSetData(i).bottomRightTileIndex(j) = i+j;
-      }
-
-      sei->tileSetData(i).m_exact_sample_value_match_flag    = false;
-      sei->tileSetData(i).m_mcts_tier_level_idc_present_flag = false;
-    }
-  }
-  else
-  {
-    assert(!"Tile is not enabled");
-  }
-  return sei;
-}
-
-SEIKneeFunctionInfo* TEncGOP::xCreateSEIKneeFunctionInfo()
-{
-  SEIKneeFunctionInfo *seiKneeFunctionInfo = new SEIKneeFunctionInfo();
-  seiKneeFunctionInfo->m_kneeId = m_pcCfg->getKneeSEIId();
-  seiKneeFunctionInfo->m_kneeCancelFlag = m_pcCfg->getKneeSEICancelFlag();
-  if ( !seiKneeFunctionInfo->m_kneeCancelFlag )
-  {
-    seiKneeFunctionInfo->m_kneePersistenceFlag = m_pcCfg->getKneeSEIPersistenceFlag();
-    seiKneeFunctionInfo->m_kneeInputDrange = m_pcCfg->getKneeSEIInputDrange();
-    seiKneeFunctionInfo->m_kneeInputDispLuminance = m_pcCfg->getKneeSEIInputDispLuminance();
-    seiKneeFunctionInfo->m_kneeOutputDrange = m_pcCfg->getKneeSEIOutputDrange();
-    seiKneeFunctionInfo->m_kneeOutputDispLuminance = m_pcCfg->getKneeSEIOutputDispLuminance();
-
-    seiKneeFunctionInfo->m_kneeNumKneePointsMinus1 = m_pcCfg->getKneeSEINumKneePointsMinus1();
-    Int* piInputKneePoint  = m_pcCfg->getKneeSEIInputKneePoint();
-    Int* piOutputKneePoint = m_pcCfg->getKneeSEIOutputKneePoint();
-    if(piInputKneePoint&&piOutputKneePoint)
-    {
-      seiKneeFunctionInfo->m_kneeInputKneePoint.resize(seiKneeFunctionInfo->m_kneeNumKneePointsMinus1+1);
-      seiKneeFunctionInfo->m_kneeOutputKneePoint.resize(seiKneeFunctionInfo->m_kneeNumKneePointsMinus1+1);
-      for(Int i=0; i<=seiKneeFunctionInfo->m_kneeNumKneePointsMinus1; i++)
-      {
-        seiKneeFunctionInfo->m_kneeInputKneePoint[i] = piInputKneePoint[i];
-        seiKneeFunctionInfo->m_kneeOutputKneePoint[i] = piOutputKneePoint[i];
-       }
-    }
-  }
-  return seiKneeFunctionInfo;
-}
-
-SEIChromaSamplingFilterHint* TEncGOP::xCreateSEIChromaSamplingFilterHint(Bool bChromaLocInfoPresent, Int iHorFilterIndex, Int iVerFilterIndex)
-{
-  SEIChromaSamplingFilterHint *seiChromaSamplingFilterHint = new SEIChromaSamplingFilterHint();
-  seiChromaSamplingFilterHint->m_verChromaFilterIdc = iVerFilterIndex;
-  seiChromaSamplingFilterHint->m_horChromaFilterIdc = iHorFilterIndex;
-  seiChromaSamplingFilterHint->m_verFilteringProcessFlag = 1;
-  seiChromaSamplingFilterHint->m_targetFormatIdc = 3;
-  seiChromaSamplingFilterHint->m_perfectReconstructionFlag = false;
-  if(seiChromaSamplingFilterHint->m_verChromaFilterIdc == 1)
-  {
-    seiChromaSamplingFilterHint->m_numVerticalFilters = 1;
-    seiChromaSamplingFilterHint->m_verTapLengthMinus1 = (Int*)malloc(seiChromaSamplingFilterHint->m_numVerticalFilters * sizeof(Int));
-    seiChromaSamplingFilterHint->m_verFilterCoeff =    (Int**)malloc(seiChromaSamplingFilterHint->m_numVerticalFilters * sizeof(Int*));
-    for(Int i = 0; i < seiChromaSamplingFilterHint->m_numVerticalFilters; i ++)
-    {
-      seiChromaSamplingFilterHint->m_verTapLengthMinus1[i] = 0;
-      seiChromaSamplingFilterHint->m_verFilterCoeff[i] = (Int*)malloc(seiChromaSamplingFilterHint->m_verTapLengthMinus1[i] * sizeof(Int));
-      for(Int j = 0; j < seiChromaSamplingFilterHint->m_verTapLengthMinus1[i]; j ++)
-      {
-        seiChromaSamplingFilterHint->m_verFilterCoeff[i][j] = 0;
-      }
-    }
-  }
-  else
-  {
-    seiChromaSamplingFilterHint->m_numVerticalFilters = 0;
-    seiChromaSamplingFilterHint->m_verTapLengthMinus1 = NULL;
-    seiChromaSamplingFilterHint->m_verFilterCoeff = NULL;
-  }
-  if(seiChromaSamplingFilterHint->m_horChromaFilterIdc == 1)
-  {
-    seiChromaSamplingFilterHint->m_numHorizontalFilters = 1;
-    seiChromaSamplingFilterHint->m_horTapLengthMinus1 = (Int*)malloc(seiChromaSamplingFilterHint->m_numHorizontalFilters * sizeof(Int));
-    seiChromaSamplingFilterHint->m_horFilterCoeff = (Int**)malloc(seiChromaSamplingFilterHint->m_numHorizontalFilters * sizeof(Int*));
-    for(Int i = 0; i < seiChromaSamplingFilterHint->m_numHorizontalFilters; i ++)
-    {
-      seiChromaSamplingFilterHint->m_horTapLengthMinus1[i] = 0;
-      seiChromaSamplingFilterHint->m_horFilterCoeff[i] = (Int*)malloc(seiChromaSamplingFilterHint->m_horTapLengthMinus1[i] * sizeof(Int));
-      for(Int j = 0; j < seiChromaSamplingFilterHint->m_horTapLengthMinus1[i]; j ++)
-      {
-        seiChromaSamplingFilterHint->m_horFilterCoeff[i][j] = 0;
-      }
-    }
-  }
-  else
-  {
-    seiChromaSamplingFilterHint->m_numHorizontalFilters = 0;
-    seiChromaSamplingFilterHint->m_horTapLengthMinus1 = NULL;
-    seiChromaSamplingFilterHint->m_horFilterCoeff = NULL;
-  }
-  return seiChromaSamplingFilterHint;
-}
-
-Void TEncGOP::xCreateLeadingSEIMessages (/*SEIMessages seiMessages,*/ AccessUnit &accessUnit, const TComSPS *sps, const TComPPS *pps)
-{
-  OutputNALUnit nalu(NAL_UNIT_PREFIX_SEI);
-
-  if(m_pcCfg->getActiveParameterSetsSEIEnabled()
-#if R0247_SEI_ACTIVE
-    && m_layerId == 0
-#endif
-    )
-  {
-    SEIActiveParameterSets *sei = xCreateSEIActiveParameterSets (sps);
-
-    //nalu = NALUnit(NAL_UNIT_PREFIX_SEI);
-    m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
-#if O0164_MULTI_LAYER_HRD
-    m_seiWriter.writeSEImessage(nalu.m_Bitstream, *sei, m_pcEncTop->getVPS(), sps); 
-#else
-    m_seiWriter.writeSEImessage(nalu.m_Bitstream, *sei, sps); 
-#endif
-    writeRBSPTrailingBits(nalu.m_Bitstream);
-    accessUnit.push_back(new NALUnitEBSP(nalu));
-    delete sei;
+  if(m_pcCfg->getActiveParameterSetsSEIEnabled() && m_layerId == 0 )
+#else
+  if(m_pcCfg->getActiveParameterSetsSEIEnabled())
+#endif
+  {
+    SEIActiveParameterSets *sei = new SEIActiveParameterSets;
+    m_seiEncoder.initSEIActiveParameterSets (sei, m_pcCfg->getVPS(), sps);
+    seiMessages.push_back(sei);
     m_activeParameterSetSEIPresentInAU = true;
   }
@@ -516 +562 @@
   if(m_pcCfg->getFramePackingArrangementSEIEnabled())
   {
-    SEIFramePacking *sei = xCreateSEIFramePacking ();
-
-    nalu = NALUnit(NAL_UNIT_PREFIX_SEI);
-    m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
-#if O0164_MULTI_LAYER_HRD
-    m_seiWriter.writeSEImessage(nalu.m_Bitstream, *sei, m_pcEncTop->getVPS(), sps);
-#else
-    m_seiWriter.writeSEImessage(nalu.m_Bitstream, *sei, sps);
-#endif
-    writeRBSPTrailingBits(nalu.m_Bitstream);
-    accessUnit.push_back(new NALUnitEBSP(nalu));
-    delete sei;
-  }
+    SEIFramePacking *sei = new SEIFramePacking;
+    m_seiEncoder.initSEIFramePacking (sei, m_iNumPicCoded);
+    seiMessages.push_back(sei);
+  }
+
   if(m_pcCfg->getSegmentedRectFramePackingArrangementSEIEnabled())
   {
-    SEISegmentedRectFramePacking *sei = xCreateSEISegmentedRectFramePacking ();
-
-    nalu = NALUnit(NAL_UNIT_PREFIX_SEI);
-    m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
-#if O0164_MULTI_LAYER_HRD
-    m_seiWriter.writeSEImessage(nalu.m_Bitstream, *sei, m_pcEncTop->getVPS(), sps); 
-#else
-    m_seiWriter.writeSEImessage(nalu.m_Bitstream, *sei, sps); 
-#endif
-    writeRBSPTrailingBits(nalu.m_Bitstream);
-    accessUnit.push_back(new NALUnitEBSP(nalu));
-    delete sei;
-  }
+    SEISegmentedRectFramePacking *sei = new SEISegmentedRectFramePacking;
+    m_seiEncoder.initSEISegmentedRectFramePacking(sei);
+    seiMessages.push_back(sei);
+  }
+
   if (m_pcCfg->getDisplayOrientationSEIAngle())
   {
-    SEIDisplayOrientation *sei = xCreateSEIDisplayOrientation();
-
-    nalu = NALUnit(NAL_UNIT_PREFIX_SEI);
-    m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
-#if O0164_MULTI_LAYER_HRD
-    m_seiWriter.writeSEImessage(nalu.m_Bitstream, *sei, m_pcEncTop->getVPS(), sps); 
-#else
-    m_seiWriter.writeSEImessage(nalu.m_Bitstream, *sei, sps);
-#endif
-    writeRBSPTrailingBits(nalu.m_Bitstream);
-    accessUnit.push_back(new NALUnitEBSP(nalu));
-    delete sei;
+    SEIDisplayOrientation *sei = new SEIDisplayOrientation;
+    m_seiEncoder.initSEIDisplayOrientation(sei);
+    seiMessages.push_back(sei);
   }
 
   if(m_pcCfg->getToneMappingInfoSEIEnabled())
   {
-    SEIToneMappingInfo *sei = xCreateSEIToneMappingInfo ();
-
-    nalu = NALUnit(NAL_UNIT_PREFIX_SEI);
-    m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
-#if O0164_MULTI_LAYER_HRD
-    m_seiWriter.writeSEImessage(nalu.m_Bitstream, *sei, m_pcEncTop->getVPS(), sps);
-#else
-    m_seiWriter.writeSEImessage(nalu.m_Bitstream, *sei, sps);
-#endif
-    writeRBSPTrailingBits(nalu.m_Bitstream);
-    accessUnit.push_back(new NALUnitEBSP(nalu));
-    delete sei;
+    SEIToneMappingInfo *sei = new SEIToneMappingInfo;
+    m_seiEncoder.initSEIToneMappingInfo (sei);
+    seiMessages.push_back(sei);
   }
 
   if(m_pcCfg->getTMCTSSEIEnabled())
   {
-    SEITempMotionConstrainedTileSets *sei_tmcts = xCreateSEITempMotionConstrainedTileSets (pps);
-
-    nalu = NALUnit(NAL_UNIT_PREFIX_SEI);
-    m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
-#if O0164_MULTI_LAYER_HRD
-    m_seiWriter.writeSEImessage(nalu.m_Bitstream, *sei_tmcts, m_pcEncTop->getVPS(), sps);
-#else
-    m_seiWriter.writeSEImessage(nalu.m_Bitstream, *sei_tmcts, sps);
-#endif
-    writeRBSPTrailingBits(nalu.m_Bitstream);
-    accessUnit.push_back(new NALUnitEBSP(nalu));
-    delete sei_tmcts;
+    SEITempMotionConstrainedTileSets *sei = new SEITempMotionConstrainedTileSets;
+    m_seiEncoder.initSEITempMotionConstrainedTileSets(sei, pps);
+    seiMessages.push_back(sei);
   }
 
   if(m_pcCfg->getTimeCodeSEIEnabled())
   {
-    SEITimeCode sei_time_code;
-    //  Set data as per command line options
-    sei_time_code.numClockTs = m_pcCfg->getNumberOfTimesets();
-    for(Int i = 0; i < sei_time_code.numClockTs; i++)
-    {
-      sei_time_code.timeSetArray[i] = m_pcCfg->getTimeSet(i);
-    }
-
-    nalu = NALUnit(NAL_UNIT_PREFIX_SEI);
-    m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
-#if O0164_MULTI_LAYER_HRD
-    m_seiWriter.writeSEImessage(nalu.m_Bitstream, sei_time_code, m_pcEncTop->getVPS(), sps);
-#else
-    m_seiWriter.writeSEImessage(nalu.m_Bitstream, sei_time_code, sps);
-#endif
-    writeRBSPTrailingBits(nalu.m_Bitstream);
-    accessUnit.push_back(new NALUnitEBSP(nalu));
+    SEITimeCode *seiTimeCode = new SEITimeCode;
+    m_seiEncoder.initSEITimeCode(seiTimeCode);
+    seiMessages.push_back(seiTimeCode);
   }
 
   if(m_pcCfg->getKneeSEIEnabled())
   {
-    SEIKneeFunctionInfo *sei = xCreateSEIKneeFunctionInfo();
-
-    nalu = NALUnit(NAL_UNIT_PREFIX_SEI);
-    m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
-#if O0164_MULTI_LAYER_HRD
-    m_seiWriter.writeSEImessage(nalu.m_Bitstream, *sei, m_pcEncTop->getVPS(), sps);
-#else
-    m_seiWriter.writeSEImessage(nalu.m_Bitstream, *sei, sps);
-#endif
-    writeRBSPTrailingBits(nalu.m_Bitstream);
-    accessUnit.push_back(new NALUnitEBSP(nalu));
-    delete sei;
+    SEIKneeFunctionInfo *sei = new SEIKneeFunctionInfo;
+    m_seiEncoder.initSEIKneeFunctionInfo(sei);
+    seiMessages.push_back(sei);
   }
     
@@ -632 +612 @@
   {
     const TComSEIMasteringDisplay &seiCfg=m_pcCfg->getMasteringDisplaySEI();
-    SEIMasteringDisplayColourVolume mdcv;
-    mdcv.values = seiCfg;
-
-    nalu = NALUnit(NAL_UNIT_PREFIX_SEI);
-    m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
-#if O0164_MULTI_LAYER_HRD
-    m_seiWriter.writeSEImessage(nalu.m_Bitstream, mdcv, m_pcEncTop->getVPS(), sps);
-#else
-    m_seiWriter.writeSEImessage(nalu.m_Bitstream, mdcv, sps);
-#endif
-    writeRBSPTrailingBits(nalu.m_Bitstream);
-    accessUnit.push_back(new NALUnitEBSP(nalu));
-      
+    SEIMasteringDisplayColourVolume *sei = new SEIMasteringDisplayColourVolume;
+    sei->values = seiCfg;
+    seiMessages.push_back(sei);
   }
 
@@ -651 +621 @@
   if(m_pcCfg->getLayersNotPresentSEIEnabled())
   {
-    SEILayersNotPresent *sei = xCreateSEILayersNotPresent ();
-    m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
-#if O0164_MULTI_LAYER_HRD
-    m_seiWriter.writeSEImessage(nalu.m_Bitstream, *sei, m_pcEncTop->getVPS(), sps); 
-#else
-    m_seiWriter.writeSEImessage(nalu.m_Bitstream, *sei, sps); 
-#endif
-    writeRBSPTrailingBits(nalu.m_Bitstream);
-    accessUnit.push_back(new NALUnitEBSP(nalu));
-    delete sei;
+    SEILayersNotPresent *sei = new SEILayersNotPresent;
+    m_seiEncoder.initSEILayersNotPresent(sei);
+    seiMessages.push_back(sei);
   }
 #endif
@@ -667 +630 @@
   if(m_pcCfg->getInterLayerConstrainedTileSetsSEIEnabled())
   {
-    SEIInterLayerConstrainedTileSets *sei = xCreateSEIInterLayerConstrainedTileSets ();
-
-    nalu = NALUnit(NAL_UNIT_PREFIX_SEI, 0, m_pcCfg->getNumLayer()-1); // For highest layer
-    m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
-#if O0164_MULTI_LAYER_HRD
-    m_seiWriter.writeSEImessage(nalu.m_Bitstream, *sei, m_pcEncTop->getVPS(), sps); 
-#else
-    m_seiWriter.writeSEImessage(nalu.m_Bitstream, *sei, sps); 
-#endif
-    writeRBSPTrailingBits(nalu.m_Bitstream);
-    accessUnit.push_back(new NALUnitEBSP(nalu));
-    delete sei;
+    SEIInterLayerConstrainedTileSets *sei = new SEIInterLayerConstrainedTileSets;
+    m_seiEncoder.initSEIInterLayerConstrainedTileSets(sei);
+
+    // nalu = NALUnit(NAL_UNIT_PREFIX_SEI, 0, m_pcCfg->getNumLayer()-1); // For highest layer //ToDo(VS)
+    seiMessages.push_back(sei);
   }
 #endif
@@ -685 +641 @@
   if( m_pcCfg->getAlphaSEIEnabled() && m_pcEncTop->getVPS()->getScalabilityId(m_layerId, AUX_ID) && m_pcEncTop->getVPS()->getDimensionId(m_pcEncTop->getVPS()->getLayerIdxInVps(m_layerId), m_pcEncTop->getVPS()->getNumScalabilityTypes() - 1) == AUX_ALPHA )
   {
-    SEIAlphaChannelInfo *sei = xCreateSEIAlphaChannelInfo();
-    m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
-#if O0164_MULTI_LAYER_HRD
-    m_seiWriter.writeSEImessage(nalu.m_Bitstream, *sei, m_pcEncTop->getVPS(), sps);
-#else
-    m_seiWriter.writeSEImessage(nalu.m_Bitstream, *sei, sps);
-#endif
-    writeRBSPTrailingBits(nalu.m_Bitstream);
-    accessUnit.push_back(new NALUnitEBSP(nalu));
-    delete sei;
+    SEIAlphaChannelInfo *sei = new SEIAlphaChannelInfo;
+    m_seiEncoder.initSEIAlphaChannelInfo(sei);
+    seiMessages.push_back(sei);
   }
 #endif
@@ -700 +649 @@
 #if Q0096_OVERLAY_SEI
   if(m_pcCfg->getOverlaySEIEnabled())
-  {    
-    SEIOverlayInfo *sei = xCreateSEIOverlayInfo();       
+  {
+    SEIOverlayInfo *sei = new SEIOverlayInfo;
+    m_seiEncoder.initSEIOverlayInfo(sei);
     m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
+    seiMessages.push_back(sei);
+  }
+#endif
 #if O0164_MULTI_LAYER_HRD
-    m_seiWriter.writeSEImessage(nalu.m_Bitstream, *sei, m_pcEncTop->getVPS(), sps); 
-#else
-    m_seiWriter.writeSEImessage(nalu.m_Bitstream, *sei, sps); 
-#endif
-    writeRBSPTrailingBits(nalu.m_Bitstream);
-    accessUnit.push_back(new NALUnitEBSP(nalu));
-    delete sei;
+  if( m_layerId == 0 && m_pcEncTop->getVPS()->getVpsVuiBspHrdPresentFlag() )
+  {
+    TComVPS *vps = m_pcEncTop->getVPS();
+    for(Int i = 0; i < vps->getNumOutputLayerSets(); i++)
+    {
+      for(Int k = 0; k < vps->getNumSignalledPartitioningSchemes(i); k++)
+      {
+        for(Int l = 0; l < vps->getNumPartitionsInSchemeMinus1(i, k)+1; l++)
+        {
+          SEIScalableNesting *scalableBspNestingSei = new SEIScalableNesting;
+          m_seiEncoder.initBspNestingSEI(scalableBspNestingSei, vps, sps, i, k, l);
+          seiMessages.push_back(scalableBspNestingSei);
+        }
+      }
+    }
   }
 #endif
@@ -721 +682 @@
   for( Int c=0 ; c<3 ; c++)
   {
-    if ( m_colourRemapSEIPreLutCodedValue[c] != NULL)
-    {
-      delete[] m_colourRemapSEIPreLutCodedValue[c];
-      m_colourRemapSEIPreLutCodedValue[c] = NULL;
-    }
-    if ( m_colourRemapSEIPreLutTargetValue[c] != NULL)
-    {
-      delete[] m_colourRemapSEIPreLutTargetValue[c];
-      m_colourRemapSEIPreLutTargetValue[c] = NULL;
-    }
-    if ( m_colourRemapSEIPostLutCodedValue[c] != NULL)
-    {
-      delete[] m_colourRemapSEIPostLutCodedValue[c];
-      m_colourRemapSEIPostLutCodedValue[c] = NULL;
-    }
-    if ( m_colourRemapSEIPostLutTargetValue[c] != NULL)
-    {
-      delete[] m_colourRemapSEIPostLutTargetValue[c];
-      m_colourRemapSEIPostLutTargetValue[c] = NULL;
+    if ( m_seiColourRemappingInfo.m_colourRemapSEIPreLutCodedValue[c] != NULL)
+    {
+      delete[] m_seiColourRemappingInfo.m_colourRemapSEIPreLutCodedValue[c];
+      m_seiColourRemappingInfo.m_colourRemapSEIPreLutCodedValue[c] = NULL;
+    }
+    if ( m_seiColourRemappingInfo.m_colourRemapSEIPreLutTargetValue[c] != NULL)
+    {
+      delete[] m_seiColourRemappingInfo.m_colourRemapSEIPreLutTargetValue[c];
+      m_seiColourRemappingInfo.m_colourRemapSEIPreLutTargetValue[c] = NULL;
+    }
+    if ( m_seiColourRemappingInfo.m_colourRemapSEIPostLutCodedValue[c] != NULL)
+    {
+      delete[] m_seiColourRemappingInfo.m_colourRemapSEIPostLutCodedValue[c];
+      m_seiColourRemappingInfo.m_colourRemapSEIPostLutCodedValue[c] = NULL;
+    }
+    if ( m_seiColourRemappingInfo.m_colourRemapSEIPostLutTargetValue[c] != NULL)
+    {
+      delete[] m_seiColourRemappingInfo.m_colourRemapSEIPostLutTargetValue[c];
+      m_seiColourRemappingInfo.m_colourRemapSEIPostLutTargetValue[c] = NULL;
     }
   }
@@ -747 +708 @@
 
   // reading external Colour Remapping Information SEI message parameters from file
-  if( m_colourRemapSEIFile.c_str() )
+  if( m_seiColourRemappingInfo.m_colourRemapSEIFile.c_str() )
   {
     FILE* fic;
     Int retval;
-    if((fic = fopen(m_colourRemapSEIFile.c_str(),"r")) == (FILE*)NULL)
+    if((fic = fopen(m_seiColourRemappingInfo.m_colourRemapSEIFile.c_str(),"r")) == (FILE*)NULL)
     {
       //fprintf(stderr, "Can't open Colour Remapping Information SEI parameters file %s\n", m_colourRemapSEIFile.c_str());
@@ -758 +719 @@
     }
     Int tempCode;
-    retval = fscanf( fic, "%d", &m_colourRemapSEIId );
-    retval = fscanf( fic, "%d", &tempCode );m_colourRemapSEICancelFlag = tempCode ? 1 : 0;
-    if( !m_colourRemapSEICancelFlag )
-    {
-      retval = fscanf( fic, "%d", &tempCode ); m_colourRemapSEIPersistenceFlag= tempCode ? 1 : 0;
-      retval = fscanf( fic, "%d", &tempCode); m_colourRemapSEIVideoSignalInfoPresentFlag = tempCode ? 1 : 0;
-      if( m_colourRemapSEIVideoSignalInfoPresentFlag )
-      {
-        retval = fscanf( fic, "%d", &tempCode  ); m_colourRemapSEIFullRangeFlag = tempCode ? 1 : 0;
-        retval = fscanf( fic, "%d", &m_colourRemapSEIPrimaries );
-        retval = fscanf( fic, "%d", &m_colourRemapSEITransferFunction );
-        retval = fscanf( fic, "%d", &m_colourRemapSEIMatrixCoefficients );
-      }
-
-      retval = fscanf( fic, "%d", &m_colourRemapSEIInputBitDepth );
-      retval = fscanf( fic, "%d", &m_colourRemapSEIBitDepth );
+    retval = fscanf( fic, "%d", &m_seiColourRemappingInfo.m_colourRemapSEIId );
+    retval = fscanf( fic, "%d", &tempCode ); m_seiColourRemappingInfo.m_colourRemapSEICancelFlag = tempCode ? 1 : 0;
+    if( !m_seiColourRemappingInfo.m_colourRemapSEICancelFlag )
+    {
+      retval = fscanf( fic, "%d", &tempCode ); m_seiColourRemappingInfo.m_colourRemapSEIPersistenceFlag= tempCode ? 1 : 0;
+      retval = fscanf( fic, "%d", &tempCode); m_seiColourRemappingInfo.m_colourRemapSEIVideoSignalInfoPresentFlag = tempCode ? 1 : 0;
+      if( m_seiColourRemappingInfo.m_colourRemapSEIVideoSignalInfoPresentFlag )
+      {
+        retval = fscanf( fic, "%d", &tempCode  ); m_seiColourRemappingInfo.m_colourRemapSEIFullRangeFlag = tempCode ? 1 : 0;
+        retval = fscanf( fic, "%d", &m_seiColourRemappingInfo.m_colourRemapSEIPrimaries );
+        retval = fscanf( fic, "%d", &m_seiColourRemappingInfo.m_colourRemapSEITransferFunction );
+        retval = fscanf( fic, "%d", &m_seiColourRemappingInfo.m_colourRemapSEIMatrixCoefficients );
+      }
+
+      retval = fscanf( fic, "%d", &m_seiColourRemappingInfo.m_colourRemapSEIInputBitDepth );
+      retval = fscanf( fic, "%d", &m_seiColourRemappingInfo.m_colourRemapSEIBitDepth );
   
       for( Int c=0 ; c<3 ; c++ )
       {
-        retval = fscanf( fic, "%d", &m_colourRemapSEIPreLutNumValMinus1[c] );
-        if( m_colourRemapSEIPreLutNumValMinus1[c]>0 )
-        {
-          m_colourRemapSEIPreLutCodedValue[c]  = new Int[m_colourRemapSEIPreLutNumValMinus1[c]+1];
-          m_colourRemapSEIPreLutTargetValue[c] = new Int[m_colourRemapSEIPreLutNumValMinus1[c]+1];
-          for( Int i=0 ; i<=m_colourRemapSEIPreLutNumValMinus1[c] ; i++ )
+        retval = fscanf( fic, "%d", &m_seiColourRemappingInfo.m_colourRemapSEIPreLutNumValMinus1[c] );
+        if( m_seiColourRemappingInfo.m_colourRemapSEIPreLutNumValMinus1[c]>0 )
+        {
+          m_seiColourRemappingInfo.m_colourRemapSEIPreLutCodedValue[c]  = new Int[m_seiColourRemappingInfo.m_colourRemapSEIPreLutNumValMinus1[c]+1];
+          m_seiColourRemappingInfo.m_colourRemapSEIPreLutTargetValue[c] = new Int[m_seiColourRemappingInfo.m_colourRemapSEIPreLutNumValMinus1[c]+1];
+          for( Int i=0 ; i<=m_seiColourRemappingInfo.m_colourRemapSEIPreLutNumValMinus1[c] ; i++ )
           {
-            retval = fscanf( fic, "%d", &m_colourRemapSEIPreLutCodedValue[c][i] );
-            retval = fscanf( fic, "%d", &m_colourRemapSEIPreLutTargetValue[c][i] );
-          }
-        }
-      }
-
-      retval = fscanf( fic, "%d", &tempCode ); m_colourRemapSEIMatrixPresentFlag = tempCode ? 1 : 0;
-      if( m_colourRemapSEIMatrixPresentFlag )
-      {
-        retval = fscanf( fic, "%d", &m_colourRemapSEILog2MatrixDenom );
+            retval = fscanf( fic, "%d", &m_seiColourRemappingInfo.m_colourRemapSEIPreLutCodedValue[c][i] );
+            retval = fscanf( fic, "%d", &m_seiColourRemappingInfo.m_colourRemapSEIPreLutTargetValue[c][i] );
+          }
+        }
+      }
+
+      retval = fscanf( fic, "%d", &tempCode ); m_seiColourRemappingInfo.m_colourRemapSEIMatrixPresentFlag = tempCode ? 1 : 0;
+      if( m_seiColourRemappingInfo.m_colourRemapSEIMatrixPresentFlag )
+      {
+        retval = fscanf( fic, "%d", &m_seiColourRemappingInfo.m_colourRemapSEILog2MatrixDenom );
         for( Int c=0 ; c<3 ; c++ )
+        {
           for( Int i=0 ; i<3 ; i++ )
-            retval = fscanf( fic, "%d", &m_colourRemapSEICoeffs[c][i] );
+          {
+            retval = fscanf( fic, "%d", &m_seiColourRemappingInfo.m_colourRemapSEICoeffs[c][i] );
+          }
+        }
       }
 
       for( Int c=0 ; c<3 ; c++ )
       {
-        retval = fscanf( fic, "%d", &m_colourRemapSEIPostLutNumValMinus1[c] );
-        if( m_colourRemapSEIPostLutNumValMinus1[c]>0 )
-        {
-          m_colourRemapSEIPostLutCodedValue[c]  = new Int[m_colourRemapSEIPostLutNumValMinus1[c]+1];
-          m_colourRemapSEIPostLutTargetValue[c] = new Int[m_colourRemapSEIPostLutNumValMinus1[c]+1];
-          for( Int i=0 ; i<=m_colourRemapSEIPostLutNumValMinus1[c] ; i++ )
+        retval = fscanf( fic, "%d", &m_seiColourRemappingInfo.m_colourRemapSEIPostLutNumValMinus1[c] );
+        if( m_seiColourRemappingInfo.m_colourRemapSEIPostLutNumValMinus1[c]>0 )
+        {
+          m_seiColourRemappingInfo.m_colourRemapSEIPostLutCodedValue[c]  = new Int[m_seiColourRemappingInfo.m_colourRemapSEIPostLutNumValMinus1[c]+1];
+          m_seiColourRemappingInfo.m_colourRemapSEIPostLutTargetValue[c] = new Int[m_seiColourRemappingInfo.m_colourRemapSEIPostLutNumValMinus1[c]+1];
+          for( Int i=0 ; i<= m_seiColourRemappingInfo.m_colourRemapSEIPostLutNumValMinus1[c] ; i++ )
           {
-            retval = fscanf( fic, "%d", &m_colourRemapSEIPostLutCodedValue[c][i] );
-            retval = fscanf( fic, "%d", &m_colourRemapSEIPostLutTargetValue[c][i] );
+            retval = fscanf( fic, "%d", &m_seiColourRemappingInfo.m_colourRemapSEIPostLutCodedValue[c][i] );
+            retval = fscanf( fic, "%d", &m_seiColourRemappingInfo.m_colourRemapSEIPostLutTargetValue[c][i] );
           }
         }
@@ -834 +799 @@
 #define xConfirmParameter(a,b) check_failed |= confirmParameter(a,b)
 
-  if ( m_colourRemapSEIFile.c_str() && !m_colourRemapSEICancelFlag )
-  {
-    xConfirmParameter( m_colourRemapSEIInputBitDepth < 8 || m_colourRemapSEIInputBitDepth > 16 , "colour_remap_coded_data_bit_depth shall be in the range of 8 to 16, inclusive");
-    xConfirmParameter( m_colourRemapSEIBitDepth < 8 || (m_colourRemapSEIBitDepth > 16 && m_colourRemapSEIBitDepth < 255) , "colour_remap_target_bit_depth shall be in the range of 8 to 16, inclusive");
+  if ( m_seiColourRemappingInfo.m_colourRemapSEIFile.c_str() && !m_seiColourRemappingInfo.m_colourRemapSEICancelFlag )
+  {
+    xConfirmParameter( m_seiColourRemappingInfo.m_colourRemapSEIInputBitDepth < 8 || m_seiColourRemappingInfo.m_colourRemapSEIInputBitDepth > 16 , "colour_remap_coded_data_bit_depth shall be in the range of 8 to 16, inclusive");
+    xConfirmParameter( m_seiColourRemappingInfo.m_colourRemapSEIBitDepth < 8 || (m_seiColourRemappingInfo.m_colourRemapSEIBitDepth > 16 && m_seiColourRemappingInfo.m_colourRemapSEIBitDepth < 255) , "colour_remap_target_bit_depth shall be in the range of 8 to 16, inclusive");
     for( Int c=0 ; c<3 ; c++)
     {
-      xConfirmParameter( m_colourRemapSEIPreLutNumValMinus1[c] < 0 || m_colourRemapSEIPreLutNumValMinus1[c] > 32, "pre_lut_num_val_minus1[c] shall be in the range of 0 to 32, inclusive");
-      if( m_colourRemapSEIPreLutNumValMinus1[c]>0 )
-        for( Int i=0 ; i<=m_colourRemapSEIPreLutNumValMinus1[c] ; i++)
-        {
-          xConfirmParameter( m_colourRemapSEIPreLutCodedValue[c][i] < 0 || m_colourRemapSEIPreLutCodedValue[c][i] > ((1<<m_colourRemapSEIInputBitDepth)-1), "pre_lut_coded_value[c][i] shall be in the range of 0 to (1<<colour_remap_coded_data_bit_depth)-1, inclusive");
-          xConfirmParameter( m_colourRemapSEIPreLutTargetValue[c][i] < 0 || m_colourRemapSEIPreLutTargetValue[c][i] > ((1<<m_colourRemapSEIBitDepth)-1), "pre_lut_target_value[c][i] shall be in the range of 0 to (1<<colour_remap_target_bit_depth)-1, inclusive");
-        }
-      xConfirmParameter( m_colourRemapSEIPostLutNumValMinus1[c] < 0 || m_colourRemapSEIPostLutNumValMinus1[c] > 32, "post_lut_num_val_minus1[c] shall be in the range of 0 to 32, inclusive");
-      if( m_colourRemapSEIPostLutNumValMinus1[c]>0 )
-        for( Int i=0 ; i<=m_colourRemapSEIPostLutNumValMinus1[c] ; i++)
-        {
-          xConfirmParameter( m_colourRemapSEIPostLutCodedValue[c][i] < 0 || m_colourRemapSEIPostLutCodedValue[c][i] > ((1<<m_colourRemapSEIBitDepth)-1), "post_lut_coded_value[c][i] shall be in the range of 0 to (1<<colour_remap_target_bit_depth)-1, inclusive");
-          xConfirmParameter( m_colourRemapSEIPostLutTargetValue[c][i] < 0 || m_colourRemapSEIPostLutTargetValue[c][i] > ((1<<m_colourRemapSEIBitDepth)-1), "post_lut_target_value[c][i] shall be in the range of 0 to (1<<colour_remap_target_bit_depth)-1, inclusive");
-        }
-    }
-    if ( m_colourRemapSEIMatrixPresentFlag )
-    {
-      xConfirmParameter( m_colourRemapSEILog2MatrixDenom < 0 || m_colourRemapSEILog2MatrixDenom > 15, "log2_matrix_denom shall be in the range of 0 to 15, inclusive");
+      xConfirmParameter( m_seiColourRemappingInfo.m_colourRemapSEIPreLutNumValMinus1[c] < 0 || m_seiColourRemappingInfo.m_colourRemapSEIPreLutNumValMinus1[c] > 32, "pre_lut_num_val_minus1[c] shall be in the range of 0 to 32, inclusive");
+      if( m_seiColourRemappingInfo.m_colourRemapSEIPreLutNumValMinus1[c]>0 )
+        for( Int i=0 ; i<= m_seiColourRemappingInfo.m_colourRemapSEIPreLutNumValMinus1[c] ; i++)
+        {
+          xConfirmParameter( m_seiColourRemappingInfo.m_colourRemapSEIPreLutCodedValue[c][i] < 0 || m_seiColourRemappingInfo.m_colourRemapSEIPreLutCodedValue[c][i] > ((1<<m_seiColourRemappingInfo.m_colourRemapSEIInputBitDepth)-1), "pre_lut_coded_value[c][i] shall be in the range of 0 to (1<<colour_remap_coded_data_bit_depth)-1, inclusive");
+          xConfirmParameter( m_seiColourRemappingInfo.m_colourRemapSEIPreLutTargetValue[c][i] < 0 || m_seiColourRemappingInfo.m_colourRemapSEIPreLutTargetValue[c][i] > ((1<<m_seiColourRemappingInfo.m_colourRemapSEIBitDepth)-1), "pre_lut_target_value[c][i] shall be in the range of 0 to (1<<colour_remap_target_bit_depth)-1, inclusive");
+        }
+      xConfirmParameter( m_seiColourRemappingInfo.m_colourRemapSEIPostLutNumValMinus1[c] < 0 || m_seiColourRemappingInfo.m_colourRemapSEIPostLutNumValMinus1[c] > 32, "post_lut_num_val_minus1[c] shall be in the range of 0 to 32, inclusive");
+      if( m_seiColourRemappingInfo.m_colourRemapSEIPostLutNumValMinus1[c]>0 )
+        for( Int i=0 ; i<= m_seiColourRemappingInfo.m_colourRemapSEIPostLutNumValMinus1[c] ; i++)
+        {
+          xConfirmParameter( m_seiColourRemappingInfo.m_colourRemapSEIPostLutCodedValue[c][i] < 0 || m_seiColourRemappingInfo.m_colourRemapSEIPostLutCodedValue[c][i] > ((1<<m_seiColourRemappingInfo.m_colourRemapSEIBitDepth)-1), "post_lut_coded_value[c][i] shall be in the range of 0 to (1<<colour_remap_target_bit_depth)-1, inclusive");
+          xConfirmParameter( m_seiColourRemappingInfo.m_colourRemapSEIPostLutTargetValue[c][i] < 0 || m_seiColourRemappingInfo.m_colourRemapSEIPostLutTargetValue[c][i] > ((1<<m_seiColourRemappingInfo.m_colourRemapSEIBitDepth)-1), "post_lut_target_value[c][i] shall be in the range of 0 to (1<<colour_remap_target_bit_depth)-1, inclusive");
+        }
+    }
+    if ( m_seiColourRemappingInfo.m_colourRemapSEIMatrixPresentFlag )
+    {
+      xConfirmParameter( m_seiColourRemappingInfo.m_colourRemapSEILog2MatrixDenom < 0 || m_seiColourRemappingInfo.m_colourRemapSEILog2MatrixDenom > 15, "log2_matrix_denom shall be in the range of 0 to 15, inclusive");
       for( Int c=0 ; c<3 ; c++)
         for( Int i=0 ; i<3 ; i++)
-          xConfirmParameter( m_colourRemapSEICoeffs[c][i] < -32768 || m_colourRemapSEICoeffs[c][i] > 32767, "colour_remap_coeffs[c][i] shall be in the range of -32768 and 32767, inclusive");
-    }
-  }
-}
-#endif
+          xConfirmParameter( m_seiColourRemappingInfo.m_colourRemapSEICoeffs[c][i] < -32768 || m_seiColourRemappingInfo.m_colourRemapSEICoeffs[c][i] > 32767, "colour_remap_coeffs[c][i] shall be in the range of -32768 and 32767, inclusive");
+    }
+  }
+}
+#endif
+
+Void TEncGOP::xCreatePerPictureSEIMessages (Int picInGOP, SEIMessages& seiMessages, SEIMessages& nestedSeiMessages, TComSlice *slice)
+{
+  if( ( m_pcCfg->getBufferingPeriodSEIEnabled() ) && ( slice->getSliceType() == I_SLICE ) &&
+    ( slice->getSPS()->getVuiParametersPresentFlag() ) &&
+    ( ( slice->getSPS()->getVuiParameters()->getHrdParameters()->getNalHrdParametersPresentFlag() )
+    || ( slice->getSPS()->getVuiParameters()->getHrdParameters()->getVclHrdParametersPresentFlag() ) ) )
+  {
+    SEIBufferingPeriod *bufferingPeriodSEI = new SEIBufferingPeriod();
+    m_seiEncoder.initSEIBufferingPeriod(bufferingPeriodSEI, slice);
+    seiMessages.push_back(bufferingPeriodSEI);
+    m_bufferingPeriodSEIPresentInAU = true;
+
+    if (m_pcCfg->getScalableNestingSEIEnabled())
+    {
+      SEIBufferingPeriod *bufferingPeriodSEIcopy = new SEIBufferingPeriod();
+      bufferingPeriodSEI->copyTo(*bufferingPeriodSEIcopy);
+      nestedSeiMessages.push_back(bufferingPeriodSEIcopy);
+    }
+  }
+
+  if (picInGOP ==0 && m_pcCfg->getSOPDescriptionSEIEnabled() ) // write SOP description SEI (if enabled) at the beginning of GOP
+  {
+    SEISOPDescription* sopDescriptionSEI = new SEISOPDescription();
+    m_seiEncoder.initSEISOPDescription(sopDescriptionSEI, slice, picInGOP, m_iLastIDR, m_iGopSize);
+    seiMessages.push_back(sopDescriptionSEI);
+  }
+
+  if( ( m_pcEncTop->getRecoveryPointSEIEnabled() ) && ( slice->getSliceType() == I_SLICE ) )
+  {
+    if( m_pcEncTop->getGradualDecodingRefreshInfoEnabled() && !slice->getRapPicFlag() )
+    {
+      // Gradual decoding refresh SEI
+      SEIGradualDecodingRefreshInfo *gradualDecodingRefreshInfoSEI = new SEIGradualDecodingRefreshInfo();
+      gradualDecodingRefreshInfoSEI->m_gdrForegroundFlag = true; // Indicating all "foreground"
+      seiMessages.push_back(gradualDecodingRefreshInfoSEI);
+    }
+    // Recovery point SEI
+    SEIRecoveryPoint *recoveryPointSEI = new SEIRecoveryPoint();
+    m_seiEncoder.initSEIRecoveryPoint(recoveryPointSEI, slice);
+    seiMessages.push_back(recoveryPointSEI);
+
+#if ALLOW_RECOVERY_POINT_AS_RAP
+    if(m_pcCfg->getDecodingRefreshType() == 3)
+    {
+      m_iLastRecoveryPicPOC = slice->getPOC();
+    }
+#endif
+  }
+  if (m_pcCfg->getTemporalLevel0IndexSEIEnabled())
+  {
+    SEITemporalLevel0Index *temporalLevel0IndexSEI = new SEITemporalLevel0Index();
+    m_seiEncoder.initTemporalLevel0IndexSEI(temporalLevel0IndexSEI, slice);
+    seiMessages.push_back(temporalLevel0IndexSEI);
+  }
+
+  if(slice->getSPS()->getVuiParametersPresentFlag() && m_pcCfg->getChromaSamplingFilterHintEnabled() && ( slice->getSliceType() == I_SLICE ))
+  {
+    SEIChromaSamplingFilterHint *seiChromaSamplingFilterHint = new SEIChromaSamplingFilterHint;
+    m_seiEncoder.initSEIChromaSamplingFilterHint(seiChromaSamplingFilterHint, m_pcCfg->getChromaLocInfoPresentFlag(), m_pcCfg->getChromaSamplingHorFilterIdc(), m_pcCfg->getChromaSamplingVerFilterIdc());
+    seiMessages.push_back(seiChromaSamplingFilterHint);
+  }
+
+  if( m_pcEncTop->getNoDisplaySEITLayer() && ( slice->getTLayer() >= m_pcEncTop->getNoDisplaySEITLayer() ) )
+  {
+    SEINoDisplay *seiNoDisplay = new SEINoDisplay;
+    seiNoDisplay->m_noDisplay = true;
+    seiMessages.push_back(seiNoDisplay);
+  }
+
+#if Q0189_TMVP_CONSTRAINTS
+  if( m_pcEncTop->getTMVPConstraintsSEIEnabled() == 1 && (m_pcEncTop->getTMVPModeId() == 1 || m_pcEncTop->getTMVPModeId() == 2) &&
+    slice->getLayerId() > 0 && (slice->getNalUnitType() ==  NAL_UNIT_CODED_SLICE_IDR_W_RADL || slice->getNalUnitType() ==  NAL_UNIT_CODED_SLICE_IDR_N_LP))
+  {
+    SEITMVPConstrains *seiTMVPConstrains = new SEITMVPConstrains;
+    seiTMVPConstrains->no_intra_layer_col_pic_flag = 1;
+    seiTMVPConstrains->prev_pics_not_used_flag = 1;
+    seiMessages.push_back(seiTMVPConstrains);
+  }
+#endif
+#if Q0247_FRAME_FIELD_INFO
+  if( slice->getLayerId()> 0 && ( (m_pcCfg->getProgressiveSourceFlag() && m_pcCfg->getInterlacedSourceFlag()) || m_pcCfg->getFrameFieldInfoPresentFlag()))
+  {
+    Bool isField = slice->getPic()->isField();
+    SEIFrameFieldInfo *seiFFInfo = new SEIFrameFieldInfo;
+    seiFFInfo->m_ffinfo_picStruct = (isField && slice->getPic()->isTopField())? 1 : isField? 2 : 0;
+    seiMessages.push_back(seiFFInfo);
+  }
+#endif
+#if Q0074_COLOUR_REMAPPING_SEI
+    // insert one CRI by picture (if the file exist)   
+    freeColourCRI();
+
+    // building the CRI file name with poc num in suffix "_poc.txt"
+    char suffix[10];
+    sprintf(suffix, "_%d.txt",  slice->getPOC());
+    string  colourRemapSEIFileWithPoc(m_pcCfg->getCRISEIFileRoot());
+    colourRemapSEIFileWithPoc.append(suffix);
+    setCRISEIFile( const_cast<Char*>(colourRemapSEIFileWithPoc.c_str()) );
+  
+    Int ret = readingCRIparameters();
+
+    if(ret != -1 && m_pcCfg->getCRISEIFileRoot())
+    {
+      // check validity of input parameters
+      xCheckParameter();
+
+      SEIColourRemappingInfo *seiColourRemappingInfo = new SEIColourRemappingInfo;
+      m_seiEncoder.initSEIColourRemappingInfo(seiColourRemappingInfo, &m_seiColourRemappingInfo);
+      seiMessages.push_back(seiColourRemappingInfo);
+    }
+#endif
+}
+
+Void TEncGOP::xCreateScalableNestingSEI (SEIMessages& seiMessages, SEIMessages& nestedSeiMessages)
+{
+  SEIMessages tmpMessages;
+  while (!nestedSeiMessages.empty())
+  {
+    SEI* sei=nestedSeiMessages.front();
+    nestedSeiMessages.pop_front();
+    tmpMessages.push_back(sei);
+    SEIScalableNesting *nestingSEI = new SEIScalableNesting();
+    m_seiEncoder.initSEIScalableNesting(nestingSEI, tmpMessages);
+    seiMessages.push_back(nestingSEI);
+    tmpMessages.clear();
+  }
+}
+
+Void TEncGOP::xCreatePictureTimingSEI  (Int IRAPGOPid, SEIMessages& seiMessages, SEIMessages& nestedSeiMessages, SEIMessages& duInfoSeiMessages, AccessUnit &accessUnit, TComSlice *slice, Bool isField, std::deque<DUData> &duData)
+{
+  Int picSptDpbOutputDuDelay = 0;
+  SEIPictureTiming *pictureTimingSEI = new SEIPictureTiming();
+
+  const TComVUI *vui = slice->getSPS()->getVuiParameters();
+  const TComHRD *hrd = vui->getHrdParameters();
+
+  // update decoding unit parameters
+  if( ( m_pcCfg->getPictureTimingSEIEnabled() || m_pcCfg->getDecodingUnitInfoSEIEnabled() ) &&
+    ( slice->getSPS()->getVuiParametersPresentFlag() ) &&
+    (  hrd->getNalHrdParametersPresentFlag() || hrd->getVclHrdParametersPresentFlag() ) )
+  {
+    // DU parameters
+    if( hrd->getSubPicCpbParamsPresentFlag() )
+    {
+      UInt numDU = (UInt) duData.size();
+      pictureTimingSEI->m_numDecodingUnitsMinus1     = ( numDU - 1 );
+      pictureTimingSEI->m_duCommonCpbRemovalDelayFlag = false;
+      pictureTimingSEI->m_numNalusInDuMinus1.resize( numDU );
+      pictureTimingSEI->m_duCpbRemovalDelayMinus1.resize( numDU );
+    }
+    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 .
+    pictureTimingSEI->m_picDpbOutputDelay = slice->getSPS()->getNumReorderPics(slice->getSPS()->getMaxTLayers()-1) + slice->getPOC() - m_totalCoded;
+#if EFFICIENT_FIELD_IRAP
+    if(IRAPGOPid > 0 && IRAPGOPid < m_iGopSize)
+    {
+      // if pictures have been swapped there is likely one more picture delay on their tid. Very rough approximation
+      pictureTimingSEI->m_picDpbOutputDelay ++;
+    }
+#endif
+    Int factor = hrd->getTickDivisorMinus2() + 2;
+    pictureTimingSEI->m_picDpbOutputDuDelay = factor * pictureTimingSEI->m_picDpbOutputDelay;
+    if( m_pcCfg->getDecodingUnitInfoSEIEnabled() )
+    {
+      picSptDpbOutputDuDelay = factor * pictureTimingSEI->m_picDpbOutputDelay;
+    }
+    if (m_bufferingPeriodSEIPresentInAU)
+    {
+      m_lastBPSEI = m_totalCoded;
+    }
+
+    if( hrd->getSubPicCpbParamsPresentFlag() )
+    {
+      Int i;
+      UInt64 ui64Tmp;
+      UInt uiPrev = 0;
+      UInt numDU = ( pictureTimingSEI->m_numDecodingUnitsMinus1 + 1 );
+      std::vector<UInt> &rDuCpbRemovalDelayMinus1 = pictureTimingSEI->m_duCpbRemovalDelayMinus1;
+      UInt maxDiff = ( hrd->getTickDivisorMinus2() + 2 ) - 1;
+
+      for( i = 0; i < numDU; i ++ )
+      {
+        pictureTimingSEI->m_numNalusInDuMinus1[ i ]       = ( i == 0 ) ? ( duData[i].accumNalsDU - 1 ) : ( duData[i].accumNalsDU- duData[i-1].accumNalsDU - 1 );
+      }
+
+      if( numDU == 1 )
+      {
+        rDuCpbRemovalDelayMinus1[ 0 ] = 0; /* don't care */
+      }
+      else
+      {
+        rDuCpbRemovalDelayMinus1[ numDU - 1 ] = 0;/* by definition */
+        UInt tmp = 0;
+        UInt accum = 0;
+
+        for( i = ( numDU - 2 ); i >= 0; i -- )
+        {
+          ui64Tmp = ( ( ( duData[numDU - 1].accumBitsDU  - duData[i].accumBitsDU ) * ( vui->getTimingInfo()->getTimeScale() / vui->getTimingInfo()->getNumUnitsInTick() ) * ( hrd->getTickDivisorMinus2() + 2 ) ) / ( m_pcCfg->getTargetBitrate() ) );
+          if( (UInt)ui64Tmp > maxDiff )
+          {
+            tmp ++;
+          }
+        }
+        uiPrev = 0;
+
+        UInt flag = 0;
+        for( i = ( numDU - 2 ); i >= 0; i -- )
+        {
+          flag = 0;
+          ui64Tmp = ( ( ( duData[numDU - 1].accumBitsDU  - duData[i].accumBitsDU ) * ( vui->getTimingInfo()->getTimeScale() / vui->getTimingInfo()->getNumUnitsInTick() ) * ( hrd->getTickDivisorMinus2() + 2 ) ) / ( m_pcCfg->getTargetBitrate() ) );
+
+          if( (UInt)ui64Tmp > maxDiff )
+          {
+            if(uiPrev >= maxDiff - tmp)
+            {
+              ui64Tmp = uiPrev + 1;
+              flag = 1;
+            }
+            else                            ui64Tmp = maxDiff - tmp + 1;
+          }
+          rDuCpbRemovalDelayMinus1[ i ] = (UInt)ui64Tmp - uiPrev - 1;
+          if( (Int)rDuCpbRemovalDelayMinus1[ i ] < 0 )
+          {
+            rDuCpbRemovalDelayMinus1[ i ] = 0;
+          }
+          else if (tmp > 0 && flag == 1)
+          {
+            tmp --;
+          }
+          accum += rDuCpbRemovalDelayMinus1[ i ] + 1;
+          uiPrev = accum;
+        }
+      }
+    }
+    
+    if( m_pcCfg->getPictureTimingSEIEnabled() )
+    {
+      pictureTimingSEI->m_picStruct = (isField && slice->getPic()->isTopField())? 1 : isField? 2 : 0;
+      seiMessages.push_back(pictureTimingSEI);
+      m_pictureTimingSEIPresentInAU = true;
+
+      if ( m_pcCfg->getScalableNestingSEIEnabled() ) // put picture timing SEI into scalable nesting SEI
+      {
+        if (m_pcCfg->getScalableNestingSEIEnabled())
+        {
+          SEIPictureTiming *pictureTimingSEIcopy = new SEIPictureTiming();
+          pictureTimingSEI->copyTo(*pictureTimingSEIcopy);
+          nestedSeiMessages.push_back(pictureTimingSEIcopy);
+        }
+        m_nestedPictureTimingSEIPresentInAU = true;
+      }
+    }
+
+    if( m_pcCfg->getDecodingUnitInfoSEIEnabled() && hrd->getSubPicCpbParamsPresentFlag() )
+    {
+      for( Int i = 0; i < ( pictureTimingSEI->m_numDecodingUnitsMinus1 + 1 ); i ++ )
+      {
+        SEIDecodingUnitInfo *duInfoSEI = new SEIDecodingUnitInfo();
+        duInfoSEI->m_decodingUnitIdx = i;
+        duInfoSEI->m_duSptCpbRemovalDelay = pictureTimingSEI->m_duCpbRemovalDelayMinus1[i] + 1;
+        duInfoSEI->m_dpbOutputDuDelayPresentFlag = false;
+        duInfoSEI->m_picSptDpbOutputDuDelay = picSptDpbOutputDuDelay;
+
+        duInfoSeiMessages.push_back(duInfoSEI);
+      }
+    }
+  }
+}
+
+Void TEncGOP::xUpdateDuData(AccessUnit &testAU, std::deque<DUData> &duData)
+{
+  if (duData.empty())
+  {
+    return;
+  }
+  // fix first 
+  UInt numNalUnits = (UInt)testAU.size();
+  UInt numRBSPBytes = 0;
+  for (AccessUnit::const_iterator it = testAU.begin(); it != testAU.end(); it++)
+  {
+    numRBSPBytes += UInt((*it)->m_nalUnitData.str().size());
+  }
+  duData[0].accumBitsDU += ( numRBSPBytes << 3 );
+  duData[0].accumNalsDU += numNalUnits;
+
+  // adapt cumulative sums for all following DUs
+  // and add one DU info SEI, if enabled
+  for (Int i=1; i<duData.size(); i++)
+  {
+    if (m_pcCfg->getDecodingUnitInfoSEIEnabled())
+    {
+      numNalUnits  += 1;
+      numRBSPBytes += ( 5 << 3 );
+    }
+    duData[i].accumBitsDU += numRBSPBytes; // probably around 5 bytes
+    duData[i].accumNalsDU += numNalUnits;
+  }
+
+  // The last DU may have a trailing SEI
+  if (m_pcCfg->getDecodedPictureHashSEIEnabled())
+  {
+    duData.back().accumBitsDU += ( 20 << 3 ); // probably around 20 bytes - should be further adjusted, e.g. by type
+    duData.back().accumNalsDU += 1;
+  }
+
+}
+Void TEncGOP::xUpdateTimingSEI(SEIPictureTiming *pictureTimingSEI, std::deque<DUData> &duData, const TComSPS *sps)
+{
+  if (!pictureTimingSEI)
+  {
+    return;
+  }
+  const TComVUI *vui = sps->getVuiParameters();
+  const TComHRD *hrd = vui->getHrdParameters();
+  if( hrd->getSubPicCpbParamsPresentFlag() )
+  {
+    Int i;
+    UInt64 ui64Tmp;
+    UInt uiPrev = 0;
+    UInt numDU = ( pictureTimingSEI->m_numDecodingUnitsMinus1 + 1 );
+    std::vector<UInt> &rDuCpbRemovalDelayMinus1 = pictureTimingSEI->m_duCpbRemovalDelayMinus1;
+    UInt maxDiff = ( hrd->getTickDivisorMinus2() + 2 ) - 1;
+
+    for( i = 0; i < numDU; i ++ )
+    {
+      pictureTimingSEI->m_numNalusInDuMinus1[ i ]       = ( i == 0 ) ? ( duData[i].accumNalsDU - 1 ) : ( duData[i].accumNalsDU- duData[i-1].accumNalsDU - 1 );
+    }
+
+    if( numDU == 1 )
+    {
+      rDuCpbRemovalDelayMinus1[ 0 ] = 0; /* don't care */
+    }
+    else
+    {
+      rDuCpbRemovalDelayMinus1[ numDU - 1 ] = 0;/* by definition */
+      UInt tmp = 0;
+      UInt accum = 0;
+
+      for( i = ( numDU - 2 ); i >= 0; i -- )
+      {
+        ui64Tmp = ( ( ( duData[numDU - 1].accumBitsDU  - duData[i].accumBitsDU ) * ( vui->getTimingInfo()->getTimeScale() / vui->getTimingInfo()->getNumUnitsInTick() ) * ( hrd->getTickDivisorMinus2() + 2 ) ) / ( m_pcCfg->getTargetBitrate() ) );
+        if( (UInt)ui64Tmp > maxDiff )
+        {
+          tmp ++;
+        }
+      }
+      uiPrev = 0;
+
+      UInt flag = 0;
+      for( i = ( numDU - 2 ); i >= 0; i -- )
+      {
+        flag = 0;
+        ui64Tmp = ( ( ( duData[numDU - 1].accumBitsDU  - duData[i].accumBitsDU ) * ( vui->getTimingInfo()->getTimeScale() / vui->getTimingInfo()->getNumUnitsInTick() ) * ( hrd->getTickDivisorMinus2() + 2 ) ) / ( m_pcCfg->getTargetBitrate() ) );
+
+        if( (UInt)ui64Tmp > maxDiff )
+        {
+          if(uiPrev >= maxDiff - tmp)
+          {
+            ui64Tmp = uiPrev + 1;
+            flag = 1;
+          }
+          else                            ui64Tmp = maxDiff - tmp + 1;
+        }
+        rDuCpbRemovalDelayMinus1[ i ] = (UInt)ui64Tmp - uiPrev - 1;
+        if( (Int)rDuCpbRemovalDelayMinus1[ i ] < 0 )
+        {
+          rDuCpbRemovalDelayMinus1[ i ] = 0;
+        }
+        else if (tmp > 0 && flag == 1)
+        {
+          tmp --;
+        }
+        accum += rDuCpbRemovalDelayMinus1[ i ] + 1;
+        uiPrev = accum;
+      }
+    }
+  }
+}
+Void TEncGOP::xUpdateDuInfoSEI(SEIMessages &duInfoSeiMessages, SEIPictureTiming *pictureTimingSEI)
+{
+  if (duInfoSeiMessages.empty() || (pictureTimingSEI == NULL))
+  {
+    return;
+  }
+
+  Int i=0;
+
+  for (SEIMessages::iterator du = duInfoSeiMessages.begin(); du!= duInfoSeiMessages.end(); du++)
+  {
+    SEIDecodingUnitInfo *duInfoSEI = (SEIDecodingUnitInfo*) (*du);
+    duInfoSEI->m_decodingUnitIdx = i;
+    duInfoSEI->m_duSptCpbRemovalDelay = pictureTimingSEI->m_duCpbRemovalDelayMinus1[i] + 1;
+    duInfoSEI->m_dpbOutputDuDelayPresentFlag = false;
+    i++;
+  }
+}
 
 // ====================================================================================================================
@@ -891 +1252 @@
 
   m_iNumPicCoded = 0;
-  SEIPictureTiming pictureTimingSEI;
-  Bool writeSOP = m_pcCfg->getSOPDescriptionSEIEnabled();
-
-  // Initialize Scalable Nesting SEI with single layer values
-  SEIScalableNesting scalableNestingSEI;
-  scalableNestingSEI.m_bitStreamSubsetFlag           = 1;      // If the nested SEI messages are picture buffereing SEI mesages, picure timing SEI messages or sub-picture timing SEI messages, bitstream_subset_flag shall be equal to 1
-  scalableNestingSEI.m_nestingOpFlag                 = 0;
-  scalableNestingSEI.m_nestingNumOpsMinus1           = 0;      //nesting_num_ops_minus1
-  scalableNestingSEI.m_allLayersFlag                 = 0;
-  scalableNestingSEI.m_nestingNoOpMaxTemporalIdPlus1 = 6 + 1;  //nesting_no_op_max_temporal_id_plus1
-  scalableNestingSEI.m_nestingNumLayersMinus1        = 1 - 1;  //nesting_num_layers_minus1
-  scalableNestingSEI.m_nestingLayerId[0]             = 0;
-  scalableNestingSEI.m_callerOwnsSEIs                = true;
-
-  Int picSptDpbOutputDuDelay = 0;
-  UInt *accumBitsDU = NULL;
-  UInt *accumNalsDU = NULL;
+  SEIMessages leadingSeiMessages;
+  SEIMessages nestedSeiMessages;
+  SEIMessages duInfoSeiMessages;
+  SEIMessages trailingSeiMessages;
+  std::deque<DUData> duData;
   SEIDecodingUnitInfo decodingUnitInfoSEI;
 
@@ -2092 +2441 @@
 #endif
 
+    duData.clear();
     pcSlice = pcPic->getSlice(0);
 
@@ -2113 +2463 @@
     m_pcEntropyCoder->setEntropyCoder   ( m_pcCavlcCoder, pcSlice );
 
-    // write various header sets.
     if ( m_bSeqFirst )
     {
-#if SVC_EXTENSION
-      OutputNALUnit nalu( NAL_UNIT_VPS, 0, 0 ); // The value of nuh_layer_id of VPS NAL unit shall be equal to 0.
-#if AVC_BASE
-      if( ( m_layerId > 0 && m_pcEncTop->getVPS()->getNonHEVCBaseLayerFlag() ) || ( m_layerId == 0 && !m_pcEncTop->getVPS()->getNonHEVCBaseLayerFlag() ) )
-#else
-      if( m_layerId == 0 )
-#endif
-      {
-        //The following code also calculates the VPS VUI offset
-#else
-      OutputNALUnit nalu(NAL_UNIT_VPS);
-#endif
-      m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
-      m_pcEntropyCoder->encodeVPS(m_pcEncTop->getVPS());
-      writeRBSPTrailingBits(nalu.m_Bitstream);
-      accessUnit.push_back(new NALUnitEBSP(nalu));
-      actualTotalBits += UInt(accessUnit.back()->m_nalUnitData.str().size()) * 8;
-#if SVC_EXTENSION
-      }
-#endif
-
-#if SVC_EXTENSION
-      nalu = NALUnit(NAL_UNIT_SPS, 0, m_layerId);
-
-      if( m_pcEncTop->getVPS()->getNumDirectRefLayers(m_layerId) == 0 && m_pcEncTop->getVPS()->getNumAddLayerSets() > 0 )
-      {
-        // For independent base layer rewriting
-        nalu.m_nuhLayerId = 0; 
-      }
-#else
-      nalu = NALUnit(NAL_UNIT_SPS);
-#endif
-
-      m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
-      
-#if SVC_EXTENSION
-      // dependency constraint
-      assert( pcSlice->getSPS()->getLayerId() == 0 || pcSlice->getSPS()->getLayerId() == m_layerId || m_pcEncTop->getVPS()->getRecursiveRefLayerFlag(m_layerId, pcSlice->getSPS()->getLayerId()) );
-#endif
-
-      m_pcEntropyCoder->encodeSPS(pcSlice->getSPS());
-      writeRBSPTrailingBits(nalu.m_Bitstream);
-      accessUnit.push_back(new NALUnitEBSP(nalu));
-      actualTotalBits += UInt(accessUnit.back()->m_nalUnitData.str().size()) * 8;
-
-#if SVC_EXTENSION
-      nalu = NALUnit(NAL_UNIT_PPS, 0, m_layerId);
-
-      if( m_pcEncTop->getVPS()->getNumDirectRefLayers(m_layerId) == 0 && m_pcEncTop->getVPS()->getNumAddLayerSets() > 0 )
-      {
-        // For independent base layer rewriting
-        nalu.m_nuhLayerId = 0;
-      }
-#else
-      nalu = NALUnit(NAL_UNIT_PPS);
-#endif
-
-      m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
-
-#if SVC_EXTENSION
-      // dependency constraint
-      assert( pcSlice->getPPS()->getLayerId() == 0 || pcSlice->getPPS()->getLayerId() == m_layerId || m_pcEncTop->getVPS()->getRecursiveRefLayerFlag(m_layerId, pcSlice->getPPS()->getLayerId()) );
-#endif
+      // write various parameter sets
+      actualTotalBits += xWriteParameterSets(accessUnit, pcSlice);
+
+      // create prefix SEI messages at the beginning of the sequence
+      leadingSeiMessages.clear();
+      xCreateIRAPLeadingSEIMessages(leadingSeiMessages, pcSlice->getSPS(), pcSlice->getPPS());
+
+      m_bSeqFirst = false;
+    }
 #if SVC_EXTENSION && CGS_3D_ASYMLUT
-      m_pcEntropyCoder->encodePPS(pcSlice->getPPS(), &m_Enc3DAsymLUTPPS);
-#else
-      m_pcEntropyCoder->encodePPS(pcSlice->getPPS());
-#endif
-      writeRBSPTrailingBits(nalu.m_Bitstream);
-      accessUnit.push_back(new NALUnitEBSP(nalu));
-      actualTotalBits += UInt(accessUnit.back()->m_nalUnitData.str().size()) * 8;
-
-      xCreateLeadingSEIMessages(accessUnit, pcSlice->getSPS(), pcSlice->getPPS());
-
-#if O0164_MULTI_LAYER_HRD
-      if (pcSlice->getLayerId() == 0 && m_pcEncTop->getVPS()->getVpsVuiBspHrdPresentFlag())
-      {
-        Int j;
-        TComVPS *vps = m_pcEncTop->getVPS();
-
-        for( Int i = 0; i < vps->getNumOutputLayerSets(); i++ )
-        {
-          for( Int k = 0; k < vps->getNumSignalledPartitioningSchemes(i); k++ )
-          {
-            for( Int l = 0; l < vps->getNumPartitionsInSchemeMinus1(i, k)+1; l++ )
-            {
-              nalu = NALUnit(NAL_UNIT_PREFIX_SEI, 0, 1);
-              m_pcEntropyCoder->setEntropyCoder(m_pcCavlcCoder, pcSlice);
-              m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
-              SEIScalableNesting *scalableBspNestingSei = xCreateBspNestingSEI(pcSlice, i, k, l);
-              m_seiWriter.writeSEImessage(nalu.m_Bitstream, *scalableBspNestingSei, m_pcEncTop->getVPS(), pcSlice->getSPS());
-              writeRBSPTrailingBits(nalu.m_Bitstream);
-
-              UInt seiPositionInAu = xGetFirstSeiLocation(accessUnit);
-              UInt offsetPosition = m_activeParameterSetSEIPresentInAU 
-                + m_bufferingPeriodSEIPresentInAU 
-                + m_pictureTimingSEIPresentInAU
-                + m_nestedPictureTimingSEIPresentInAU;  // Insert SEI after APS, BP and PT SEI
-
-              AccessUnit::iterator it;
-
-              for( j = 0, it = accessUnit.begin(); j < seiPositionInAu + offsetPosition; j++ )
-              {
-                it++;
-              }
-
-              accessUnit.insert(it, new NALUnitEBSP(nalu));
-            }
-          }
-        }
-      }
-#endif
-
-      m_bSeqFirst = false;
-    }
-#if CGS_3D_ASYMLUT
     else if( m_pcCfg->getCGSFlag() && pcSlice->getLayerId() && pcSlice->getCGSOverWritePPS() )
     {
@@ -2242 +2485 @@
 #endif
 
-    if (writeSOP) // write SOP description SEI (if enabled) at the beginning of GOP
-    {
-      Int SOPcurrPOC = pocCurr;
-
-      OutputNALUnit nalu(NAL_UNIT_PREFIX_SEI);
-      m_pcEntropyCoder->setEntropyCoder(m_pcCavlcCoder, pcSlice);
-      m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
-
-      SEISOPDescription SOPDescriptionSEI;
-      SOPDescriptionSEI.m_sopSeqParameterSetId = pcSlice->getSPS()->getSPSId();
-
-      UInt i = 0;
-      UInt prevEntryId = iGOPid;
-      for (Int j = iGOPid; j < m_iGopSize; j++)
-      {
-        Int deltaPOC = m_pcCfg->getGOPEntry(j).m_POC - m_pcCfg->getGOPEntry(prevEntryId).m_POC;
-        if ((SOPcurrPOC + deltaPOC) < m_pcCfg->getFramesToBeEncoded())
-        {
-          SOPcurrPOC += deltaPOC;
-          SOPDescriptionSEI.m_sopDescVclNaluType[i] = getNalUnitType(SOPcurrPOC, m_iLastIDR, isField);
-          SOPDescriptionSEI.m_sopDescTemporalId[i] = m_pcCfg->getGOPEntry(j).m_temporalId;
-          SOPDescriptionSEI.m_sopDescStRpsIdx[i] = m_pcEncTop->getReferencePictureSetIdxForSOP(pcSlice, SOPcurrPOC, j);
-          SOPDescriptionSEI.m_sopDescPocDelta[i] = deltaPOC;
-
-          prevEntryId = j;
-          i++;
-        }
-      }
-
-      SOPDescriptionSEI.m_numPicsInSopMinus1 = i - 1;
-
-#if O0164_MULTI_LAYER_HRD
-      m_seiWriter.writeSEImessage( nalu.m_Bitstream, SOPDescriptionSEI, m_pcEncTop->getVPS(), pcSlice->getSPS());
-#else
-      m_seiWriter.writeSEImessage( nalu.m_Bitstream, SOPDescriptionSEI, pcSlice->getSPS());
-#endif
-      writeRBSPTrailingBits(nalu.m_Bitstream);
-      accessUnit.push_back(new NALUnitEBSP(nalu));
-
-      writeSOP = false;
-    }
-#if Q0189_TMVP_CONSTRAINTS
-   if( m_pcEncTop->getTMVPConstraintsSEIEnabled() == 1 &&
-      (m_pcEncTop->getTMVPModeId() == 1 || m_pcEncTop->getTMVPModeId() == 2) &&
-      pcSlice->getLayerId() >0 && 
-      (pcSlice->getNalUnitType() ==  NAL_UNIT_CODED_SLICE_IDR_W_RADL || pcSlice->getNalUnitType() ==  NAL_UNIT_CODED_SLICE_IDR_N_LP))
-   {
-      OutputNALUnit nalu(NAL_UNIT_PREFIX_SEI);
-      SEITMVPConstrains seiTMVPConstrains;
-      m_pcEntropyCoder->setEntropyCoder(m_pcCavlcCoder, pcSlice);
-      m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
-      seiTMVPConstrains.no_intra_layer_col_pic_flag = 1;
-      seiTMVPConstrains.prev_pics_not_used_flag = 1;
-#if O0164_MULTI_LAYER_HRD
-      m_seiWriter.writeSEImessage( nalu.m_Bitstream, seiTMVPConstrains, m_pcEncTop->getVPS(), pcSlice->getSPS() );
-#else
-      m_seiWriter.writeSEImessage( nalu.m_Bitstream, seiTMVPConstrains, pcSlice->getSPS() );
-#endif
-      writeRBSPTrailingBits(nalu.m_Bitstream);
-      accessUnit.push_back(new NALUnitEBSP(nalu));
-   }
-#endif
-#if Q0247_FRAME_FIELD_INFO
-    if(  pcSlice->getLayerId()> 0 &&
-     ( (m_pcCfg->getProgressiveSourceFlag() && m_pcCfg->getInterlacedSourceFlag()) || m_pcCfg->getFrameFieldInfoPresentFlag()))
-    {
-      OutputNALUnit nalu(NAL_UNIT_PREFIX_SEI);
-      SEIFrameFieldInfo seiFFInfo;
-      m_pcEntropyCoder->setEntropyCoder(m_pcCavlcCoder, pcSlice);
-      m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
-      seiFFInfo.m_ffinfo_picStruct = (isField && pcSlice->getPic()->isTopField())? 1 : isField? 2 : 0;
-#if O0164_MULTI_LAYER_HRD
-      m_seiWriter.writeSEImessage( nalu.m_Bitstream, seiFFInfo, m_pcEncTop->getVPS(), pcSlice->getSPS() );
-#else
-      m_seiWriter.writeSEImessage( nalu.m_Bitstream, seiFFInfo, pcSlice->getSPS() );
-#endif
-      writeRBSPTrailingBits(nalu.m_Bitstream);
-      accessUnit.push_back(new NALUnitEBSP(nalu));
-    }
-#endif
-
-    if( ( m_pcCfg->getPictureTimingSEIEnabled() || m_pcCfg->getDecodingUnitInfoSEIEnabled() ) &&
-        ( pcSlice->getSPS()->getVuiParametersPresentFlag() ) &&
-        ( ( pcSlice->getSPS()->getVuiParameters()->getHrdParameters()->getNalHrdParametersPresentFlag() )
-       || ( pcSlice->getSPS()->getVuiParameters()->getHrdParameters()->getVclHrdParametersPresentFlag() ) ) )
-    {
-      if( pcSlice->getSPS()->getVuiParameters()->getHrdParameters()->getSubPicCpbParamsPresentFlag() )
-      {
-        UInt numDU = pcSlice->getSPS()->getVuiParameters()->getHrdParameters()->getNumDU();
-        pictureTimingSEI.m_numDecodingUnitsMinus1     = ( numDU - 1 );
-        pictureTimingSEI.m_duCommonCpbRemovalDelayFlag = false;
-
-        if( pictureTimingSEI.m_numNalusInDuMinus1 == NULL )
-        {
-          pictureTimingSEI.m_numNalusInDuMinus1       = new UInt[ numDU ];
-        }
-        if( pictureTimingSEI.m_duCpbRemovalDelayMinus1  == NULL )
-        {
-          pictureTimingSEI.m_duCpbRemovalDelayMinus1  = new UInt[ numDU ];
-        }
-        if( accumBitsDU == NULL )
-        {
-          accumBitsDU                                  = new UInt[ numDU ];
-        }
-        if( accumNalsDU == NULL )
-        {
-          accumNalsDU                                  = new UInt[ numDU ];
-        }
-      }
-      pictureTimingSEI.m_auCpbRemovalDelay = std::min<Int>(std::max<Int>(1, m_totalCoded - m_lastBPSEI), static_cast<Int>(pow(2, static_cast<Double>(pcSlice->getSPS()->getVuiParameters()->getHrdParameters()->getCpbRemovalDelayLengthMinus1()+1)))); // Syntax element signalled as minus, hence the .
-#if SVC_EXTENSION
-      pictureTimingSEI.m_picDpbOutputDelay = pcSlice->getSPS()->getNumReorderPics(pcSlice->getSPS()->getMaxTLayers()-1) + pocCurr - m_totalCoded;
-#else
-      pictureTimingSEI.m_picDpbOutputDelay = pcSlice->getSPS()->getNumReorderPics(pcSlice->getSPS()->getMaxTLayers()-1) + pcSlice->getPOC() - m_totalCoded;
-#endif
-#if EFFICIENT_FIELD_IRAP
-      if(IRAPGOPid > 0 && IRAPGOPid < m_iGopSize)
-      {
-        // if pictures have been swapped there is likely one more picture delay on their tid. Very rough approximation
-        pictureTimingSEI.m_picDpbOutputDelay ++;
-      }
-#endif
-      Int factor = pcSlice->getSPS()->getVuiParameters()->getHrdParameters()->getTickDivisorMinus2() + 2;
-      pictureTimingSEI.m_picDpbOutputDuDelay = factor * pictureTimingSEI.m_picDpbOutputDelay;
-      if( m_pcCfg->getDecodingUnitInfoSEIEnabled() )
-      {
-        picSptDpbOutputDuDelay = factor * pictureTimingSEI.m_picDpbOutputDelay;
-      }
-    }
-
-    if( ( m_pcCfg->getBufferingPeriodSEIEnabled() ) && ( pcSlice->getSliceType() == I_SLICE ) &&
-        ( pcSlice->getSPS()->getVuiParametersPresentFlag() ) &&
-        ( ( pcSlice->getSPS()->getVuiParameters()->getHrdParameters()->getNalHrdParametersPresentFlag() )
-       || ( pcSlice->getSPS()->getVuiParameters()->getHrdParameters()->getVclHrdParametersPresentFlag() ) ) )
-    {
-      OutputNALUnit nalu(NAL_UNIT_PREFIX_SEI);
-      m_pcEntropyCoder->setEntropyCoder(m_pcCavlcCoder, pcSlice);
-      m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
-
-      SEIBufferingPeriod sei_buffering_period;
-
-      UInt uiInitialCpbRemovalDelay = (90000/2);                      // 0.5 sec
-      sei_buffering_period.m_initialCpbRemovalDelay      [0][0]     = uiInitialCpbRemovalDelay;
-      sei_buffering_period.m_initialCpbRemovalDelayOffset[0][0]     = uiInitialCpbRemovalDelay;
-      sei_buffering_period.m_initialCpbRemovalDelay      [0][1]     = uiInitialCpbRemovalDelay;
-      sei_buffering_period.m_initialCpbRemovalDelayOffset[0][1]     = uiInitialCpbRemovalDelay;
-
-      Double dTmp = (Double)pcSlice->getSPS()->getVuiParameters()->getTimingInfo()->getNumUnitsInTick() / (Double)pcSlice->getSPS()->getVuiParameters()->getTimingInfo()->getTimeScale();
-
-      UInt uiTmp = (UInt)( dTmp * 90000.0 );
-      uiInitialCpbRemovalDelay -= uiTmp;
-      uiInitialCpbRemovalDelay -= uiTmp / ( pcSlice->getSPS()->getVuiParameters()->getHrdParameters()->getTickDivisorMinus2() + 2 );
-      sei_buffering_period.m_initialAltCpbRemovalDelay      [0][0]  = uiInitialCpbRemovalDelay;
-      sei_buffering_period.m_initialAltCpbRemovalDelayOffset[0][0]  = uiInitialCpbRemovalDelay;
-      sei_buffering_period.m_initialAltCpbRemovalDelay      [0][1]  = uiInitialCpbRemovalDelay;
-      sei_buffering_period.m_initialAltCpbRemovalDelayOffset[0][1]  = uiInitialCpbRemovalDelay;
-
-      sei_buffering_period.m_rapCpbParamsPresentFlag              = 0;
-      //for the concatenation, it can be set to one during splicing.
-      sei_buffering_period.m_concatenationFlag = 0;
-      //since the temporal layer HRD is not ready, we assumed it is fixed
-      sei_buffering_period.m_auCpbRemovalDelayDelta = 1;
-
-      sei_buffering_period.m_cpbDelayOffset = 0;
-      sei_buffering_period.m_dpbDelayOffset = 0;
-
-#if O0164_MULTI_LAYER_HRD
-      m_seiWriter.writeSEImessage( nalu.m_Bitstream, sei_buffering_period, m_pcEncTop->getVPS(), pcSlice->getSPS());
-#else
-      m_seiWriter.writeSEImessage( nalu.m_Bitstream, sei_buffering_period, pcSlice->getSPS());
-#endif
-      writeRBSPTrailingBits(nalu.m_Bitstream);
-
-      {
-        UInt seiPositionInAu = xGetFirstSeiLocation(accessUnit);
-        UInt offsetPosition = m_activeParameterSetSEIPresentInAU;   // Insert BP SEI after APS SEI
-        AccessUnit::iterator it = accessUnit.begin();
-        for(Int j = 0; j < seiPositionInAu + offsetPosition; j++)
-        {
-          it++;
-        }
-        accessUnit.insert(it, new NALUnitEBSP(nalu));
-        m_bufferingPeriodSEIPresentInAU = true;
-      }
-
-      if (m_pcCfg->getScalableNestingSEIEnabled())
-      {
-        OutputNALUnit naluTmp(NAL_UNIT_PREFIX_SEI);
-        m_pcEntropyCoder->setEntropyCoder(m_pcCavlcCoder, pcSlice);
-        m_pcEntropyCoder->setBitstream(&naluTmp.m_Bitstream);
-        scalableNestingSEI.m_nestedSEIs.clear();
-        scalableNestingSEI.m_nestedSEIs.push_back(&sei_buffering_period);
-#if O0164_MULTI_LAYER_HRD
-        m_seiWriter.writeSEImessage( naluTmp.m_Bitstream, scalableNestingSEI, m_pcEncTop->getVPS(), pcSlice->getSPS());
-#else
-        m_seiWriter.writeSEImessage( naluTmp.m_Bitstream, scalableNestingSEI, pcSlice->getSPS());
-#endif
-        writeRBSPTrailingBits(naluTmp.m_Bitstream);
-        UInt seiPositionInAu = xGetFirstSeiLocation(accessUnit);
-        UInt offsetPosition = m_activeParameterSetSEIPresentInAU + m_bufferingPeriodSEIPresentInAU + m_pictureTimingSEIPresentInAU;   // Insert BP SEI after non-nested APS, BP and PT SEIs
-        AccessUnit::iterator it = accessUnit.begin();
-        for(Int j = 0; j < seiPositionInAu + offsetPosition; j++)
-        {
-          it++;
-        }
-        accessUnit.insert(it, new NALUnitEBSP(naluTmp));
-        m_nestedBufferingPeriodSEIPresentInAU = true;
-      }
-
-      m_lastBPSEI = m_totalCoded;
-      m_cpbRemovalDelay = 0;
-    }
-    m_cpbRemovalDelay ++;
-
-    if(pcSlice->getSPS()->getVuiParametersPresentFlag() && m_pcCfg->getChromaSamplingFilterHintEnabled() && ( pcSlice->getSliceType() == I_SLICE ))
-    {
-      SEIChromaSamplingFilterHint *seiChromaSamplingFilterHint = xCreateSEIChromaSamplingFilterHint(m_pcCfg->getChromaLocInfoPresentFlag(), m_pcCfg->getChromaSamplingHorFilterIdc(), m_pcCfg->getChromaSamplingVerFilterIdc());
-
-      OutputNALUnit naluTmp(NAL_UNIT_PREFIX_SEI); 
-      m_pcEntropyCoder->setEntropyCoder(m_pcCavlcCoder, pcSlice);
-      m_pcEntropyCoder->setBitstream(&naluTmp.m_Bitstream);
-#if O0164_MULTI_LAYER_HRD
-      m_seiWriter.writeSEImessage(naluTmp.m_Bitstream, *seiChromaSamplingFilterHint, m_pcEncTop->getVPS(), pcSlice->getSPS());
-#else
-      m_seiWriter.writeSEImessage(naluTmp.m_Bitstream, *seiChromaSamplingFilterHint, pcSlice->getSPS()); 
-#endif
-      writeRBSPTrailingBits(naluTmp.m_Bitstream);
-      accessUnit.push_back(new NALUnitEBSP(naluTmp));
-      delete seiChromaSamplingFilterHint;
-    }
-
-    if( ( m_pcEncTop->getRecoveryPointSEIEnabled() ) && ( pcSlice->getSliceType() == I_SLICE ) )
-    {
-      if( m_pcEncTop->getGradualDecodingRefreshInfoEnabled() && !pcSlice->getRapPicFlag() )
-      {
-        // Gradual decoding refresh SEI
-        OutputNALUnit nalu(NAL_UNIT_PREFIX_SEI);
-        m_pcEntropyCoder->setEntropyCoder(m_pcCavlcCoder, pcSlice);
-        m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
-
-        SEIGradualDecodingRefreshInfo seiGradualDecodingRefreshInfo;
-        seiGradualDecodingRefreshInfo.m_gdrForegroundFlag = true; // Indicating all "foreground"
-
-#if O0164_MULTI_LAYER_HRD
-        m_seiWriter.writeSEImessage( nalu.m_Bitstream, seiGradualDecodingRefreshInfo, m_pcEncTop->getVPS(), pcSlice->getSPS() );
-#else
-        m_seiWriter.writeSEImessage( nalu.m_Bitstream, seiGradualDecodingRefreshInfo, pcSlice->getSPS() );
-#endif
-        writeRBSPTrailingBits(nalu.m_Bitstream);
-        accessUnit.push_back(new NALUnitEBSP(nalu));
-      }
-    // Recovery point SEI
-      OutputNALUnit nalu(NAL_UNIT_PREFIX_SEI);
-      m_pcEntropyCoder->setEntropyCoder(m_pcCavlcCoder, pcSlice);
-      m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
-
-      SEIRecoveryPoint sei_recovery_point;
-      sei_recovery_point.m_recoveryPocCnt    = 0;
-#if SVC_EXTENSION
-      sei_recovery_point.m_exactMatchingFlag = ( pocCurr == 0 ) ? (true) : (false);
-#else
-      sei_recovery_point.m_exactMatchingFlag = ( pcSlice->getPOC() == 0 ) ? (true) : (false);
-#endif
-      sei_recovery_point.m_brokenLinkFlag    = false;
-#if ALLOW_RECOVERY_POINT_AS_RAP
-      if(m_pcCfg->getDecodingRefreshType() == 3)
-      {
-        m_iLastRecoveryPicPOC = pocCurr;
-      }
-#endif
-
-#if O0164_MULTI_LAYER_HRD
-      m_seiWriter.writeSEImessage( nalu.m_Bitstream, sei_recovery_point, m_pcEncTop->getVPS(), pcSlice->getSPS() );
-#else
-      m_seiWriter.writeSEImessage( nalu.m_Bitstream, sei_recovery_point, pcSlice->getSPS() );
-#endif
-      writeRBSPTrailingBits(nalu.m_Bitstream);
-      accessUnit.push_back(new NALUnitEBSP(nalu));
-    }
-
-    if( m_pcEncTop->getNoDisplaySEITLayer() )
-    {
-      if( pcSlice->getTLayer() >= m_pcEncTop->getNoDisplaySEITLayer() )
-      {
-        // No display SEI
-        OutputNALUnit nalu(NAL_UNIT_PREFIX_SEI);
-        m_pcEntropyCoder->setEntropyCoder(m_pcCavlcCoder, pcSlice);
-        m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
-
-        SEINoDisplay seiNoDisplay;
-        seiNoDisplay.m_noDisplay = true;
-
-#if O0164_MULTI_LAYER_HRD
-        m_seiWriter.writeSEImessage( nalu.m_Bitstream, seiNoDisplay, m_pcEncTop->getVPS(), pcSlice->getSPS() );
-#else
-        m_seiWriter.writeSEImessage( nalu.m_Bitstream, seiNoDisplay, pcSlice->getSPS() );
-#endif
-        writeRBSPTrailingBits(nalu.m_Bitstream);
-        accessUnit.push_back(new NALUnitEBSP(nalu));
-      }
-    }
-
-    // insert one CRI by picture (if the file exist) 
-#if Q0074_COLOUR_REMAPPING_SEI
-  
-    freeColourCRI();
-
-    // building the CRI file name with poc num in suffix "_poc.txt"
-    char suffix[10];
-    sprintf(suffix, "_%d.txt",  pcSlice->getPOC());
-    string  colourRemapSEIFileWithPoc(m_pcCfg->getCRISEIFileRoot());
-    colourRemapSEIFileWithPoc.append(suffix);
-    setCRISEIFile( const_cast<Char*>(colourRemapSEIFileWithPoc.c_str()) );
-  
-    Int ret = readingCRIparameters();
-
-    if(ret != -1 && m_pcCfg->getCRISEIFileRoot())
-    {
-      // check validity of input parameters
-      xCheckParameter();
-
-      SEIColourRemappingInfo *sei = xCreateSEIColourRemappingInfo ();
-#if SVC_EXTENSION
-      OutputNALUnit nalu(NAL_UNIT_PREFIX_SEI, 0, pcSlice->getSPS()->getLayerId());  // SEI-CRI is applied per layer
-#else
-      OutputNALUnit nalu(NAL_UNIT_PREFIX_SEI);
-#endif
-      m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
-#if SVC_EXTENSION
-      m_seiWriter.writeSEImessage(nalu.m_Bitstream, *sei, m_pcEncTop->getVPS(), pcSlice->getSPS() ); 
-#else
-      m_seiWriter.writeSEImessage(nalu.m_Bitstream, *sei, pcSlice->getSPS() ); 
-#endif
-      writeRBSPTrailingBits(nalu.m_Bitstream);
-      accessUnit.push_back(new NALUnitEBSP(nalu));
-      delete sei;
-    }
-#endif
+    // create prefix SEI associated with a picture
+    xCreatePerPictureSEIMessages(iGOPid, leadingSeiMessages, nestedSeiMessages, pcSlice);
 
     /* use the main bitstream buffer for storing the marshalled picture */
@@ -2753 +2660 @@
         for (AccessUnit::const_iterator it = accessUnit.begin(); it != accessUnit.end(); it++)
         {
-          UInt numRBSPBytes_nal = UInt((*it)->m_nalUnitData.str().size());
-          if ((*it)->m_nalUnitType != NAL_UNIT_PREFIX_SEI && (*it)->m_nalUnitType != NAL_UNIT_SUFFIX_SEI)
-          {
-            numRBSPBytes += numRBSPBytes_nal;
-            numNalus ++;
-          }
-        }
-        accumBitsDU[ pcSlice->getSliceIdx() ] = ( numRBSPBytes << 3 );
-        accumNalsDU[ pcSlice->getSliceIdx() ] = numNalus;   // SEI not counted for bit count; hence shouldn't be counted for # of NALUs - only for consistency
+          numRBSPBytes += UInt((*it)->m_nalUnitData.str().size());
+          numNalus ++;
+        }
+        duData.push_back(DUData());
+        duData.back().accumBitsDU = ( numRBSPBytes << 3 );
+        duData.back().accumNalsDU = numNalus;
       }
     } // end iteration over slices
@@ -2792 +2696 @@
           if (m_pcCfg->getCabacZeroWordPaddingEnabled())
           {
-            std::vector<Char> zeroBytesPadding((size_t)numberOfAdditionalCabacZeroBytes, Char(0));
+            std::vector<Char> zeroBytesPadding(numberOfAdditionalCabacZeroBytes, Char(0));
             for(std::size_t i=0; i<numberOfAdditionalCabacZeroWords; i++)
             {
               zeroBytesPadding[i*3+2]=3;  // 00 00 03
             }
-            accessUnit.back()->m_nalUnitData.write(&(zeroBytesPadding[0]), (size_t)numberOfAdditionalCabacZeroBytes);
+            accessUnit.back()->m_nalUnitData.write(&(zeroBytesPadding[0]), numberOfAdditionalCabacZeroBytes);
             printf("Adding %d bytes of padding\n", UInt(numberOfAdditionalCabacZeroWords*3));
           }
@@ -2816 +2720 @@
     if (m_pcCfg->getDecodedPictureHashSEIEnabled())
     {
-      /* calculate MD5sum for entire reconstructed picture */
-      SEIDecodedPictureHash sei_recon_picture_digest;
-      if(m_pcCfg->getDecodedPictureHashSEIEnabled() == 1)
-      {
-        sei_recon_picture_digest.method = SEIDecodedPictureHash::MD5;
-        UInt numChar=calcMD5(*pcPic->getPicYuvRec(), sei_recon_picture_digest.m_digest);
-        digestStr = digestToString(sei_recon_picture_digest.m_digest, numChar);
-      }
-      else if(m_pcCfg->getDecodedPictureHashSEIEnabled() == 2)
-      {
-        sei_recon_picture_digest.method = SEIDecodedPictureHash::CRC;
-        UInt numChar=calcCRC(*pcPic->getPicYuvRec(), sei_recon_picture_digest.m_digest);
-        digestStr = digestToString(sei_recon_picture_digest.m_digest, numChar);
-      }
-      else if(m_pcCfg->getDecodedPictureHashSEIEnabled() == 3)
-      {
-        sei_recon_picture_digest.method = SEIDecodedPictureHash::CHECKSUM;
-        UInt numChar=calcChecksum(*pcPic->getPicYuvRec(), sei_recon_picture_digest.m_digest);
-        digestStr = digestToString(sei_recon_picture_digest.m_digest, numChar);
-      }
-
-#if SVC_EXTENSION
-      OutputNALUnit nalu(NAL_UNIT_SUFFIX_SEI, pcSlice->getTLayer(), m_layerId);
-#else
-      OutputNALUnit nalu(NAL_UNIT_SUFFIX_SEI, pcSlice->getTLayer());
-#endif
-
-      /* write the SEI messages */
-      m_pcEntropyCoder->setEntropyCoder(m_pcCavlcCoder, pcSlice);
+      SEIDecodedPictureHash *decodedPictureHashSei = new SEIDecodedPictureHash();
+      m_seiEncoder.initDecodedPictureHashSEI(decodedPictureHashSei, pcPic, digestStr);
+      trailingSeiMessages.push_back(decodedPictureHashSei);
+    }
+
 #if O0164_MULTI_LAYER_HRD
-      m_seiWriter.writeSEImessage(nalu.m_Bitstream, sei_recon_picture_digest, m_pcEncTop->getVPS(), pcSlice->getSPS());
-#else
-      m_seiWriter.writeSEImessage(nalu.m_Bitstream, sei_recon_picture_digest, pcSlice->getSPS());
-#endif
-      writeRBSPTrailingBits(nalu.m_Bitstream);
-
-      accessUnit.insert(accessUnit.end(), new NALUnitEBSP(nalu));
-    }
-    if (m_pcCfg->getTemporalLevel0IndexSEIEnabled())
-    {
-      SEITemporalLevel0Index sei_temporal_level0_index;
-      if (pcSlice->getRapPicFlag())
-      {
-        m_tl0Idx = 0;
-        m_rapIdx = (m_rapIdx + 1) & 0xFF;
-      }
-      else
-      {
-        m_tl0Idx = (m_tl0Idx + (pcSlice->getTLayer() ? 0 : 1)) & 0xFF;
-      }
-      sei_temporal_level0_index.tl0Idx = m_tl0Idx;
-      sei_temporal_level0_index.rapIdx = m_rapIdx;
-
-      OutputNALUnit nalu(NAL_UNIT_PREFIX_SEI);
-
-      /* write the SEI messages */
-      m_pcEntropyCoder->setEntropyCoder(m_pcCavlcCoder, pcSlice);
-#if O0164_MULTI_LAYER_HRD
-      m_seiWriter.writeSEImessage(nalu.m_Bitstream, sei_temporal_level0_index, m_pcEncTop->getVPS(), pcSlice->getSPS());
-#else
-      m_seiWriter.writeSEImessage(nalu.m_Bitstream, sei_temporal_level0_index, pcSlice->getSPS());      
-#endif
-      writeRBSPTrailingBits(nalu.m_Bitstream);
-
-      /* insert the SEI message NALUnit before any Slice NALUnits */
-      AccessUnit::iterator it = find_if(accessUnit.begin(), accessUnit.end(), mem_fun(&NALUnit::isSlice));
-      accessUnit.insert(it, new NALUnitEBSP(nalu));
-    }
+    xWriteTrailingSEIMessages(trailingSeiMessages, accessUnit, pcSlice->getTLayer(), pcSlice->getVPS(), pcSlice->getSPS());
+#else
+    xWriteTrailingSEIMessages(trailingSeiMessages, accessUnit, pcSlice->getTLayer(), pcSlice->getSPS());
+#endif
+    trailingSeiMessages.clear();
 
     m_pcCfg->setEncodedFlag(iGOPid, true);
@@ -2989 +2836 @@
     }
 
-    if( ( m_pcCfg->getPictureTimingSEIEnabled() || m_pcCfg->getDecodingUnitInfoSEIEnabled() ) &&
-        ( pcSlice->getSPS()->getVuiParametersPresentFlag() ) &&
-        ( ( pcSlice->getSPS()->getVuiParameters()->getHrdParameters()->getNalHrdParametersPresentFlag() )
-        || ( pcSlice->getSPS()->getVuiParameters()->getHrdParameters()->getVclHrdParametersPresentFlag() ) ) )
-    {
-      const TComVUI *vui = pcSlice->getSPS()->getVuiParameters();
-      const TComHRD *hrd = vui->getHrdParameters();
-
-      if( hrd->getSubPicCpbParamsPresentFlag() )
-      {
-        Int i;
-        UInt64 ui64Tmp;
-        UInt uiPrev = 0;
-        UInt numDU = ( pictureTimingSEI.m_numDecodingUnitsMinus1 + 1 );
-        UInt *pCRD = &pictureTimingSEI.m_duCpbRemovalDelayMinus1[0];
-        UInt maxDiff = ( hrd->getTickDivisorMinus2() + 2 ) - 1;
-
-        for( i = 0; i < numDU; i ++ )
-        {
-          pictureTimingSEI.m_numNalusInDuMinus1[ i ]       = ( i == 0 ) ? ( accumNalsDU[ i ] - 1 ) : ( accumNalsDU[ i ] - accumNalsDU[ i - 1] - 1 );
-        }
-
-        if( numDU == 1 )
-        {
-          pCRD[ 0 ] = 0; /* don't care */
-        }
-        else
-        {
-          pCRD[ numDU - 1 ] = 0;/* by definition */
-          UInt tmp = 0;
-          UInt accum = 0;
-
-          for( i = ( numDU - 2 ); i >= 0; i -- )
-          {
-            ui64Tmp = ( ( ( accumBitsDU[ numDU - 1 ]  - accumBitsDU[ i ] ) * ( vui->getTimingInfo()->getTimeScale() / vui->getTimingInfo()->getNumUnitsInTick() ) * ( hrd->getTickDivisorMinus2() + 2 ) ) / ( m_pcCfg->getTargetBitrate() ) );
-            if( (UInt)ui64Tmp > maxDiff )
-            {
-              tmp ++;
-            }
-          }
-          uiPrev = 0;
-
-          UInt flag = 0;
-          for( i = ( numDU - 2 ); i >= 0; i -- )
-          {
-            flag = 0;
-            ui64Tmp = ( ( ( accumBitsDU[ numDU - 1 ]  - accumBitsDU[ i ] ) * ( vui->getTimingInfo()->getTimeScale() / vui->getTimingInfo()->getNumUnitsInTick() ) * ( hrd->getTickDivisorMinus2() + 2 ) ) / ( m_pcCfg->getTargetBitrate() ) );
-
-            if( (UInt)ui64Tmp > maxDiff )
-            {
-              if(uiPrev >= maxDiff - tmp)
-              {
-                ui64Tmp = uiPrev + 1;
-                flag = 1;
-              }
-              else
-              {
-                ui64Tmp = maxDiff - tmp + 1;
-              }
-            }
-            pCRD[ i ] = (UInt)ui64Tmp - uiPrev - 1;
-            if( (Int)pCRD[ i ] < 0 )
-            {
-              pCRD[ i ] = 0;
-            }
-            else if (tmp > 0 && flag == 1)
-            {
-              tmp --;
-            }
-            accum += pCRD[ i ] + 1;
-            uiPrev = accum;
-          }
-        }
-      }
-
-      if( m_pcCfg->getPictureTimingSEIEnabled() )
-      {
-        {
-          OutputNALUnit nalu(NAL_UNIT_PREFIX_SEI, pcSlice->getTLayer());
-          m_pcEntropyCoder->setEntropyCoder(m_pcCavlcCoder, pcSlice);
-          pictureTimingSEI.m_picStruct = (isField && pcSlice->getPic()->isTopField())? 1 : isField? 2 : 0;
+    xCreatePictureTimingSEI(IRAPGOPid, leadingSeiMessages, nestedSeiMessages, duInfoSeiMessages, accessUnit, pcSlice, isField, duData);
+    if (m_pcCfg->getScalableNestingSEIEnabled())
+    {
+      xCreateScalableNestingSEI (leadingSeiMessages, nestedSeiMessages);
+    }
 #if O0164_MULTI_LAYER_HRD
-          m_seiWriter.writeSEImessage(nalu.m_Bitstream, pictureTimingSEI, m_pcEncTop->getVPS(), pcSlice->getSPS());
-#else
-          m_seiWriter.writeSEImessage(nalu.m_Bitstream, pictureTimingSEI, pcSlice->getSPS());
-#endif
-          writeRBSPTrailingBits(nalu.m_Bitstream);
-          UInt seiPositionInAu = xGetFirstSeiLocation(accessUnit);
-          UInt offsetPosition = m_activeParameterSetSEIPresentInAU
-                                    + m_bufferingPeriodSEIPresentInAU;    // Insert PT SEI after APS and BP SEI
-          AccessUnit::iterator it = accessUnit.begin();
-          for(Int j = 0; j < seiPositionInAu + offsetPosition; j++)
-          {
-            it++;
-          }
-          accessUnit.insert(it, new NALUnitEBSP(nalu));
-          m_pictureTimingSEIPresentInAU = true;
-        }
-
-        if ( m_pcCfg->getScalableNestingSEIEnabled() ) // put picture timing SEI into scalable nesting SEI
-        {
-          OutputNALUnit nalu(NAL_UNIT_PREFIX_SEI, pcSlice->getTLayer());
-          m_pcEntropyCoder->setEntropyCoder(m_pcCavlcCoder, pcSlice);
-          scalableNestingSEI.m_nestedSEIs.clear();
-          scalableNestingSEI.m_nestedSEIs.push_back(&pictureTimingSEI);
+    xWriteLeadingSEIMessages(leadingSeiMessages, duInfoSeiMessages, accessUnit, pcSlice->getTLayer(), pcSlice->getVPS(), pcSlice->getSPS(), duData);
+#else
+    xWriteLeadingSEIMessages(leadingSeiMessages, duInfoSeiMessages, accessUnit, pcSlice->getTLayer(), pcSlice->getSPS(), duData);
+#endif
+    leadingSeiMessages.clear();
 #if O0164_MULTI_LAYER_HRD
-          m_seiWriter.writeSEImessage(nalu.m_Bitstream, scalableNestingSEI, m_pcEncTop->getVPS(), pcSlice->getSPS());
-#else
-          m_seiWriter.writeSEImessage(nalu.m_Bitstream, scalableNestingSEI, pcSlice->getSPS());
-#endif
-          writeRBSPTrailingBits(nalu.m_Bitstream);
-          UInt seiPositionInAu = xGetFirstSeiLocation(accessUnit);
-          UInt offsetPosition = m_activeParameterSetSEIPresentInAU
-            + m_bufferingPeriodSEIPresentInAU + m_pictureTimingSEIPresentInAU + m_nestedBufferingPeriodSEIPresentInAU;    // Insert PT SEI after APS and BP SEI
-          AccessUnit::iterator it = accessUnit.begin();
-          for(Int j = 0; j < seiPositionInAu + offsetPosition; j++)
-          {
-            it++;
-          }
-          accessUnit.insert(it, new NALUnitEBSP(nalu));
-          m_nestedPictureTimingSEIPresentInAU = true;
-        }
-      }
-
-      if( m_pcCfg->getDecodingUnitInfoSEIEnabled() && hrd->getSubPicCpbParamsPresentFlag() )
-      {
-        m_pcEntropyCoder->setEntropyCoder(m_pcCavlcCoder, pcSlice);
-        for( Int i = 0; i < ( pictureTimingSEI.m_numDecodingUnitsMinus1 + 1 ); i ++ )
-        {
-          OutputNALUnit nalu(NAL_UNIT_PREFIX_SEI, pcSlice->getTLayer());
-
-          SEIDecodingUnitInfo tempSEI;
-          tempSEI.m_decodingUnitIdx = i;
-          tempSEI.m_duSptCpbRemovalDelay = pictureTimingSEI.m_duCpbRemovalDelayMinus1[i] + 1;
-          tempSEI.m_dpbOutputDuDelayPresentFlag = false;
-          tempSEI.m_picSptDpbOutputDuDelay = picSptDpbOutputDuDelay;
-
-          // Insert the first one in the right location, before the first slice
-          if(i == 0)
-          {
-            // Insert before the first slice.
-#if O0164_MULTI_LAYER_HRD
-            m_seiWriter.writeSEImessage(nalu.m_Bitstream, tempSEI, m_pcEncTop->getVPS(), pcSlice->getSPS());
-#else
-            m_seiWriter.writeSEImessage(nalu.m_Bitstream, tempSEI, pcSlice->getSPS());
-#endif
-            writeRBSPTrailingBits(nalu.m_Bitstream);
-
-            UInt seiPositionInAu = xGetFirstSeiLocation(accessUnit);
-            UInt offsetPosition = m_activeParameterSetSEIPresentInAU
-                                  + m_bufferingPeriodSEIPresentInAU
-                                  + m_pictureTimingSEIPresentInAU;  // Insert DU info SEI after APS, BP and PT SEI
-            AccessUnit::iterator it = accessUnit.begin();
-            for(Int j = 0; j < seiPositionInAu + offsetPosition; j++)
-            {
-              it++;
-            }
-            accessUnit.insert(it, new NALUnitEBSP(nalu));
-          }
-          else
-          {
-            // For the second decoding unit onwards we know how many NALUs are present
-            AccessUnit::iterator it = accessUnit.begin();
-            for (Int ctr = 0; it != accessUnit.end(); it++)
-            {
-              if(ctr == accumNalsDU[ i - 1 ])
-              {
-                // Insert before the first slice.
-#if O0164_MULTI_LAYER_HRD
-                m_seiWriter.writeSEImessage(nalu.m_Bitstream, tempSEI, m_pcEncTop->getVPS(), pcSlice->getSPS());
-#else
-                m_seiWriter.writeSEImessage(nalu.m_Bitstream, tempSEI, pcSlice->getSPS());
-#endif
-                writeRBSPTrailingBits(nalu.m_Bitstream);
-
-                accessUnit.insert(it, new NALUnitEBSP(nalu));
-                break;
-              }
-              if ((*it)->m_nalUnitType != NAL_UNIT_PREFIX_SEI && (*it)->m_nalUnitType != NAL_UNIT_SUFFIX_SEI)
-              {
-                ctr++;
-              }
-            }
-          }
-        }
-      }
-    }
+    xWriteDuSEIMessages(duInfoSeiMessages, accessUnit, pcSlice->getTLayer(), pcSlice->getVPS(), pcSlice->getSPS(), duData);
+#else
+    xWriteDuSEIMessages(duInfoSeiMessages, accessUnit, pcSlice->getTLayer(), pcSlice->getSPS(), duData);
+#endif
 
 #if SVC_EXTENSION
@@ -3251 +2927 @@
 
   delete pcBitstreamRedirect;
-
-  if( accumBitsDU != NULL)
-  {
-    delete accumBitsDU;
-  }
-  if( accumNalsDU != NULL)
-  {
-    delete accumNalsDU;
-  }
 
 #if SVC_EXTENSION
@@ -3998 +3665 @@
 }
 
-/** Function for finding the position to insert the first of APS and non-nested BP, PT, DU info SEI messages.
- * \param accessUnit Access Unit of the current picture
- * This function finds the position to insert the first of APS and non-nested BP, PT, DU info SEI messages.
- */
-Int TEncGOP::xGetFirstSeiLocation(AccessUnit &accessUnit)
-{
-  // Find the location of the first SEI message
-  Int seiStartPos = 0;
-  for(AccessUnit::iterator it = accessUnit.begin(); it != accessUnit.end(); it++, seiStartPos++)
-  {
-     if ((*it)->isSei() || (*it)->isVcl())
-     {
-       break;
-     }
-  }
-  //  assert(it != accessUnit.end());  // Triggers with some legit configurations
-  return seiStartPos;
-}
-
 Void TEncGOP::applyDeblockingFilterMetric( TComPic* pcPic, UInt uiNumSlices )
 {
@@ -4141 +3789 @@
 }
 
-#if P0123_ALPHA_CHANNEL_SEI
-SEIAlphaChannelInfo* TEncGOP::xCreateSEIAlphaChannelInfo()
-{
-  SEIAlphaChannelInfo *sei = new SEIAlphaChannelInfo();
-  sei->m_alphaChannelCancelFlag = m_pcCfg->getAlphaCancelFlag();
-  if(!sei->m_alphaChannelCancelFlag)
-  {
-    sei->m_alphaChannelUseIdc = m_pcCfg->getAlphaUseIdc();
-    sei->m_alphaChannelBitDepthMinus8 = m_pcCfg->getAlphaBitDepthMinus8();
-    sei->m_alphaTransparentValue = m_pcCfg->getAlphaTransparentValue();
-    sei->m_alphaOpaqueValue = m_pcCfg->getAlphaOpaqueValue();
-    sei->m_alphaChannelIncrFlag = m_pcCfg->getAlphaIncrementFlag();
-    sei->m_alphaChannelClipFlag = m_pcCfg->getAlphaClipFlag();
-    sei->m_alphaChannelClipTypeFlag = m_pcCfg->getAlphaClipTypeFlag();
-  }
-  return sei;
-}
-#endif
-#if Q0096_OVERLAY_SEI
-SEIOverlayInfo* TEncGOP::xCreateSEIOverlayInfo()
-{  
-  SEIOverlayInfo *sei = new SEIOverlayInfo();  
-  sei->m_overlayInfoCancelFlag = m_pcCfg->getOverlaySEICancelFlag();    
-  if ( !sei->m_overlayInfoCancelFlag )
-  {
-    sei->m_overlayContentAuxIdMinus128          = m_pcCfg->getOverlaySEIContentAuxIdMinus128(); 
-    sei->m_overlayLabelAuxIdMinus128            = m_pcCfg->getOverlaySEILabelAuxIdMinus128();  
-    sei->m_overlayAlphaAuxIdMinus128            = m_pcCfg->getOverlaySEIAlphaAuxIdMinus128(); 
-    sei->m_overlayElementLabelValueLengthMinus8 = m_pcCfg->getOverlaySEIElementLabelValueLengthMinus8(); 
-    sei->m_numOverlaysMinus1                    = m_pcCfg->getOverlaySEINumOverlaysMinus1();     
-    sei->m_overlayIdx                           = m_pcCfg->getOverlaySEIIdx();            
-    sei->m_languageOverlayPresentFlag           = m_pcCfg->getOverlaySEILanguagePresentFlag();
-    sei->m_overlayContentLayerId                = m_pcCfg->getOverlaySEIContentLayerId();   
-    sei->m_overlayLabelPresentFlag              = m_pcCfg->getOverlaySEILabelPresentFlag();   
-    sei->m_overlayLabelLayerId                  = m_pcCfg->getOverlaySEILabelLayerId();   
-    sei->m_overlayAlphaPresentFlag              = m_pcCfg->getOverlaySEIAlphaPresentFlag();   
-    sei->m_overlayAlphaLayerId                  = m_pcCfg->getOverlaySEIAlphaLayerId();   
-    sei->m_numOverlayElementsMinus1             = m_pcCfg->getOverlaySEINumElementsMinus1();
-    sei->m_overlayElementLabelMin               = m_pcCfg->getOverlaySEIElementLabelMin();
-    sei->m_overlayElementLabelMax               = m_pcCfg->getOverlaySEIElementLabelMax();    
-    sei->m_overlayLanguage.resize               ( sei->m_numOverlaysMinus1+1, NULL );
-    sei->m_overlayLanguageLength.resize         ( sei->m_numOverlaysMinus1+1 );
-    sei->m_overlayName.resize                   ( sei->m_numOverlaysMinus1+1, NULL );
-    sei->m_overlayNameLength.resize             ( sei->m_numOverlaysMinus1+1 );
-    sei->m_overlayElementName.resize            ( sei->m_numOverlaysMinus1+1 );
-    sei->m_overlayElementNameLength.resize      ( sei->m_numOverlaysMinus1+1 );  
-
-    Int i,j;
-    string strTmp;
-    Int nBytes;
-    assert( m_pcCfg->getOverlaySEILanguage().size()    == sei->m_numOverlaysMinus1+1 );
-    assert( m_pcCfg->getOverlaySEIName().size()        == sei->m_numOverlaysMinus1+1 );
-    assert( m_pcCfg->getOverlaySEIElementName().size() == sei->m_numOverlaysMinus1+1 );
-    
-    for ( i=0 ; i<=sei->m_numOverlaysMinus1; i++ )
-    {      
-      //language tag
-      if ( sei->m_languageOverlayPresentFlag[i] )
-      {                
-        strTmp = m_pcCfg->getOverlaySEILanguage()[i];
-        nBytes = (Int)m_pcCfg->getOverlaySEILanguage()[i].size();        
-        assert( nBytes>0 );
-        sei->m_overlayLanguage[i] = new UChar[nBytes];
-        memcpy(sei->m_overlayLanguage[i], strTmp.c_str(), nBytes);        
-        sei->m_overlayLanguageLength[i] = nBytes;        
-      }
-
-      //overlay name
-      strTmp = m_pcCfg->getOverlaySEIName()[i];
-      nBytes = (Int)m_pcCfg->getOverlaySEIName()[i].size();        
-      assert( nBytes>0 );
-      sei->m_overlayName[i] = new UChar[nBytes];      
-      memcpy(sei->m_overlayName[i], strTmp.c_str(), nBytes);        
-      sei->m_overlayNameLength[i] = nBytes;
-
-      //overlay element names
-      if ( sei->m_overlayLabelPresentFlag[i] )
-      {        
-        sei->m_overlayElementName[i].resize( sei->m_numOverlayElementsMinus1[i]+1, NULL );
-        sei->m_overlayElementNameLength[i].resize( sei->m_numOverlayElementsMinus1[i]+1 );
-        assert( m_pcCfg->getOverlaySEIElementName()[i].size() == sei->m_numOverlayElementsMinus1[i]+1 );        
-        for ( j=0 ; j<=sei->m_numOverlayElementsMinus1[i] ; j++)
-        {
-          strTmp = m_pcCfg->getOverlaySEIElementName()[i][j];
-          nBytes = (Int)m_pcCfg->getOverlaySEIElementName()[i][j].size();        
-          assert( nBytes>0 );
-          sei->m_overlayElementName[i][j] = new UChar[nBytes];
-          memcpy(sei->m_overlayElementName[i][j], strTmp.c_str(), nBytes);        
-          sei->m_overlayElementNameLength[i][j] = nBytes;
-        }
-      }
-    }
-  sei->m_overlayInfoPersistenceFlag = true;
-  }
-  return sei;
-}
-#endif
-
-#if Q0074_COLOUR_REMAPPING_SEI
-SEIColourRemappingInfo*  TEncGOP::xCreateSEIColourRemappingInfo()
-{
-  SEIColourRemappingInfo *seiColourRemappingInfo = new SEIColourRemappingInfo();
-  seiColourRemappingInfo->m_colourRemapId         = m_colourRemapSEIId;
-  seiColourRemappingInfo->m_colourRemapCancelFlag = m_colourRemapSEICancelFlag;
-  printf("xCreateSEIColourRemappingInfo - m_colourRemapId = %d m_colourRemapCancelFlag = %d \n",seiColourRemappingInfo->m_colourRemapId, seiColourRemappingInfo->m_colourRemapCancelFlag); 
-
-  if( !seiColourRemappingInfo->m_colourRemapCancelFlag )
-  {
-    seiColourRemappingInfo->m_colourRemapPersistenceFlag            = m_colourRemapSEIPersistenceFlag;
-    seiColourRemappingInfo->m_colourRemapVideoSignalInfoPresentFlag = m_colourRemapSEIVideoSignalInfoPresentFlag;
-    if( seiColourRemappingInfo->m_colourRemapVideoSignalInfoPresentFlag )
-    {
-      seiColourRemappingInfo->m_colourRemapFullRangeFlag           = m_colourRemapSEIFullRangeFlag;
-      seiColourRemappingInfo->m_colourRemapPrimaries               = m_colourRemapSEIPrimaries;
-      seiColourRemappingInfo->m_colourRemapTransferFunction        = m_colourRemapSEITransferFunction;
-      seiColourRemappingInfo->m_colourRemapMatrixCoefficients      = m_colourRemapSEIMatrixCoefficients;
-    }
-    seiColourRemappingInfo->m_colourRemapInputBitDepth             = m_colourRemapSEIInputBitDepth;
-    seiColourRemappingInfo->m_colourRemapBitDepth                  = m_colourRemapSEIBitDepth;
-    for( Int c=0 ; c<3 ; c++ )
-    {
-      seiColourRemappingInfo->m_preLutNumValMinus1[c] = m_colourRemapSEIPreLutNumValMinus1[c];
-      if( seiColourRemappingInfo->m_preLutNumValMinus1[c]>0 )
-      {
-        seiColourRemappingInfo->m_preLutCodedValue[c].resize(seiColourRemappingInfo->m_preLutNumValMinus1[c]+1);
-        seiColourRemappingInfo->m_preLutTargetValue[c].resize(seiColourRemappingInfo->m_preLutNumValMinus1[c]+1);
-        for( Int i=0 ; i<=seiColourRemappingInfo->m_preLutNumValMinus1[c] ; i++)
-        {
-          seiColourRemappingInfo->m_preLutCodedValue[c][i]  = m_colourRemapSEIPreLutCodedValue[c][i];
-          seiColourRemappingInfo->m_preLutTargetValue[c][i] = m_colourRemapSEIPreLutTargetValue[c][i];
-        }
-      }
-    }
-    seiColourRemappingInfo->m_colourRemapMatrixPresentFlag = m_colourRemapSEIMatrixPresentFlag;
-    if( seiColourRemappingInfo->m_colourRemapMatrixPresentFlag )
-    {
-      seiColourRemappingInfo->m_log2MatrixDenom = m_colourRemapSEILog2MatrixDenom;
-      for( Int c=0 ; c<3 ; c++ )
-        for( Int i=0 ; i<3 ; i++ )
-          seiColourRemappingInfo->m_colourRemapCoeffs[c][i] = m_colourRemapSEICoeffs[c][i];
-    }
-    for( Int c=0 ; c<3 ; c++ )
-    {
-      seiColourRemappingInfo->m_postLutNumValMinus1[c] = m_colourRemapSEIPostLutNumValMinus1[c];
-      if( seiColourRemappingInfo->m_postLutNumValMinus1[c]>0 )
-      {
-        seiColourRemappingInfo->m_postLutCodedValue[c].resize(seiColourRemappingInfo->m_postLutNumValMinus1[c]+1);
-        seiColourRemappingInfo->m_postLutTargetValue[c].resize(seiColourRemappingInfo->m_postLutNumValMinus1[c]+1);
-        for( Int i=0 ; i<=seiColourRemappingInfo->m_postLutNumValMinus1[c] ; i++)
-        {
-          seiColourRemappingInfo->m_postLutCodedValue[c][i]  = m_colourRemapSEIPostLutCodedValue[c][i];
-          seiColourRemappingInfo->m_postLutTargetValue[c][i] = m_colourRemapSEIPostLutTargetValue[c][i];
-        }
-      }
-    }
-  }
-  return seiColourRemappingInfo;
-}
-#endif
-
 #if SVC_EXTENSION
-#if LAYERS_NOT_PRESENT_SEI
-SEILayersNotPresent* TEncGOP::xCreateSEILayersNotPresent ()
-{
-  UInt i = 0;
-  SEILayersNotPresent *seiLayersNotPresent = new SEILayersNotPresent(); 
-  seiLayersNotPresent->m_activeVpsId = m_pcCfg->getVPS()->getVPSId(); 
-  seiLayersNotPresent->m_vpsMaxLayers = m_pcCfg->getVPS()->getMaxLayers();
-  for ( ; i < seiLayersNotPresent->m_vpsMaxLayers; i++)
-  {
-    seiLayersNotPresent->m_layerNotPresentFlag[i] = true; 
-  }
-  for ( ; i < MAX_LAYERS; i++)
-  {
-    seiLayersNotPresent->m_layerNotPresentFlag[i] = false; 
-  }
-  return seiLayersNotPresent;
-}
-#endif
-
 #if N0383_IL_CONSTRAINED_TILE_SETS_SEI
-SEIInterLayerConstrainedTileSets* TEncGOP::xCreateSEIInterLayerConstrainedTileSets()
-{
-  SEIInterLayerConstrainedTileSets *seiInterLayerConstrainedTileSets = new SEIInterLayerConstrainedTileSets();
-  seiInterLayerConstrainedTileSets->m_ilAllTilesExactSampleValueMatchFlag = false;
-  seiInterLayerConstrainedTileSets->m_ilOneTilePerTileSetFlag = false;
-  if (!seiInterLayerConstrainedTileSets->m_ilOneTilePerTileSetFlag)
-  {
-    seiInterLayerConstrainedTileSets->m_ilNumSetsInMessageMinus1 = m_pcCfg->getIlNumSetsInMessage() - 1;
-    if (seiInterLayerConstrainedTileSets->m_ilNumSetsInMessageMinus1)
-    {
-      seiInterLayerConstrainedTileSets->m_skippedTileSetPresentFlag = m_pcCfg->getSkippedTileSetPresentFlag();
-    }
-    else
-    {
-      seiInterLayerConstrainedTileSets->m_skippedTileSetPresentFlag = false;
-    }
-    seiInterLayerConstrainedTileSets->m_ilNumSetsInMessageMinus1 += seiInterLayerConstrainedTileSets->m_skippedTileSetPresentFlag ? 1 : 0;
-    for (UInt i = 0; i < m_pcCfg->getIlNumSetsInMessage(); i++)
-    {
-      seiInterLayerConstrainedTileSets->m_ilctsId[i] = i;
-      seiInterLayerConstrainedTileSets->m_ilNumTileRectsInSetMinus1[i] = 0;
-      for( UInt j = 0; j <= seiInterLayerConstrainedTileSets->m_ilNumTileRectsInSetMinus1[i]; j++)
-      {
-        seiInterLayerConstrainedTileSets->m_ilTopLeftTileIndex[i][j]     = m_pcCfg->getTopLeftTileIndex(i);
-        seiInterLayerConstrainedTileSets->m_ilBottomRightTileIndex[i][j] = m_pcCfg->getBottomRightTileIndex(i);
-      }
-      seiInterLayerConstrainedTileSets->m_ilcIdc[i] = m_pcCfg->getIlcIdc(i);
-      if (seiInterLayerConstrainedTileSets->m_ilAllTilesExactSampleValueMatchFlag)
-      {
-        seiInterLayerConstrainedTileSets->m_ilExactSampleValueMatchFlag[i] = false;
-      }
-    }
-  }
-
-  return seiInterLayerConstrainedTileSets;
-}
-
 Void TEncGOP::xBuildTileSetsMap(TComPicSym* picSym)
 {
@@ -4670 +4102 @@
   }
 }
-
-#if O0164_MULTI_LAYER_HRD
-SEIScalableNesting* TEncGOP::xCreateBspNestingSEI(TComSlice *pcSlice, Int olsIdx, Int partitioningSchemeIdx, Int bspIdx)
-{
-  SEIScalableNesting *seiScalableNesting = new SEIScalableNesting();
-  SEIBspInitialArrivalTime *seiBspInitialArrivalTime = new SEIBspInitialArrivalTime();
-  SEIBspNesting *seiBspNesting = new SEIBspNesting();
-  SEIBufferingPeriod *seiBufferingPeriod = new SEIBufferingPeriod();
-
-  // Scalable nesting SEI
-
-  seiScalableNesting->m_bitStreamSubsetFlag           = 1;      // If the nested SEI messages are picture buffereing SEI mesages, picure timing SEI messages or sub-picture timing SEI messages, bitstream_subset_flag shall be equal to 1
-  seiScalableNesting->m_nestingOpFlag                 = 1;
-  seiScalableNesting->m_defaultOpFlag                 = 0;
-  seiScalableNesting->m_nestingNumOpsMinus1           = 0;      //nesting_num_ops_minus1
-  seiScalableNesting->m_nestingOpIdx[0]               = pcSlice->getVPS()->getOutputLayerSetIdx(olsIdx);
-  seiScalableNesting->m_nestingMaxTemporalIdPlus1[0]  = 6 + 1;
-  seiScalableNesting->m_allLayersFlag                 = 0;
-  seiScalableNesting->m_nestingNoOpMaxTemporalIdPlus1 = 6 + 1;  //nesting_no_op_max_temporal_id_plus1
-  seiScalableNesting->m_nestingNumLayersMinus1        = 1 - 1;  //nesting_num_layers_minus1
-  seiScalableNesting->m_nestingLayerId[0]             = 0;
-  seiScalableNesting->m_callerOwnsSEIs                = true;
-
-  // Bitstream partition nesting SEI
-
-  seiBspNesting->m_bspIdx = 0;
-  seiBspNesting->m_callerOwnsSEIs = true;
-
-  // Buffering period SEI
-
-  UInt uiInitialCpbRemovalDelay = (90000/2);                      // 0.5 sec
-  seiBufferingPeriod->m_initialCpbRemovalDelay      [0][0]     = uiInitialCpbRemovalDelay;
-  seiBufferingPeriod->m_initialCpbRemovalDelayOffset[0][0]     = uiInitialCpbRemovalDelay;
-  seiBufferingPeriod->m_initialCpbRemovalDelay      [0][1]     = uiInitialCpbRemovalDelay;
-  seiBufferingPeriod->m_initialCpbRemovalDelayOffset[0][1]     = uiInitialCpbRemovalDelay;
-
-  Double dTmp = (Double)pcSlice->getSPS()->getVuiParameters()->getTimingInfo()->getNumUnitsInTick() / (Double)pcSlice->getSPS()->getVuiParameters()->getTimingInfo()->getTimeScale();
-
-  UInt uiTmp = (UInt)( dTmp * 90000.0 ); 
-  uiInitialCpbRemovalDelay -= uiTmp;
-  uiInitialCpbRemovalDelay -= uiTmp / ( pcSlice->getSPS()->getVuiParameters()->getHrdParameters()->getTickDivisorMinus2() + 2 );
-  seiBufferingPeriod->m_initialAltCpbRemovalDelay      [0][0]  = uiInitialCpbRemovalDelay;
-  seiBufferingPeriod->m_initialAltCpbRemovalDelayOffset[0][0]  = uiInitialCpbRemovalDelay;
-  seiBufferingPeriod->m_initialAltCpbRemovalDelay      [0][1]  = uiInitialCpbRemovalDelay;
-  seiBufferingPeriod->m_initialAltCpbRemovalDelayOffset[0][1]  = uiInitialCpbRemovalDelay;
-
-  seiBufferingPeriod->m_rapCpbParamsPresentFlag              = 0;
-  //for the concatenation, it can be set to one during splicing.
-  seiBufferingPeriod->m_concatenationFlag = 0;
-  //since the temporal layer HRD is not ready, we assumed it is fixed
-  seiBufferingPeriod->m_auCpbRemovalDelayDelta = 1;
-  seiBufferingPeriod->m_cpbDelayOffset = 0;
-  seiBufferingPeriod->m_dpbDelayOffset = 0;
-
-  // Intial arrival time SEI message
-
-  seiBspInitialArrivalTime->m_nalInitialArrivalDelay[0] = 0;
-  seiBspInitialArrivalTime->m_vclInitialArrivalDelay[0] = 0;
-
-
-  seiBspNesting->m_nestedSEIs.push_back(seiBufferingPeriod);
-  seiBspNesting->m_nestedSEIs.push_back(seiBspInitialArrivalTime);
-  seiBspNesting->m_bspIdx = bspIdx;
-  seiBspNesting->m_seiOlsIdx = olsIdx;
-  seiBspNesting->m_seiPartitioningSchemeIdx = partitioningSchemeIdx;
-  seiScalableNesting->m_nestedSEIs.push_back(seiBspNesting); // BSP nesting SEI is contained in scalable nesting SEI
-
-  return seiScalableNesting;
-}
-#endif
 
 #if CGS_3D_ASYMLUT

branches/SHM-dev/source/Lib/TLibEncoder/TEncGOP.h

@@ -54 +54 @@
 #include "TEncSbac.h"
 #include "SEIwrite.h"
+#include "SEIEncoder.h"
 #if CGS_3D_ASYMLUT
 #include "TEnc3DAsymLUT.h"
@@ -73 +74 @@
 class TEncGOP
 {
+  class DUData
+  {
+  public:
+    DUData()
+    :accumBitsDU(0)
+    ,accumNalsDU(0) {};
+
+    Int accumBitsDU;
+    Int accumNalsDU;
+  };
+
 private:
   //  Data
@@ -88 +100 @@
 #endif
 
-#if Q0074_COLOUR_REMAPPING_SEI
-  string                  m_colourRemapSEIFile;
-  Int                     m_colourRemapSEIId;
-  Bool                    m_colourRemapSEICancelFlag;
-  Bool                    m_colourRemapSEIPersistenceFlag;
-  Bool                    m_colourRemapSEIVideoSignalInfoPresentFlag;
-  Bool                    m_colourRemapSEIFullRangeFlag;
-  Int                     m_colourRemapSEIPrimaries;
-  Int                     m_colourRemapSEITransferFunction;
-  Int                     m_colourRemapSEIMatrixCoefficients;
-  Int                     m_colourRemapSEIInputBitDepth;
-  Int                     m_colourRemapSEIBitDepth;
-  Int                     m_colourRemapSEIPreLutNumValMinus1[3];
-  Int*                    m_colourRemapSEIPreLutCodedValue[3];
-  Int*                    m_colourRemapSEIPreLutTargetValue[3];
-  Bool                    m_colourRemapSEIMatrixPresentFlag;
-  Int                     m_colourRemapSEILog2MatrixDenom;
-  Int                     m_colourRemapSEICoeffs[3][3];
-  Int                     m_colourRemapSEIPostLutNumValMinus1[3];
-  Int*                    m_colourRemapSEIPostLutCodedValue[3];
-  Int*                    m_colourRemapSEIPostLutTargetValue[3];
-#endif
   //  Access channel
   TEncTop*                m_pcEncTop;
@@ -139 +129 @@
   UInt                    m_lastBPSEI;
   UInt                    m_totalCoded;
-  UInt                    m_cpbRemovalDelay;
-  UInt                    m_tl0Idx;
-  UInt                    m_rapIdx;
   Bool                    m_activeParameterSetSEIPresentInAU;
   Bool                    m_bufferingPeriodSEIPresentInAU;
@@ -147 +134 @@
   Bool                    m_nestedBufferingPeriodSEIPresentInAU;
   Bool                    m_nestedPictureTimingSEIPresentInAU;
-
+  SEIEncoder              m_seiEncoder;
+
+#if Q0074_COLOUR_REMAPPING_SEI
+  TComSEIColourRemappingInfo m_seiColourRemappingInfo;  
+#endif
 #if SVC_EXTENSION
   Int                     m_pocCraWithoutReset;
@@ -236 +227 @@
   Double xCalculateRVM();
 
-  SEIActiveParameterSets*           xCreateSEIActiveParameterSets (const TComSPS *sps);
-  SEIFramePacking*                  xCreateSEIFramePacking();
-  SEISegmentedRectFramePacking*     xCreateSEISegmentedRectFramePacking();
-  SEIDisplayOrientation*            xCreateSEIDisplayOrientation();
-  SEIToneMappingInfo*               xCreateSEIToneMappingInfo();
-  SEITempMotionConstrainedTileSets* xCreateSEITempMotionConstrainedTileSets (const TComPPS *pps);
-  SEIKneeFunctionInfo*              xCreateSEIKneeFunctionInfo();
-  SEIChromaSamplingFilterHint*      xCreateSEIChromaSamplingFilterHint(Bool bChromaLocInfoPresent, Int iHorFilterIndex, Int iVerFilterIdc);
-
-  Void xCreateLeadingSEIMessages (/*SEIMessages seiMessages,*/ AccessUnit &accessUnit, const TComSPS *sps, const TComPPS *pps);
-  Int xGetFirstSeiLocation (AccessUnit &accessUnit);
+  Void xCreateIRAPLeadingSEIMessages (SEIMessages& seiMessages, const TComSPS *sps, const TComPPS *pps);
+  Void xCreatePerPictureSEIMessages (Int picInGOP, SEIMessages& seiMessages, SEIMessages& nestedSeiMessages, TComSlice *slice);
+  Void xCreatePictureTimingSEI  (Int IRAPGOPid, SEIMessages& seiMessages, SEIMessages& nestedSeiMessages, SEIMessages& duInfoSeiMessages, AccessUnit &accessUnit, TComSlice *slice, Bool isField, std::deque<DUData> &duData);
+  Void xUpdateDuData(AccessUnit &testAU, std::deque<DUData> &duData);
+  Void xUpdateTimingSEI(SEIPictureTiming *pictureTimingSEI, std::deque<DUData> &duData, const TComSPS *sps);
+  Void xUpdateDuInfoSEI(SEIMessages &duInfoSeiMessages, SEIPictureTiming *pictureTimingSEI);
+
+  Void xCreateScalableNestingSEI (SEIMessages& seiMessages, SEIMessages& nestedSeiMessages);
+#if O0164_MULTI_LAYER_HRD
+  Void xWriteSEI (NalUnitType naluType, SEIMessages& seiMessages, AccessUnit &accessUnit, AccessUnit::iterator &auPos, Int temporalId, const TComVPS *vps, const TComSPS *sps, const SEIScalableNesting* nestingSei=NULL, const SEIBspNesting* bspNestingSei=NULL);
+  Void xWriteSEISeparately (NalUnitType naluType, SEIMessages& seiMessages, AccessUnit &accessUnit, AccessUnit::iterator &auPos, Int temporalId, const TComVPS *vps, const TComSPS *sps, const SEIScalableNesting* nestingSei=NULL, const SEIBspNesting* bspNestingSei=NULL);
+#else
+  Void xWriteSEI (NalUnitType naluType, SEIMessages& seiMessages, AccessUnit &accessUnit, AccessUnit::iterator &auPos, Int temporalId, const TComSPS *sps);
+  Void xWriteSEISeparately (NalUnitType naluType, SEIMessages& seiMessages, AccessUnit &accessUnit, AccessUnit::iterator &auPos, Int temporalId, const TComSPS *sps);
+#endif
+  Void xClearSEIs(SEIMessages& seiMessages, Bool deleteMessages);
+#if O0164_MULTI_LAYER_HRD
+  Void xWriteLeadingSEIOrdered (SEIMessages& seiMessages, SEIMessages& duInfoSeiMessages, AccessUnit &accessUnit, Int temporalId, const TComVPS *vps, const TComSPS *sps, Bool testWrite, const SEIScalableNesting* nestingSei=NULL, const SEIBspNesting* bspNestingSei=NULL);
+  Void xWriteLeadingSEIMessages  (SEIMessages& seiMessages, SEIMessages& duInfoSeiMessages, AccessUnit &accessUnit, Int temporalId, const TComVPS *vps, const TComSPS *sps, std::deque<DUData> &duData, const SEIScalableNesting* nestingSei=NULL, const SEIBspNesting* bspNestingSei=NULL);
+  Void xWriteTrailingSEIMessages (SEIMessages& seiMessages, AccessUnit &accessUnit, Int temporalId, const TComVPS *vps, const TComSPS *sps, const SEIScalableNesting* nestingSei=NULL, const SEIBspNesting* bspNestingSei=NULL);
+  Void xWriteDuSEIMessages       (SEIMessages& duInfoSeiMessages, AccessUnit &accessUnit, Int temporalId, const TComVPS *sps, const TComSPS *vps, std::deque<DUData> &duData, const SEIScalableNesting* nestingSei=NULL, const SEIBspNesting* bspNestingSei=NULL);
+#else
+  Void xWriteLeadingSEIOrdered (SEIMessages& seiMessages, SEIMessages& duInfoSeiMessages, AccessUnit &accessUnit, Int temporalId, const TComSPS *sps, Bool testWrite);
+  Void xWriteLeadingSEIMessages  (SEIMessages& seiMessages, SEIMessages& duInfoSeiMessages, AccessUnit &accessUnit, Int temporalId, const TComSPS *sps, std::deque<DUData> &duData);
+  Void xWriteTrailingSEIMessages (SEIMessages& seiMessages, AccessUnit &accessUnit, Int temporalId, const TComSPS *sps);
+  Void xWriteDuSEIMessages       (SEIMessages& duInfoSeiMessages, AccessUnit &accessUnit, Int temporalId, const TComSPS *sps, std::deque<DUData> &duData);
+#endif
+
+  Int xWriteVPS (AccessUnit &accessUnit, const TComVPS *vps);
+  Int xWriteSPS (AccessUnit &accessUnit, const TComSPS *sps);
+  Int xWritePPS (AccessUnit &accessUnit, const TComPPS *pps);
+  Int xWriteParameterSets (AccessUnit &accessUnit, TComSlice *slice);
+
   Void xResetNonNestedSEIPresentFlags()
   {
@@ -261 +274 @@
 
 #if Q0074_COLOUR_REMAPPING_SEI
-  Void  setCRISEIFile( Char* pch )       { m_colourRemapSEIFile = pch; }
+  TComSEIColourRemappingInfo* xGetSEIColourRemappingInfo()  { return &m_seiColourRemappingInfo; }
+  Void  setCRISEIFile( Char* pch )       { m_seiColourRemappingInfo.m_colourRemapSEIFile = pch; }
 
   Void freeColourCRI();
   Int  readingCRIparameters();
   Void xCheckParameter();
-
-  SEIColourRemappingInfo* xCreateSEIColourRemappingInfo();
 #endif
 #if SVC_EXTENSION
-#if LAYERS_NOT_PRESENT_SEI
-  SEILayersNotPresent*    xCreateSEILayersNotPresent ();
-#endif
 #if N0383_IL_CONSTRAINED_TILE_SETS_SEI
   Void xBuildTileSetsMap(TComPicSym* picSym);
-  SEIInterLayerConstrainedTileSets* xCreateSEIInterLayerConstrainedTileSets();
-#endif
-#if O0164_MULTI_LAYER_HRD
-  SEIScalableNesting* xCreateBspNestingSEI(TComSlice *pcSlice, Int olsIdx, Int partitioningSchemeIdx, Int bspIdx);
-#endif
-#if P0123_ALPHA_CHANNEL_SEI
-  SEIAlphaChannelInfo* xCreateSEIAlphaChannelInfo();
-#endif
-#if Q0096_OVERLAY_SEI
-  SEIOverlayInfo* xCreateSEIOverlayInfo();
 #endif
 #if CGS_3D_ASYMLUT

branches/SHM-dev/source/Lib/TLibEncoder/TEncTop.cpp

@@ -994 +994 @@
   if( getPictureTimingSEIEnabled() || getDecodingUnitInfoSEIEnabled() )
   {
-#if SVC_EXTENSION
-    const UInt picWidth = m_cVPS.getPicWidthInLumaSamples(&m_cSPS, m_layerId);
-    const UInt picHeight= m_cVPS.getPicWidthInLumaSamples(&m_cSPS, m_layerId);
-#else
-    const UInt picWidth = m_cSPS.getPicWidthInLumaSamples();
-    const UInt picHeight= m_cSPS.getPicWidthInLumaSamples();
-#endif
-
-    const UInt frameWidthInCtus   = ( picWidth + g_uiMaxCUWidth -1 ) / g_uiMaxCUWidth;
-    const UInt frameHeightInCtus  = ( picHeight + g_uiMaxCUHeight - 1 ) / g_uiMaxCUHeight;
-    const UInt numCtusInFrame = frameWidthInCtus * frameHeightInCtus;
-
-    UInt maxCU = getSliceArgument();
-    UInt numDU = ( getSliceMode() == FIXED_NUMBER_OF_CTU ) ? ( numCtusInFrame / maxCU ) : ( 0 );
-    if( numCtusInFrame % maxCU != 0 || numDU == 0 )
-    {
-      numDU ++;
-    }
-    m_cSPS.getVuiParameters()->getHrdParameters()->setNumDU( numDU );
-    m_cSPS.setHrdParameters( getFrameRate(), numDU, getTargetBitrate(), ( getIntraPeriod() > 0 ) );
+    Bool useDUParameters = (getSliceMode() > 0) || (getSliceSegmentMode() > 0);
+    m_cSPS.setHrdParameters( getFrameRate(), useDUParameters, getTargetBitrate(), ( getIntraPeriod() > 0 ) );
   }
   if( getBufferingPeriodSEIEnabled() || getPictureTimingSEIEnabled() || getDecodingUnitInfoSEIEnabled() )
@@ -1019 +1001 @@
     m_cSPS.getVuiParameters()->setHrdParametersPresentFlag( true );
   }
-
 }