HEVC代码追踪（四。二）

/////////////////////////////////////////////////////////////////////////////////////////////////// Compress a slice
//  Slice compression
if (m_pcCfg->getUseASR())
{
m_pcSliceEncoder->setSearchRange(pcSlice);
}

Bool bGPBcheck=false;
if ( pcSlice->getSliceType() == B_SLICE)
{
if ( pcSlice->getNumRefIdx(RefPicList( 0 ) ) == pcSlice->getNumRefIdx(RefPicList( 1 ) ) )
{
bGPBcheck=true;
Int i;
for ( i=0; i < pcSlice->getNumRefIdx(RefPicList( 1 ) ); i++ )
{
if ( pcSlice->getRefPOC(RefPicList(1), i) != pcSlice->getRefPOC(RefPicList(0), i) )
{
bGPBcheck=false;
break;
}
}
}
}
if(bGPBcheck)
{
pcSlice->setMvdL1ZeroFlag(true);
}
else
{
pcSlice->setMvdL1ZeroFlag(false);
}
pcPic->getSlice(pcSlice->getSliceIdx())->setMvdL1ZeroFlag(pcSlice->getMvdL1ZeroFlag());

码率控制：对每一幅picture需要用到的相关参数进行初始化

Double lambda            = 0.0;
Int actualHeadBits       = 0;
Int actualTotalBits      = 0;
Int estimatedBits        = 0;
Int tmpBitsBeforeWriting = 0;
if ( m_pcCfg->getUseRateCtrl() )
{
Int frameLevel = m_pcRateCtrl->getRCSeq()->getGOPID2Level( iGOPid );
if ( pcPic->getSlice(0)->getSliceType() == I_SLICE )
{
frameLevel = 0;
}
m_pcRateCtrl->initRCPic( frameLevel );
estimatedBits = m_pcRateCtrl->getRCPic()->getTargetBits();

Int sliceQP = m_pcCfg->getInitialQP();
if ( ( pcSlice->getPOC() == 0 && m_pcCfg->getInitialQP() > 0 ) || ( frameLevel == 0 && m_pcCfg->getForceIntraQP() ) ) // QP is specified
{
Int    NumberBFrames = ( m_pcCfg->getGOPSize() - 1 );
Double dLambda_scale = 1.0 - Clip3( 0.0, 0.5, 0.05*(Double)NumberBFrames );
Double dQPFactor     = 0.57*dLambda_scale;
Int    SHIFT_QP      = 12;
Int    bitdepth_luma_qp_scale = 0;
Double qp_temp = (Double) sliceQP + bitdepth_luma_qp_scale - SHIFT_QP;
lambda = dQPFactor*pow( 2.0, qp_temp/3.0 );
}
else if ( frameLevel == 0 )   // intra case, but use the model
{
m_pcSliceEncoder->calCostSliceI(pcPic);
if ( m_pcCfg->getIntraPeriod() != 1 )   // do not refine allocated bits for all intra case
{
Int bits = m_pcRateCtrl->getRCSeq()->getLeftAverageBits();
bits = m_pcRateCtrl->getRCPic()->getRefineBitsForIntra( bits );
if ( bits < 200 )
{
bits = 200;
}
m_pcRateCtrl->getRCPic()->setTargetBits( bits );
}

list<TEncRCPic*> listPreviousPicture = m_pcRateCtrl->getPicList();
m_pcRateCtrl->getRCPic()->getLCUInitTargetBits();
lambda  = m_pcRateCtrl->getRCPic()->estimatePicLambda( listPreviousPicture, pcSlice->getSliceType());
sliceQP = m_pcRateCtrl->getRCPic()->estimatePicQP( lambda, listPreviousPicture );
}
else    // normal case
{
list<TEncRCPic*> listPreviousPicture = m_pcRateCtrl->getPicList();
lambda  = m_pcRateCtrl->getRCPic()->estimatePicLambda( listPreviousPicture, pcSlice->getSliceType());
sliceQP = m_pcRateCtrl->getRCPic()->estimatePicQP( lambda, listPreviousPicture );
}

sliceQP = Clip3( -pcSlice->getSPS()->getQpBDOffsetY(), MAX_QP, sliceQP );
m_pcRateCtrl->getRCPic()->setPicEstQP( sliceQP );

m_pcSliceEncoder->resetQP( pcPic, sliceQP, lambda );
}

/*Slice Compression部分*/
UInt uiNumSlices = 1;

UInt uiInternalAddress = pcPic->getNumPartInCU()-4;//CU内部Zscan顺序
UInt uiExternalAddress = pcPic->getPicSym()->getNumberOfCUsInFrame()-1;//CU相对于整帧图像的位置
UInt uiPosX = ( uiExternalAddress % pcPic->getFrameWidthInCU() ) * g_uiMaxCUWidth+ g_auiRasterToPelX[ g_auiZscanToRaster[uiInternalAddress] ];//CU的绝对位置
UInt uiPosY = ( uiExternalAddress / pcPic->getFrameWidthInCU() ) * g_uiMaxCUHeight+ g_auiRasterToPelY[ g_auiZscanToRaster[uiInternalAddress] ];
UInt uiWidth = pcSlice->getSPS()->getPicWidthInLumaSamples();
UInt uiHeight = pcSlice->getSPS()->getPicHeightInLumaSamples();
while(uiPosX>=uiWidth||uiPosY>=uiHeight)
{
uiInternalAddress--;
uiPosX = ( uiExternalAddress % pcPic->getFrameWidthInCU() ) * g_uiMaxCUWidth+ g_auiRasterToPelX[ g_auiZscanToRaster[uiInternalAddress] ];
uiPosY = ( uiExternalAddress / pcPic->getFrameWidthInCU() ) * g_uiMaxCUHeight+ g_auiRasterToPelY[ g_auiZscanToRaster[uiInternalAddress] ];
}
uiInternalAddress++;
if(uiInternalAddress==pcPic->getNumPartInCU())
{
uiInternalAddress = 0;
uiExternalAddress++;
}
UInt uiRealEndAddress = uiExternalAddress*pcPic->getNumPartInCU()+uiInternalAddress;

Int  p, j;
UInt uiEncCUAddr;

pcPic->getPicSym()->initTiles(pcSlice->getPPS());

// Allocate some coders, now we know how many tiles there are.
Int iNumSubstreams = pcSlice->getPPS()->getNumSubstreams();

//generate the Coding Order Map and Inverse Coding Order Map
for(p=0, uiEncCUAddr=0; p<pcPic->getPicSym()->getNumberOfCUsInFrame(); p++, uiEncCUAddr = pcPic->getPicSym()->xCalculateNxtCUAddr(uiEncCUAddr))
{
pcPic->getPicSym()->setCUOrderMap(p, uiEncCUAddr);
pcPic->getPicSym()->setInverseCUOrderMap(uiEncCUAddr, p);
}
pcPic->getPicSym()->setCUOrderMap(pcPic->getPicSym()->getNumberOfCUsInFrame(), pcPic->getPicSym()->getNumberOfCUsInFrame());
pcPic->getPicSym()->setInverseCUOrderMap(pcPic->getPicSym()->getNumberOfCUsInFrame(), pcPic->getPicSym()->getNumberOfCUsInFrame());

// Allocate some coders, now we know how many tiles there are.
m_pcEncTop->createWPPCoders(iNumSubstreams);
pcSbacCoders = m_pcEncTop->getSbacCoders();
pcSubstreamsOut = new TComOutputBitstream[iNumSubstreams];

UInt startCUAddrSliceIdx = 0; // used to index "m_uiStoredStartCUAddrForEncodingSlice" containing locations of slice boundaries
UInt startCUAddrSlice    = 0; // used to keep track of current slice's starting CU addr.
pcSlice->setSliceCurStartCUAddr( startCUAddrSlice ); // Setting "start CU addr" for current slice
m_storedStartCUAddrForEncodingSlice.clear();

UInt startCUAddrSliceSegmentIdx = 0; // used to index "m_uiStoredStartCUAddrForEntropyEncodingSlice" containing locations of slice boundaries
UInt startCUAddrSliceSegment    = 0; // used to keep track of current Dependent slice's starting CU addr.
pcSlice->setSliceSegmentCurStartCUAddr( startCUAddrSliceSegment ); // Setting "start CU addr" for current Dependent slice

m_storedStartCUAddrForEncodingSliceSegment.clear();
UInt nextCUAddr = 0;
m_storedStartCUAddrForEncodingSlice.push_back (nextCUAddr);
startCUAddrSliceIdx++;
m_storedStartCUAddrForEncodingSliceSegment.push_back(nextCUAddr);
startCUAddrSliceSegmentIdx++;

while(nextCUAddr<uiRealEndAddress) // determine slice boundaries
{
pcSlice->setNextSlice       ( false );
pcSlice->setNextSliceSegment( false );
assert(pcPic->getNumAllocatedSlice() == startCUAddrSliceIdx);
m_pcSliceEncoder->precompressSlice( pcPic );
m_pcSliceEncoder->compressSlice   ( pcPic );

Bool bNoBinBitConstraintViolated = (!pcSlice->isNextSlice() && !pcSlice->isNextSliceSegment());
if (pcSlice->isNextSlice() || (bNoBinBitConstraintViolated && m_pcCfg->getSliceMode()==FIXED_NUMBER_OF_LCU))
{
startCUAddrSlice = pcSlice->getSliceCurEndCUAddr();
// Reconstruction slice
m_storedStartCUAddrForEncodingSlice.push_back(startCUAddrSlice);
startCUAddrSliceIdx++;
// Dependent slice
if (startCUAddrSliceSegmentIdx>0 && m_storedStartCUAddrForEncodingSliceSegment[startCUAddrSliceSegmentIdx-1] != startCUAddrSlice)
{
m_storedStartCUAddrForEncodingSliceSegment.push_back(startCUAddrSlice);
startCUAddrSliceSegmentIdx++;
}

if (startCUAddrSlice < uiRealEndAddress)
{
pcPic->allocateNewSlice();
pcPic->setCurrSliceIdx                  ( startCUAddrSliceIdx-1 );
m_pcSliceEncoder->setSliceIdx           ( startCUAddrSliceIdx-1 );
pcSlice = pcPic->getSlice               ( startCUAddrSliceIdx-1 );
pcSlice->copySliceInfo                  ( pcPic->getSlice(0)      );
pcSlice->setSliceIdx                    ( startCUAddrSliceIdx-1 );
pcSlice->setSliceCurStartCUAddr         ( startCUAddrSlice      );
pcSlice->setSliceSegmentCurStartCUAddr  ( startCUAddrSlice      );
pcSlice->setSliceBits(0);
uiNumSlices ++;
}
}
else if (pcSlice->isNextSliceSegment() || (bNoBinBitConstraintViolated && m_pcCfg->getSliceSegmentMode()==FIXED_NUMBER_OF_LCU))
{
startCUAddrSliceSegment                                                     = pcSlice->getSliceSegmentCurEndCUAddr();
m_storedStartCUAddrForEncodingSliceSegment.push_back(startCUAddrSliceSegment);
startCUAddrSliceSegmentIdx++;
pcSlice->setSliceSegmentCurStartCUAddr( startCUAddrSliceSegment );
}
else
{
startCUAddrSlice                                                            = pcSlice->getSliceCurEndCUAddr();
startCUAddrSliceSegment                                                     = pcSlice->getSliceSegmentCurEndCUAddr();
}

nextCUAddr = (startCUAddrSlice > startCUAddrSliceSegment) ? startCUAddrSlice : startCUAddrSliceSegment;
}
m_storedStartCUAddrForEncodingSlice.push_back( pcSlice->getSliceCurEndCUAddr());
startCUAddrSliceIdx++;
m_storedStartCUAddrForEncodingSliceSegment.push_back(pcSlice->getSliceCurEndCUAddr());
startCUAddrSliceSegmentIdx++;

pcSlice = pcPic->getSlice(0);

// SAO parameter estimation using non-deblocked pixels for LCU bottom and right boundary areas
if( pcSlice->getSPS()->getUseSAO() && m_pcCfg->getSaoLcuBoundary() )
{
m_pcSAO->getPreDBFStatistics(pcPic);
}
//-- Loop filter
Bool bLFCrossTileBoundary = pcSlice->getPPS()->getLoopFilterAcrossTilesEnabledFlag();
m_pcLoopFilter->setCfg(bLFCrossTileBoundary);
if ( m_pcCfg->getDeblockingFilterMetric() )
{
dblMetric(pcPic, uiNumSlices);
}
m_pcLoopFilter->loopFilterPic( pcPic );

/////////////////////////////////////////////////////////////////////////////////////////////////// File writing
// Set entropy coder
m_pcEntropyCoder->setEntropyCoder   ( m_pcCavlcCoder, pcSlice );

/* write various header sets. */
if ( m_bSeqFirst )
{
OutputNALUnit nalu(NAL_UNIT_VPS);
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;

nalu = NALUnit(NAL_UNIT_SPS);
m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
if (m_bSeqFirst)
{
pcSlice->getSPS()->setNumLongTermRefPicSPS(m_numLongTermRefPicSPS);
for (Int k = 0; k < m_numLongTermRefPicSPS; k++)
{
pcSlice->getSPS()->setLtRefPicPocLsbSps(k, m_ltRefPicPocLsbSps[k]);
pcSlice->getSPS()->setUsedByCurrPicLtSPSFlag(k, m_ltRefPicUsedByCurrPicFlag[k]);
}
}
if( m_pcCfg->getPictureTimingSEIEnabled() || m_pcCfg->getDecodingUnitInfoSEIEnabled() )
{
UInt maxCU = m_pcCfg->getSliceArgument() >> ( pcSlice->getSPS()->getMaxCUDepth() << 1);
UInt numDU = ( m_pcCfg->getSliceMode() == 1 ) ? ( pcPic->getNumCUsInFrame() / maxCU ) : ( 0 );
if( pcPic->getNumCUsInFrame() % maxCU != 0 || numDU == 0 )
{
numDU ++;
}
pcSlice->getSPS()->getVuiParameters()->getHrdParameters()->setNumDU( numDU );
pcSlice->getSPS()->setHrdParameters( m_pcCfg->getFrameRate(), numDU, m_pcCfg->getTargetBitrate(), ( m_pcCfg->getIntraPeriod() > 0 ) );
}
if( m_pcCfg->getBufferingPeriodSEIEnabled() || m_pcCfg->getPictureTimingSEIEnabled() || m_pcCfg->getDecodingUnitInfoSEIEnabled() )
{
pcSlice->getSPS()->getVuiParameters()->setHrdParametersPresentFlag( true );
}
m_pcEntropyCoder->encodeSPS(pcSlice->getSPS());
writeRBSPTrailingBits(nalu.m_Bitstream);
accessUnit.push_back(new NALUnitEBSP(nalu));
actualTotalBits += UInt(accessUnit.back()->m_nalUnitData.str().size()) * 8;

nalu = NALUnit(NAL_UNIT_PPS);
m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
m_pcEntropyCoder->encodePPS(pcSlice->getPPS());
writeRBSPTrailingBits(nalu.m_Bitstream);
accessUnit.push_back(new NALUnitEBSP(nalu));
actualTotalBits += UInt(accessUnit.back()->m_nalUnitData.str().size()) * 8;

xCreateLeadingSEIMessages(accessUnit, pcSlice->getSPS());

m_bSeqFirst = false;
}

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 (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;

m_seiWriter.writeSEImessage( nalu.m_Bitstream, SOPDescriptionSEI, pcSlice->getSPS());
writeRBSPTrailingBits(nalu.m_Bitstream);
accessUnit.push_back(new NALUnitEBSP(nalu));

writeSOP = false;
}

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 .
pictureTimingSEI.m_picDpbOutputDelay = pcSlice->getSPS()->getNumReorderPics(pcSlice->getSPS()->getMaxTLayers()-1) + pcSlice->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 = 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;

m_seiWriter.writeSEImessage( nalu.m_Bitstream, sei_buffering_period, pcSlice->getSPS());
writeRBSPTrailingBits(nalu.m_Bitstream);
{
UInt seiPositionInAu = xGetFirstSeiLocation(accessUnit);
UInt offsetPosition = m_activeParameterSetSEIPresentInAU;   // Insert BP SEI after APS SEI
AccessUnit::iterator it;
for(j = 0, it = accessUnit.begin(); 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);
m_seiWriter.writeSEImessage( naluTmp.m_Bitstream, scalableNestingSEI, pcSlice->getSPS());
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;
for(j = 0, it = accessUnit.begin(); j < seiPositionInAu + offsetPosition; j++)
{
it++;
}
accessUnit.insert(it, new NALUnitEBSP(naluTmp));
m_nestedBufferingPeriodSEIPresentInAU = true;
}

m_lastBPSEI = m_totalCoded;
m_cpbRemovalDelay = 0;
}
m_cpbRemovalDelay ++;
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"

m_seiWriter.writeSEImessage( nalu.m_Bitstream, seiGradualDecodingRefreshInfo, pcSlice->getSPS() );
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;
sei_recovery_point.m_exactMatchingFlag = ( pcSlice->getPOC() == 0 ) ? (true) : (false);
sei_recovery_point.m_brokenLinkFlag    = false;
#if ALLOW_RECOVERY_POINT_AS_RAP
if(m_pcCfg->getDecodingRefreshType() == 3)
{
m_iLastRecoveryPicPOC = pocCurr;
}
#endif

m_seiWriter.writeSEImessage( nalu.m_Bitstream, sei_recovery_point, pcSlice->getSPS() );
writeRBSPTrailingBits(nalu.m_Bitstream);
accessUnit.push_back(new NALUnitEBSP(nalu));
}