/** derivation of wp tables
* \param TComDataCU* cu
* \param refIdx0
* \param refIdx1
* \param wpScalingParam *&wp0
* \param wpScalingParam *&wp1
* \param ibdi
* \returns void
*/
void TComWeightPrediction::getWpScaling(TComDataCU* cu, int refIdx0, int refIdx1, wpScalingParam *&wp0, wpScalingParam *&wp1)
{
TComSlice* slice = cu->getSlice();
const TComPPS* pps = cu->getSlice()->getPPS();
bool wpBiPred = pps->getWPBiPred();
wpScalingParam* pwp;
bool bBiDir = (refIdx0 >= 0 && refIdx1 >= 0);
bool bUniDir = !bBiDir;
if (bUniDir || wpBiPred)
{ // explicit --------------------
if (refIdx0 >= 0)
{
slice->getWpScaling(REF_PIC_LIST_0, refIdx0, wp0);
}
if (refIdx1 >= 0)
{
slice->getWpScaling(REF_PIC_LIST_1, refIdx1, wp1);
}
}
else
{
X265_CHECK(0, "unexpected wpScaling configuration\n");
}
if (refIdx0 < 0)
{
wp0 = NULL;
}
if (refIdx1 < 0)
{
wp1 = NULL;
}
if (bBiDir)
{ // Bi-Dir case
for (int yuv = 0; yuv < 3; yuv++)
{
wp0[yuv].w = wp0[yuv].inputWeight;
wp0[yuv].o = wp0[yuv].inputOffset * (1 << (X265_DEPTH - 8));
wp1[yuv].w = wp1[yuv].inputWeight;
wp1[yuv].o = wp1[yuv].inputOffset * (1 << (X265_DEPTH - 8));
wp0[yuv].shift = wp0[yuv].log2WeightDenom;
wp0[yuv].round = (1 << wp0[yuv].log2WeightDenom);
wp1[yuv].shift = wp0[yuv].shift;
wp1[yuv].round = wp0[yuv].round;
}
}
else
{ // Unidir
pwp = (refIdx0 >= 0) ? wp0 : wp1;
for (int yuv = 0; yuv < 3; yuv++)
{
pwp[yuv].w = pwp[yuv].inputWeight;
pwp[yuv].offset = pwp[yuv].inputOffset * (1 << (X265_DEPTH - 8));
pwp[yuv].shift = pwp[yuv].log2WeightDenom;
pwp[yuv].round = (pwp[yuv].log2WeightDenom >= 1) ? (1 << (pwp[yuv].log2WeightDenom - 1)) : (0);
}
}
}
void FrameEncoder::setLambda(int qp, int row)
{
TComSlice* slice = m_pic->getSlice();
TComPicYuv *fenc = slice->getPic()->getPicYuvOrg();
double lambda = 0;
if (m_pic->getSlice()->getSliceType() == I_SLICE)
{
lambda = X265_MAX(1, x265_lambda2_tab_I[qp]);
}
else
{
lambda = X265_MAX(1, x265_lambda2_non_I[qp]);
}
// for RDO
// in RdCost there is only one lambda because the luma and chroma bits are not separated,
// instead we weight the distortion of chroma.
int chromaQPOffset = slice->getPPS()->getChromaCbQpOffset() + slice->getSliceQpDeltaCb();
int qpc = Clip3(0, 70, qp + chromaQPOffset);
double cbWeight = pow(2.0, (qp - g_chromaScale[qpc])); // takes into account of the chroma qp mapping and chroma qp Offset
chromaQPOffset = slice->getPPS()->getChromaCrQpOffset() + slice->getSliceQpDeltaCr();
qpc = Clip3(0, 70, qp + chromaQPOffset);
double crWeight = pow(2.0, (qp - g_chromaScale[qpc])); // takes into account of the chroma qp mapping and chroma qp Offset
double chromaLambda = lambda / crWeight;
m_rows[row].m_search.setQPLambda(qp, lambda, chromaLambda);
m_rows[row].m_search.m_me.setSourcePlane(fenc->getLumaAddr(), fenc->getStride());
m_rows[row].m_rdCost.setLambda(lambda);
m_rows[row].m_rdCost.setCbDistortionWeight(cbWeight);
m_rows[row].m_rdCost.setCrDistortionWeight(crWeight);
}
void DPB::prepareEncode(TComPic *pic)
{
PPAScopeEvent(DPB_prepareEncode);
int pocCurr = pic->getSlice()->getPOC();
m_picList.pushFront(*pic);
TComSlice* slice = pic->getSlice();
if (getNalUnitType(pocCurr, m_lastIDR, pic) == NAL_UNIT_CODED_SLICE_IDR_W_RADL ||
getNalUnitType(pocCurr, m_lastIDR, pic) == NAL_UNIT_CODED_SLICE_IDR_N_LP)
{
m_lastIDR = pocCurr;
}
slice->setLastIDR(m_lastIDR);
slice->setTemporalLayerNonReferenceFlag(!slice->isReferenced());
// Set the nal unit type
slice->setNalUnitType(getNalUnitType(pocCurr, m_lastIDR, pic));
// If the slice is un-referenced, change from _R "referenced" to _N "non-referenced" NAL unit type
if (slice->getTemporalLayerNonReferenceFlag())
{
switch (slice->getNalUnitType())
{
case NAL_UNIT_CODED_SLICE_TRAIL_R:
slice->setNalUnitType(NAL_UNIT_CODED_SLICE_TRAIL_N);
break;
case NAL_UNIT_CODED_SLICE_RADL_R:
slice->setNalUnitType(NAL_UNIT_CODED_SLICE_RADL_N);
break;
case NAL_UNIT_CODED_SLICE_RASL_R:
slice->setNalUnitType(NAL_UNIT_CODED_SLICE_RASL_N);
break;
default:
break;
}
}
// Do decoding refresh marking if any
decodingRefreshMarking(pocCurr, slice->getNalUnitType());
computeRPS(pocCurr, slice->isIRAP(), slice->getLocalRPS(), slice->getSPS()->getMaxDecPicBuffering(0));
slice->setRPS(slice->getLocalRPS());
slice->setRPSidx(-1); // Force use of RPS from slice, rather than from SPS
applyReferencePictureSet(slice->getRPS(), pocCurr); // Mark pictures in m_piclist as unreferenced if they are not included in RPS
arrangeLongtermPicturesInRPS(slice);
slice->setNumRefIdx(REF_PIC_LIST_0, X265_MIN(m_maxRefL0, slice->getRPS()->getNumberOfNegativePictures())); // Ensuring L0 contains just the -ve POC
slice->setNumRefIdx(REF_PIC_LIST_1, X265_MIN(m_maxRefL1, slice->getRPS()->getNumberOfPositivePictures()));
slice->setRefPicList(m_picList);
// Slice type refinement
if ((slice->getSliceType() == B_SLICE) && (slice->getNumRefIdx(REF_PIC_LIST_1) == 0))
{
slice->setSliceType(P_SLICE);
}
if (slice->getSliceType() == B_SLICE)
{
// TODO: Can we estimate this from lookahead?
slice->setColFromL0Flag(0);
bool bLowDelay = true;
int curPOC = slice->getPOC();
int refIdx = 0;
for (refIdx = 0; refIdx < slice->getNumRefIdx(REF_PIC_LIST_0) && bLowDelay; refIdx++)
{
if (slice->getRefPic(REF_PIC_LIST_0, refIdx)->getPOC() > curPOC)
{
bLowDelay = false;
}
}
for (refIdx = 0; refIdx < slice->getNumRefIdx(REF_PIC_LIST_1) && bLowDelay; refIdx++)
{
if (slice->getRefPic(REF_PIC_LIST_1, refIdx)->getPOC() > curPOC)
{
bLowDelay = false;
}
}
slice->setCheckLDC(bLowDelay);
}
else
{
slice->setCheckLDC(true);
}
slice->setRefPOCList();
slice->setEnableTMVPFlag(1);
bool bGPBcheck = false;
if (slice->getSliceType() == B_SLICE)
{
if (slice->getNumRefIdx(REF_PIC_LIST_0) == slice->getNumRefIdx(REF_PIC_LIST_1))
{
bGPBcheck = true;
for (int i = 0; i < slice->getNumRefIdx(REF_PIC_LIST_1); i++)
{
if (slice->getRefPOC(REF_PIC_LIST_1, i) != slice->getRefPOC(REF_PIC_LIST_0, i))
{
bGPBcheck = false;
break;
}
}
}
}
slice->setMvdL1ZeroFlag(bGPBcheck);
slice->setNextSlice(false);
/* Increment reference count of all motion-referenced frames. This serves two purposes. First
* it prevents the frame from being recycled, and second the referenced frames know how many
* other FrameEncoders are using them for motion reference */
int numPredDir = slice->isInterP() ? 1 : slice->isInterB() ? 2 : 0;
for (int l = 0; l < numPredDir; l++)
{
for (int ref = 0; ref < slice->getNumRefIdx(l); ref++)
{
TComPic *refpic = slice->getRefPic(l, ref);
ATOMIC_INC(&refpic->m_countRefEncoders);
}
}
}
Void TDecGop::filterPicture(TComPic*& rpcPic)
{
TComSlice* pcSlice = rpcPic->getSlice(rpcPic->getCurrSliceIdx());
//-- For time output for each slice
long iBeforeTime = clock();
// deblocking filter
Bool bLFCrossTileBoundary = pcSlice->getPPS()->getLoopFilterAcrossTilesEnabledFlag();
m_pcLoopFilter->setCfg(bLFCrossTileBoundary);
m_pcLoopFilter->loopFilterPic( rpcPic );
if(pcSlice->getSPS()->getUseSAO())
{
m_sliceStartCUAddress.push_back(rpcPic->getNumCUsInFrame()* rpcPic->getNumPartInCU());
rpcPic->createNonDBFilterInfo(m_sliceStartCUAddress, 0, &m_LFCrossSliceBoundaryFlag, rpcPic->getPicSym()->getNumTiles(), bLFCrossTileBoundary);
}
if( pcSlice->getSPS()->getUseSAO() )
{
{
SAOParam *saoParam = rpcPic->getPicSym()->getSaoParam();
saoParam->bSaoFlag[0] = pcSlice->getSaoEnabledFlag();
saoParam->bSaoFlag[1] = pcSlice->getSaoEnabledFlagChroma();
m_pcSAO->setSaoLcuBasedOptimization(1);
m_pcSAO->createPicSaoInfo(rpcPic);
m_pcSAO->SAOProcess(saoParam);
m_pcSAO->PCMLFDisableProcess(rpcPic);
m_pcSAO->destroyPicSaoInfo();
}
}
if(pcSlice->getSPS()->getUseSAO())
{
rpcPic->destroyNonDBFilterInfo();
}
#if H_3D
rpcPic->compressMotion(2);
#endif
#if !H_3D
rpcPic->compressMotion();
#endif
Char c = (pcSlice->isIntra() ? 'I' : pcSlice->isInterP() ? 'P' : 'B');
if (!pcSlice->isReferenced()) c += 32;
//-- For time output for each slice
#if H_MV
printf("\nLayer %2d POC %4d TId: %1d ( %c-SLICE, QP%3d ) ", pcSlice->getLayerId(),
pcSlice->getPOC(),
pcSlice->getTLayer(),
c,
pcSlice->getSliceQp() );
#else
printf("\nPOC %4d TId: %1d ( %c-SLICE, QP%3d ) ", pcSlice->getPOC(),
pcSlice->getTLayer(),
c,
pcSlice->getSliceQp() );
#endif
m_dDecTime += (Double)(clock()-iBeforeTime) / CLOCKS_PER_SEC;
printf ("[DT %6.3f] ", m_dDecTime );
m_dDecTime = 0;
for (Int iRefList = 0; iRefList < 2; iRefList++)
{
printf ("[L%d ", iRefList);
for (Int iRefIndex = 0; iRefIndex < pcSlice->getNumRefIdx(RefPicList(iRefList)); iRefIndex++)
{
#if H_MV
if( pcSlice->getLayerId() != pcSlice->getRefLayerId( RefPicList(iRefList), iRefIndex ) )
{
printf( "V%d ", pcSlice->getRefLayerId( RefPicList(iRefList), iRefIndex ) );
}
else
{
#endif
printf ("%d ", pcSlice->getRefPOC(RefPicList(iRefList), iRefIndex));
#if H_MV
}
#endif
}
printf ("] ");
}
if (m_decodedPictureHashSEIEnabled)
{
SEIMessages pictureHashes = getSeisByType(rpcPic->getSEIs(), SEI::DECODED_PICTURE_HASH );
const SEIDecodedPictureHash *hash = ( pictureHashes.size() > 0 ) ? (SEIDecodedPictureHash*) *(pictureHashes.begin()) : NULL;
if (pictureHashes.size() > 1)
{
printf ("Warning: Got multiple decoded picture hash SEI messages. Using first.");
}
calcAndPrintHashStatus(*rpcPic->getPicYuvRec(), hash);
}
rpcPic->setOutputMark(true);
rpcPic->setReconMark(true);
m_sliceStartCUAddress.clear();
m_LFCrossSliceBoundaryFlag.clear();
}
Void TDecGop::decompressSlice(TComInputBitstream* pcBitstream, TComPic*& rpcPic)
{
TComSlice* pcSlice = rpcPic->getSlice(rpcPic->getCurrSliceIdx());
// Table of extracted substreams.
// These must be deallocated AND their internal fifos, too.
TComInputBitstream **ppcSubstreams = NULL;
//-- For time output for each slice
long iBeforeTime = clock();
UInt uiStartCUAddr = pcSlice->getSliceSegmentCurStartCUAddr();
UInt uiSliceStartCuAddr = pcSlice->getSliceCurStartCUAddr();
if(uiSliceStartCuAddr == uiStartCUAddr)
{
m_sliceStartCUAddress.push_back(uiSliceStartCuAddr);
}
m_pcSbacDecoder->init( (TDecBinIf*)m_pcBinCABAC );
m_pcEntropyDecoder->setEntropyDecoder (m_pcSbacDecoder);
UInt uiNumSubstreams = pcSlice->getPPS()->getEntropyCodingSyncEnabledFlag() ? pcSlice->getNumEntryPointOffsets()+1 : pcSlice->getPPS()->getNumSubstreams();
// init each couple {EntropyDecoder, Substream}
UInt *puiSubstreamSizes = pcSlice->getSubstreamSizes();
ppcSubstreams = new TComInputBitstream*[uiNumSubstreams];
m_pcSbacDecoders = new TDecSbac[uiNumSubstreams];
m_pcBinCABACs = new TDecBinCABAC[uiNumSubstreams];
for ( UInt ui = 0 ; ui < uiNumSubstreams ; ui++ )
{
m_pcSbacDecoders[ui].init(&m_pcBinCABACs[ui]);
ppcSubstreams[ui] = pcBitstream->extractSubstream(ui+1 < uiNumSubstreams ? puiSubstreamSizes[ui] : pcBitstream->getNumBitsLeft());
}
for ( UInt ui = 0 ; ui+1 < uiNumSubstreams; ui++ )
{
m_pcEntropyDecoder->setEntropyDecoder ( &m_pcSbacDecoders[uiNumSubstreams - 1 - ui] );
m_pcEntropyDecoder->setBitstream ( ppcSubstreams [uiNumSubstreams - 1 - ui] );
m_pcEntropyDecoder->resetEntropy (pcSlice);
}
m_pcEntropyDecoder->setEntropyDecoder ( m_pcSbacDecoder );
m_pcEntropyDecoder->setBitstream ( ppcSubstreams[0] );
m_pcEntropyDecoder->resetEntropy (pcSlice);
if(uiSliceStartCuAddr == uiStartCUAddr)
{
m_LFCrossSliceBoundaryFlag.push_back( pcSlice->getLFCrossSliceBoundaryFlag());
}
#if H_3D_NBDV
if(pcSlice->getViewIndex() && !pcSlice->getIsDepth()) //Notes from QC: this condition shall be changed once the configuration is completed, e.g. in pcSlice->getSPS()->getMultiviewMvPredMode() || ARP in prev. HTM. Remove this comment once it is done.
{
Int iColPoc = pcSlice->getRefPOC(RefPicList(1-pcSlice->getColFromL0Flag()), pcSlice->getColRefIdx());
rpcPic->setNumDdvCandPics(rpcPic->getDisCandRefPictures(iColPoc));
}
if(pcSlice->getViewIndex() && !pcSlice->getIsDepth() && !pcSlice->isIntra()) //Notes from QC: this condition shall be changed once the configuration is completed, e.g. in pcSlice->getSPS()->getMultiviewMvPredMode() || ARP in prev. HTM. Remove this comment once it is done.
{
rpcPic->checkTemporalIVRef();
}
if(pcSlice->getIsDepth())
{
rpcPic->checkTextureRef();
}
#endif
#if H_3D
pcSlice->setDepthToDisparityLUTs();
#endif
m_pcSbacDecoders[0].load(m_pcSbacDecoder);
m_pcSliceDecoder->decompressSlice( ppcSubstreams, rpcPic, m_pcSbacDecoder, m_pcSbacDecoders);
m_pcEntropyDecoder->setBitstream( ppcSubstreams[uiNumSubstreams-1] );
// deallocate all created substreams, including internal buffers.
for (UInt ui = 0; ui < uiNumSubstreams; ui++)
{
ppcSubstreams[ui]->deleteFifo();
delete ppcSubstreams[ui];
}
delete[] ppcSubstreams;
delete[] m_pcSbacDecoders; m_pcSbacDecoders = NULL;
delete[] m_pcBinCABACs; m_pcBinCABACs = NULL;
m_dDecTime += (Double)(clock()-iBeforeTime) / CLOCKS_PER_SEC;
}
Void TDecGop::decompressSlice(TComInputBitstream* pcBitstream, TComPic*& rpcPic)
{
TComSlice* pcSlice = rpcPic->getSlice(rpcPic->getCurrSliceIdx());
// Table of extracted substreams.
// These must be deallocated AND their internal fifos, too.
TComInputBitstream **ppcSubstreams = NULL;
//-- For time output for each slice
long iBeforeTime = clock();
UInt uiStartCUAddr = pcSlice->getSliceSegmentCurStartCUAddr();
UInt uiSliceStartCuAddr = pcSlice->getSliceCurStartCUAddr();
if(uiSliceStartCuAddr == uiStartCUAddr)
{
m_sliceStartCUAddress.push_back(uiSliceStartCuAddr);
}
m_pcSbacDecoder->init( (TDecBinIf*)m_pcBinCABAC );
m_pcEntropyDecoder->setEntropyDecoder (m_pcSbacDecoder);
UInt uiNumSubstreams = pcSlice->getPPS()->getEntropyCodingSyncEnabledFlag() ? pcSlice->getNumEntryPointOffsets()+1 : pcSlice->getPPS()->getNumSubstreams();
// init each couple {EntropyDecoder, Substream}
UInt *puiSubstreamSizes = pcSlice->getSubstreamSizes();
ppcSubstreams = new TComInputBitstream*[uiNumSubstreams];
m_pcSbacDecoders = new TDecSbac[uiNumSubstreams];
m_pcBinCABACs = new TDecBinCABAC[uiNumSubstreams];
for ( UInt ui = 0 ; ui < uiNumSubstreams ; ui++ )
{
m_pcSbacDecoders[ui].init(&m_pcBinCABACs[ui]);
ppcSubstreams[ui] = pcBitstream->extractSubstream(ui+1 < uiNumSubstreams ? puiSubstreamSizes[ui] : pcBitstream->getNumBitsLeft());
}
for ( UInt ui = 0 ; ui+1 < uiNumSubstreams; ui++ )
{
m_pcEntropyDecoder->setEntropyDecoder ( &m_pcSbacDecoders[uiNumSubstreams - 1 - ui] );
m_pcEntropyDecoder->setBitstream ( ppcSubstreams [uiNumSubstreams - 1 - ui] );
m_pcEntropyDecoder->resetEntropy (pcSlice);
}
m_pcEntropyDecoder->setEntropyDecoder ( m_pcSbacDecoder );
m_pcEntropyDecoder->setBitstream ( ppcSubstreams[0] );
m_pcEntropyDecoder->resetEntropy (pcSlice);
if(uiSliceStartCuAddr == uiStartCUAddr)
{
m_LFCrossSliceBoundaryFlag.push_back( pcSlice->getLFCrossSliceBoundaryFlag());
}
m_pcSbacDecoders[0].load(m_pcSbacDecoder);
m_pcSliceDecoder->decompressSlice( ppcSubstreams, rpcPic, m_pcSbacDecoder, m_pcSbacDecoders);
m_pcEntropyDecoder->setBitstream( ppcSubstreams[uiNumSubstreams-1] );
// deallocate all created substreams, including internal buffers.
for (UInt ui = 0; ui < uiNumSubstreams; ui++)
{
ppcSubstreams[ui]->deleteFifo();
delete ppcSubstreams[ui];
}
delete[] ppcSubstreams;
delete[] m_pcSbacDecoders; m_pcSbacDecoders = NULL;
delete[] m_pcBinCABACs; m_pcBinCABACs = NULL;
m_dDecTime += (Double)(clock()-iBeforeTime) / CLOCKS_PER_SEC;
}
void FrameEncoder::compressFrame()
{
PPAScopeEvent(FrameEncoder_compressFrame);
int64_t startCompressTime = x265_mdate();
TEncEntropy* entropyCoder = getEntropyCoder(0);
TComSlice* slice = m_pic->getSlice();
m_nalCount = 0;
int qp = slice->getSliceQp();
double lambda = 0;
if (slice->getSliceType() == I_SLICE)
{
lambda = X265_MAX(1, x265_lambda2_tab_I[qp]);
}
else
{
lambda = X265_MAX(1, x265_lambda2_non_I[qp]);
}
// for RDO
// in RdCost there is only one lambda because the luma and chroma bits are not separated,
// instead we weight the distortion of chroma.
int qpc;
int chromaQPOffset = slice->getPPS()->getChromaCbQpOffset() + slice->getSliceQpDeltaCb();
qpc = Clip3(0, 57, qp + chromaQPOffset);
double cbWeight = pow(2.0, (qp - g_chromaScale[qpc])); // takes into account of the chroma qp mapping and chroma qp Offset
chromaQPOffset = slice->getPPS()->getChromaCrQpOffset() + slice->getSliceQpDeltaCr();
qpc = Clip3(0, 57, qp + chromaQPOffset);
double crWeight = pow(2.0, (qp - g_chromaScale[qpc])); // takes into account of the chroma qp mapping and chroma qp Offset
double chromaLambda = lambda / crWeight;
TComPicYuv *fenc = slice->getPic()->getPicYuvOrg();
for (int i = 0; i < m_numRows; i++)
{
m_rows[i].m_search.setQPLambda(qp, lambda, chromaLambda);
m_rows[i].m_search.m_me.setSourcePlane(fenc->getLumaAddr(), fenc->getStride());
m_rows[i].m_rdCost.setLambda(lambda);
m_rows[i].m_rdCost.setCbDistortionWeight(cbWeight);
m_rows[i].m_rdCost.setCrDistortionWeight(crWeight);
}
m_frameFilter.m_sao.lumaLambda = lambda;
m_frameFilter.m_sao.chromaLambda = chromaLambda;
switch (slice->getSliceType())
{
case I_SLICE:
m_frameFilter.m_sao.depth = 0;
break;
case P_SLICE:
m_frameFilter.m_sao.depth = 1;
break;
case B_SLICE:
m_frameFilter.m_sao.depth = 2 + !slice->isReferenced();
break;
}
slice->setSliceQpDelta(0);
slice->setSliceQpDeltaCb(0);
slice->setSliceQpDeltaCr(0);
int numSubstreams = m_cfg->param.bEnableWavefront ? m_pic->getPicSym()->getFrameHeightInCU() : 1;
// TODO: these two items can likely be FrameEncoder member variables to avoid re-allocs
TComOutputBitstream* bitstreamRedirect = new TComOutputBitstream;
TComOutputBitstream* outStreams = new TComOutputBitstream[numSubstreams];
if (m_cfg->getUseASR() && !slice->isIntra())
{
int pocCurr = slice->getPOC();
int maxSR = m_cfg->param.searchRange;
int numPredDir = slice->isInterP() ? 1 : 2;
for (int dir = 0; dir <= numPredDir; dir++)
{
for (int refIdx = 0; refIdx < slice->getNumRefIdx(dir); refIdx++)
{
int refPOC = slice->getRefPic(dir, refIdx)->getPOC();
int newSR = Clip3(8, maxSR, (maxSR * ADAPT_SR_SCALE * abs(pocCurr - refPOC) + 4) >> 3);
for (int i = 0; i < m_numRows; i++)
{
m_rows[i].m_search.setAdaptiveSearchRange(dir, refIdx, newSR);
}
}
}
}
void FrameEncoder::initSlice(TComPic* pic)
{
m_pic = pic;
TComSlice* slice = pic->getSlice();
slice->setSPS(&m_sps);
slice->setPPS(&m_pps);
slice->setSliceBits(0);
slice->setPic(pic);
slice->initSlice();
slice->setPicOutputFlag(true);
int type = pic->m_lowres.sliceType;
SliceType sliceType = IS_X265_TYPE_B(type) ? B_SLICE : ((type == X265_TYPE_P) ? P_SLICE : I_SLICE);
slice->setSliceType(sliceType);
slice->setReferenced(true);
slice->setScalingList(m_top->getScalingList());
slice->getScalingList()->setUseTransformSkip(m_pps.getUseTransformSkip());
for (int i = 0; i < m_numRows; i++)
m_rows[i].m_cuCoder.m_log = &m_rows[i].m_cuCoder.m_sliceTypeLog[sliceType];
if (slice->getPPS()->getDeblockingFilterControlPresentFlag())
{
slice->getPPS()->setDeblockingFilterOverrideEnabledFlag(!m_cfg->getLoopFilterOffsetInPPS());
slice->setDeblockingFilterOverrideFlag(!m_cfg->getLoopFilterOffsetInPPS());
slice->getPPS()->setPicDisableDeblockingFilterFlag(!m_cfg->param.bEnableLoopFilter);
slice->setDeblockingFilterDisable(!m_cfg->param.bEnableLoopFilter);
if (!slice->getDeblockingFilterDisable())
{
slice->getPPS()->setDeblockingFilterBetaOffsetDiv2(m_cfg->getLoopFilterBetaOffset());
slice->getPPS()->setDeblockingFilterTcOffsetDiv2(m_cfg->getLoopFilterTcOffset());
slice->setDeblockingFilterBetaOffsetDiv2(m_cfg->getLoopFilterBetaOffset());
slice->setDeblockingFilterTcOffsetDiv2(m_cfg->getLoopFilterTcOffset());
}
}
else
{
slice->setDeblockingFilterOverrideFlag(false);
slice->setDeblockingFilterDisable(false);
slice->setDeblockingFilterBetaOffsetDiv2(0);
slice->setDeblockingFilterTcOffsetDiv2(0);
}
slice->setMaxNumMergeCand(m_cfg->param.maxNumMergeCand);
}
Bool TDecTop::decode(InputNALUnit& nalu, Int& iSkipFrame, Int& iPOCLastDisplay)
{
TComPic*& pcPic = m_pcPic;
#if E045_SLICE_COMMON_INFO_SHARING
static TComPPS* pcNewPPS = NULL;
#endif
// Initialize entropy decoder
m_cEntropyDecoder.setEntropyDecoder (&m_cCavlcDecoder);
m_cEntropyDecoder.setBitstream (nalu.m_Bitstream);
switch (nalu.m_UnitType)
{
case NAL_UNIT_SPS:
m_cEntropyDecoder.decodeSPS( &m_cSPS );
#if ENABLE_ANAYSIS_OUTPUT
TSysuAnalyzerOutput::getInstance()->writeOutSps( &m_cSPS );
#endif
#if AMP
for (Int i = 0; i < m_cSPS.getMaxCUDepth() - 1; i++)
{
// m_cSPS.setAMPAcc( i, m_cSPS.getUseAMP() );
m_cSPS.setAMPAcc( i, 1 );
}
for (Int i = m_cSPS.getMaxCUDepth() - 1; i < m_cSPS.getMaxCUDepth(); i++)
{
m_cSPS.setAMPAcc( i, 0 );
}
#endif
// create ALF temporary buffer
m_cAdaptiveLoopFilter.create( m_cSPS.getWidth(), m_cSPS.getHeight(), g_uiMaxCUWidth, g_uiMaxCUHeight, g_uiMaxCUDepth );
#if MTK_SAO
m_cSAO.create( m_cSPS.getWidth(), m_cSPS.getHeight(), g_uiMaxCUWidth, g_uiMaxCUHeight, g_uiMaxCUDepth );
#endif
#if PARALLEL_MERGED_DEBLK
m_cLoopFilter.create( m_cSPS.getWidth(), m_cSPS.getHeight(), g_uiMaxCUWidth, g_uiMaxCUHeight, g_uiMaxCUDepth );
#else
m_cLoopFilter. create( g_uiMaxCUDepth );
#endif
#if E045_SLICE_COMMON_INFO_SHARING
createPPSBuffer();
#endif
m_uiValidPS |= 1;
return false;
case NAL_UNIT_PPS:
#if E045_SLICE_COMMON_INFO_SHARING
pcNewPPS = getNewPPSBuffer();
#if SUB_LCU_DQP
pcNewPPS->setSPS(&m_cSPS);
#endif
m_cEntropyDecoder.decodePPS( pcNewPPS );
if(pcNewPPS->getSharedPPSInfoEnabled())
{
if(m_cSPS.getUseALF())
{
m_cEntropyDecoder.decodeAlfParam( pcNewPPS->getSharedAlfParam());
}
}
signalNewPPSAvailable();
#else
#if SUB_LCU_DQP
m_cPPS.setSPS(&m_cSPS);
#endif
m_cEntropyDecoder.decodePPS( &m_cPPS );
#endif
m_uiValidPS |= 2;
return false;
case NAL_UNIT_SEI:
m_SEIs = new SEImessages;
m_cEntropyDecoder.decodeSEI(*m_SEIs);
return false;
case NAL_UNIT_CODED_SLICE:
case NAL_UNIT_CODED_SLICE_IDR:
case NAL_UNIT_CODED_SLICE_CDR:
{
// make sure we already received both parameter sets
assert( 3 == m_uiValidPS );
if (m_bFirstSliceInPicture)
{
m_apcSlicePilot->initSlice();
m_uiSliceIdx = 0;
m_uiLastSliceIdx = 0;
#if E045_SLICE_COMMON_INFO_SHARING
if(hasNewPPS())
{
m_pcPPS = pcNewPPS;
updatePPSBuffer();
}
#endif
}
m_apcSlicePilot->setSliceIdx(m_uiSliceIdx);
// Read slice header
m_apcSlicePilot->setSPS( &m_cSPS );
#if E045_SLICE_COMMON_INFO_SHARING
m_apcSlicePilot->setPPS( m_pcPPS );
#else
m_apcSlicePilot->setPPS( &m_cPPS );
#endif
m_apcSlicePilot->setSliceIdx(m_uiSliceIdx);
if (!m_bFirstSliceInPicture)
{
memcpy(m_apcSlicePilot, pcPic->getPicSym()->getSlice(m_uiSliceIdx-1), sizeof(TComSlice));
}
m_apcSlicePilot->setNalUnitType(nalu.m_UnitType);
m_apcSlicePilot->setReferenced(nalu.m_RefIDC != NAL_REF_IDC_PRIORITY_LOWEST);
m_cEntropyDecoder.decodeSliceHeader (m_apcSlicePilot);
if ( m_apcSlicePilot->getSymbolMode() )
{
Int numBitsForByteAlignment = nalu.m_Bitstream->getNumBitsUntilByteAligned();
if ( numBitsForByteAlignment > 0 )
{
UInt bitsForByteAlignment;
nalu.m_Bitstream->read( numBitsForByteAlignment, bitsForByteAlignment );
assert( bitsForByteAlignment == ( ( 1 << numBitsForByteAlignment ) - 1 ) );
}
}
m_apcSlicePilot->setTLayerInfo(nalu.m_TemporalID);
if (m_apcSlicePilot->isNextSlice() && m_apcSlicePilot->getPOC()!=m_uiPrevPOC && !m_bFirstSliceInSequence)
{
m_uiPrevPOC = m_apcSlicePilot->getPOC();
return true;
}
if (m_apcSlicePilot->isNextSlice())
m_uiPrevPOC = m_apcSlicePilot->getPOC();
m_bFirstSliceInSequence = false;
if (m_apcSlicePilot->isNextSlice())
{
// Skip pictures due to random access
if (isRandomAccessSkipPicture(iSkipFrame, iPOCLastDisplay))
{
return false;
}
}
if (m_bFirstSliceInPicture)
{
// Buffer initialize for prediction.
m_cPrediction.initTempBuff();
// Get a new picture buffer
xGetNewPicBuffer (m_apcSlicePilot, pcPic);
/* transfer any SEI messages that have been received to the picture */
pcPic->setSEIs(m_SEIs);
m_SEIs = NULL;
// Recursive structure
m_cCuDecoder.create ( g_uiMaxCUDepth, g_uiMaxCUWidth, g_uiMaxCUHeight );
m_cCuDecoder.init ( &m_cEntropyDecoder, &m_cTrQuant, &m_cPrediction );
m_cTrQuant.init ( g_uiMaxCUWidth, g_uiMaxCUHeight, m_apcSlicePilot->getSPS()->getMaxTrSize());
m_cSliceDecoder.create( m_apcSlicePilot, m_apcSlicePilot->getSPS()->getWidth(), m_apcSlicePilot->getSPS()->getHeight(), g_uiMaxCUWidth, g_uiMaxCUHeight, g_uiMaxCUDepth );
}
// Set picture slice pointer
TComSlice* pcSlice = m_apcSlicePilot;
Bool bNextSlice = pcSlice->isNextSlice();
if (m_bFirstSliceInPicture)
{
if(pcPic->getNumAllocatedSlice() != 1)
{
pcPic->clearSliceBuffer();
}
}
else
{
pcPic->allocateNewSlice();
}
assert(pcPic->getNumAllocatedSlice() == (m_uiSliceIdx + 1));
m_apcSlicePilot = pcPic->getPicSym()->getSlice(m_uiSliceIdx);
pcPic->getPicSym()->setSlice(pcSlice, m_uiSliceIdx);
pcPic->setTLayer(nalu.m_TemporalID);
if (bNextSlice)
{
// Do decoding refresh marking if any
pcSlice->decodingRefreshMarking(m_uiPOCCDR, m_bRefreshPending, m_cListPic);
// Set reference list
pcSlice->setRefPicList( m_cListPic );
// HierP + GPB case
if ( m_cSPS.getUseLDC() && pcSlice->isInterB() )
{
if(pcSlice->getRefPicListCombinationFlag() && (pcSlice->getNumRefIdx(REF_PIC_LIST_0) > pcSlice->getNumRefIdx(REF_PIC_LIST_1)))
{
for (Int iRefIdx = 0; iRefIdx < pcSlice->getNumRefIdx(REF_PIC_LIST_1); iRefIdx++)
{
pcSlice->setRefPic(pcSlice->getRefPic(REF_PIC_LIST_0, iRefIdx), REF_PIC_LIST_1, iRefIdx);
}
}
else
{
Int iNumRefIdx = pcSlice->getNumRefIdx(REF_PIC_LIST_0);
pcSlice->setNumRefIdx( REF_PIC_LIST_1, iNumRefIdx );
for (Int iRefIdx = 0; iRefIdx < iNumRefIdx; iRefIdx++)
{
pcSlice->setRefPic(pcSlice->getRefPic(REF_PIC_LIST_0, iRefIdx), REF_PIC_LIST_1, iRefIdx);
}
}
}
// For generalized B
// note: maybe not existed case (always L0 is copied to L1 if L1 is empty)
if (pcSlice->isInterB() && pcSlice->getNumRefIdx(REF_PIC_LIST_1) == 0)
{
Int iNumRefIdx = pcSlice->getNumRefIdx(REF_PIC_LIST_0);
pcSlice->setNumRefIdx ( REF_PIC_LIST_1, iNumRefIdx );
for (Int iRefIdx = 0; iRefIdx < iNumRefIdx; iRefIdx++)
{
pcSlice->setRefPic(pcSlice->getRefPic(REF_PIC_LIST_0, iRefIdx), REF_PIC_LIST_1, iRefIdx);
}
}
#if TMVP_ONE_LIST_CHECK
if (pcSlice->isInterB())
{
Bool bLowDelay = true;
Int iCurrPOC = pcSlice->getPOC();
Int iRefIdx = 0;
for (iRefIdx = 0; iRefIdx < pcSlice->getNumRefIdx(REF_PIC_LIST_0) && bLowDelay; iRefIdx++)
{
if ( pcSlice->getRefPic(REF_PIC_LIST_0, iRefIdx)->getPOC() > iCurrPOC )
{
bLowDelay = false;
}
}
for (iRefIdx = 0; iRefIdx < pcSlice->getNumRefIdx(REF_PIC_LIST_1) && bLowDelay; iRefIdx++)
{
if ( pcSlice->getRefPic(REF_PIC_LIST_1, iRefIdx)->getPOC() > iCurrPOC )
{
bLowDelay = false;
}
}
pcSlice->setCheckLDC(bLowDelay);
}
#endif
//---------------
pcSlice->setRefPOCList();
if(!pcSlice->getRefPicListModificationFlagLC())
{
pcSlice->generateCombinedList();
}
pcSlice->setNoBackPredFlag( false );
if ( pcSlice->getSliceType() == B_SLICE && !pcSlice->getRefPicListCombinationFlag())
{
if ( pcSlice->getNumRefIdx(RefPicList( 0 ) ) == pcSlice->getNumRefIdx(RefPicList( 1 ) ) )
{
pcSlice->setNoBackPredFlag( true );
int i;
for ( i=0; i < pcSlice->getNumRefIdx(RefPicList( 1 ) ); i++ )
{
if ( pcSlice->getRefPOC(RefPicList(1), i) != pcSlice->getRefPOC(RefPicList(0), i) )
{
pcSlice->setNoBackPredFlag( false );
break;
}
}
}
}
}
pcPic->setCurrSliceIdx(m_uiSliceIdx);
// Decode a picture
#if REF_SETTING_FOR_LD
m_cGopDecoder.decompressGop(nalu.m_Bitstream, pcPic, false, m_cListPic );
#else
m_cGopDecoder.decompressGop(nalu.m_Bitstream, pcPic, false);
#endif
m_bFirstSliceInPicture = false;
m_uiSliceIdx++;
}
break;
default:
assert (1);
}
return false;
}
Void TDecSlice::decompressSlice(TComInputBitstream** ppcSubstreams, TComPic* pcPic, TDecSbac* pcSbacDecoder)
{
TComSlice* pcSlice = pcPic->getSlice(pcPic->getCurrSliceIdx());
const Int startCtuTsAddr = pcSlice->getSliceSegmentCurStartCtuTsAddr();
const Int startCtuRsAddr = pcPic->getPicSym()->getCtuTsToRsAddrMap(startCtuTsAddr);
const UInt numCtusInFrame = pcPic->getNumberOfCtusInFrame();
const UInt frameWidthInCtus = pcPic->getPicSym()->getFrameWidthInCtus();
const Bool depSliceSegmentsEnabled = pcSlice->getPPS()->getDependentSliceSegmentsEnabledFlag();
const Bool wavefrontsEnabled = pcSlice->getPPS()->getEntropyCodingSyncEnabledFlag();
m_pcEntropyDecoder->setEntropyDecoder ( pcSbacDecoder );
m_pcEntropyDecoder->setBitstream ( ppcSubstreams[0] );
m_pcEntropyDecoder->resetEntropy (pcSlice);
// decoder doesn't need prediction & residual frame buffer
pcPic->setPicYuvPred( 0 );
pcPic->setPicYuvResi( 0 );
#if ENC_DEC_TRACE
g_bJustDoIt = g_bEncDecTraceEnable;
#endif
DTRACE_CABAC_VL( g_nSymbolCounter++ );
DTRACE_CABAC_T( "\tPOC: " );
DTRACE_CABAC_V( pcPic->getPOC() );
DTRACE_CABAC_T( "\n" );
#if ENC_DEC_TRACE
g_bJustDoIt = g_bEncDecTraceDisable;
#endif
// The first CTU of the slice is the first coded substream, but the global substream number, as calculated by getSubstreamForCtuAddr may be higher.
// This calculates the common offset for all substreams in this slice.
const UInt subStreamOffset=pcPic->getSubstreamForCtuAddr(startCtuRsAddr, true, pcSlice);
if (depSliceSegmentsEnabled)
{
// modify initial contexts with previous slice segment if this is a dependent slice.
const UInt startTileIdx=pcPic->getPicSym()->getTileIdxMap(startCtuRsAddr);
const TComTile *pCurrentTile=pcPic->getPicSym()->getTComTile(startTileIdx);
const UInt firstCtuRsAddrOfTile = pCurrentTile->getFirstCtuRsAddr();
if( pcSlice->getDependentSliceSegmentFlag() && startCtuRsAddr != firstCtuRsAddrOfTile)
{
if ( pCurrentTile->getTileWidthInCtus() >= 2 || !wavefrontsEnabled)
{
pcSbacDecoder->loadContexts(&m_lastSliceSegmentEndContextState);
}
}
}
// for every CTU in the slice segment...
Bool isLastCtuOfSliceSegment = false;
for( UInt ctuTsAddr = startCtuTsAddr; !isLastCtuOfSliceSegment && ctuTsAddr < numCtusInFrame; ctuTsAddr++)
{
const UInt ctuRsAddr = pcPic->getPicSym()->getCtuTsToRsAddrMap(ctuTsAddr);
const TComTile ¤tTile = *(pcPic->getPicSym()->getTComTile(pcPic->getPicSym()->getTileIdxMap(ctuRsAddr)));
const UInt firstCtuRsAddrOfTile = currentTile.getFirstCtuRsAddr();
const UInt tileXPosInCtus = firstCtuRsAddrOfTile % frameWidthInCtus;
const UInt tileYPosInCtus = firstCtuRsAddrOfTile / frameWidthInCtus;
const UInt ctuXPosInCtus = ctuRsAddr % frameWidthInCtus;
const UInt ctuYPosInCtus = ctuRsAddr / frameWidthInCtus;
const UInt uiSubStrm=pcPic->getSubstreamForCtuAddr(ctuRsAddr, true, pcSlice)-subStreamOffset;
TComDataCU* pCtu = pcPic->getCtu( ctuRsAddr );
pCtu->initCtu( pcPic, ctuRsAddr );
m_pcEntropyDecoder->setBitstream( ppcSubstreams[uiSubStrm] );
// set up CABAC contexts' state for this CTU
if (ctuRsAddr == firstCtuRsAddrOfTile)
{
if (ctuTsAddr != startCtuTsAddr) // if it is the first CTU, then the entropy coder has already been reset
{
m_pcEntropyDecoder->resetEntropy(pcSlice);
}
}
else if (ctuXPosInCtus == tileXPosInCtus && wavefrontsEnabled)
{
// Synchronize cabac probabilities with upper-right CTU if it's available and at the start of a line.
if (ctuTsAddr != startCtuTsAddr) // if it is the first CTU, then the entropy coder has already been reset
{
m_pcEntropyDecoder->resetEntropy(pcSlice);
}
TComDataCU *pCtuUp = pCtu->getCtuAbove();
if ( pCtuUp && ((ctuRsAddr%frameWidthInCtus+1) < frameWidthInCtus) )
{
TComDataCU *pCtuTR = pcPic->getCtu( ctuRsAddr - frameWidthInCtus + 1 );
if ( pCtu->CUIsFromSameSliceAndTile(pCtuTR) )
{
// Top-right is available, so use it.
pcSbacDecoder->loadContexts( &m_entropyCodingSyncContextState );
}
}
}
#if ENC_DEC_TRACE
g_bJustDoIt = g_bEncDecTraceEnable;
#endif
if ( pcSlice->getSPS()->getUseSAO() )
{
SAOBlkParam& saoblkParam = (pcPic->getPicSym()->getSAOBlkParam())[ctuRsAddr];
Bool bIsSAOSliceEnabled = false;
Bool sliceEnabled[MAX_NUM_COMPONENT];
for(Int comp=0; comp < MAX_NUM_COMPONENT; comp++)
{
ComponentID compId=ComponentID(comp);
sliceEnabled[compId] = pcSlice->getSaoEnabledFlag(toChannelType(compId)) && (comp < pcPic->getNumberValidComponents());
if (sliceEnabled[compId]) bIsSAOSliceEnabled=true;
saoblkParam[compId].modeIdc = SAO_MODE_OFF;
}
if (bIsSAOSliceEnabled)
{
Bool leftMergeAvail = false;
Bool aboveMergeAvail= false;
//merge left condition
Int rx = (ctuRsAddr % frameWidthInCtus);
if(rx > 0)
{
leftMergeAvail = pcPic->getSAOMergeAvailability(ctuRsAddr, ctuRsAddr-1);
}
//merge up condition
Int ry = (ctuRsAddr / frameWidthInCtus);
if(ry > 0)
{
aboveMergeAvail = pcPic->getSAOMergeAvailability(ctuRsAddr, ctuRsAddr-frameWidthInCtus);
}
#if SVC_EXTENSION
pcSbacDecoder->parseSAOBlkParam( saoblkParam, m_saoMaxOffsetQVal, sliceEnabled, leftMergeAvail, aboveMergeAvail);
#else
pcSbacDecoder->parseSAOBlkParam( saoblkParam, sliceEnabled, leftMergeAvail, aboveMergeAvail);
#endif
}
}
m_pcCuDecoder->decodeCtu ( pCtu, isLastCtuOfSliceSegment );
m_pcCuDecoder->decompressCtu ( pCtu );
#if ENC_DEC_TRACE
g_bJustDoIt = g_bEncDecTraceDisable;
#endif
//Store probabilities of second CTU in line into buffer
if ( ctuXPosInCtus == tileXPosInCtus+1 && wavefrontsEnabled)
{
m_entropyCodingSyncContextState.loadContexts( pcSbacDecoder );
}
// Should the sub-stream/stream be terminated after this CTU?
// (end of slice-segment, end of tile, end of wavefront-CTU-row)
if (isLastCtuOfSliceSegment ||
( ctuXPosInCtus + 1 == tileXPosInCtus + currentTile.getTileWidthInCtus() &&
( ctuYPosInCtus + 1 == tileYPosInCtus + currentTile.getTileHeightInCtus() || wavefrontsEnabled)
)
)
{
UInt binVal;
pcSbacDecoder->parseTerminatingBit( binVal );
assert( binVal );
#if DECODER_CHECK_SUBSTREAM_AND_SLICE_TRAILING_BYTES
pcSbacDecoder->parseRemainingBytes(!isLastCtuOfSliceSegment);
#endif
if (isLastCtuOfSliceSegment)
{
if(!pcSlice->getDependentSliceSegmentFlag())
{
pcSlice->setSliceCurEndCtuTsAddr( ctuTsAddr+1 );
}
pcSlice->setSliceSegmentCurEndCtuTsAddr( ctuTsAddr+1 );
break;
}
}
}
assert(isLastCtuOfSliceSegment == true);
if( depSliceSegmentsEnabled )
{
m_lastSliceSegmentEndContextState.loadContexts( pcSbacDecoder );//ctx end of dep.slice
}
}
Void TDecSlice::decompressSlice(TComInputBitstream** ppcSubstreams, TComPic*& rpcPic, TDecSbac* pcSbacDecoder, TDecSbac* pcSbacDecoders)
{
TComDataCU* pcCU;
UInt uiIsLast = 0;
Int iStartCUEncOrder = max(rpcPic->getSlice(rpcPic->getCurrSliceIdx())->getSliceCurStartCUAddr()/rpcPic->getNumPartInCU(), rpcPic->getSlice(rpcPic->getCurrSliceIdx())->getSliceSegmentCurStartCUAddr()/rpcPic->getNumPartInCU());
Int iStartCUAddr = rpcPic->getPicSym()->getCUOrderMap(iStartCUEncOrder);
// decoder don't need prediction & residual frame buffer
#if ENABLE_ANAYSIS_OUTPUT
#else
rpcPic->setPicYuvPred( 0 );
rpcPic->setPicYuvResi( 0 );
#endif
#if ENC_DEC_TRACE
g_bJustDoIt = g_bEncDecTraceEnable;
#endif
DTRACE_CABAC_VL( g_nSymbolCounter++ );
DTRACE_CABAC_T( "\tPOC: " );
DTRACE_CABAC_V( rpcPic->getPOC() );
DTRACE_CABAC_T( "\n" );
#if ENC_DEC_TRACE
g_bJustDoIt = g_bEncDecTraceDisable;
#endif
UInt uiTilesAcross = rpcPic->getPicSym()->getNumColumnsMinus1()+1;
TComSlice* pcSlice = rpcPic->getSlice(rpcPic->getCurrSliceIdx());
Int iNumSubstreams = pcSlice->getPPS()->getNumSubstreams();
// delete decoders if already allocated in previous slice
if (m_pcBufferSbacDecoders)
{
delete [] m_pcBufferSbacDecoders;
}
if (m_pcBufferBinCABACs)
{
delete [] m_pcBufferBinCABACs;
}
// allocate new decoders based on tile numbaer
m_pcBufferSbacDecoders = new TDecSbac [uiTilesAcross];
m_pcBufferBinCABACs = new TDecBinCABAC[uiTilesAcross];
for (UInt ui = 0; ui < uiTilesAcross; ui++)
{
m_pcBufferSbacDecoders[ui].init(&m_pcBufferBinCABACs[ui]);
}
//save init. state
for (UInt ui = 0; ui < uiTilesAcross; ui++)
{
m_pcBufferSbacDecoders[ui].load(pcSbacDecoder);
}
// free memory if already allocated in previous call
if (m_pcBufferLowLatSbacDecoders)
{
delete [] m_pcBufferLowLatSbacDecoders;
}
if (m_pcBufferLowLatBinCABACs)
{
delete [] m_pcBufferLowLatBinCABACs;
}
m_pcBufferLowLatSbacDecoders = new TDecSbac [uiTilesAcross];
m_pcBufferLowLatBinCABACs = new TDecBinCABAC[uiTilesAcross];
for (UInt ui = 0; ui < uiTilesAcross; ui++)
{
m_pcBufferLowLatSbacDecoders[ui].init(&m_pcBufferLowLatBinCABACs[ui]);
}
//save init. state
for (UInt ui = 0; ui < uiTilesAcross; ui++)
{
m_pcBufferLowLatSbacDecoders[ui].load(pcSbacDecoder);
}
UInt uiWidthInLCUs = rpcPic->getPicSym()->getFrameWidthInCU();
//UInt uiHeightInLCUs = rpcPic->getPicSym()->getFrameHeightInCU();
UInt uiCol=0, uiLin=0, uiSubStrm=0;
UInt uiTileCol;
UInt uiTileStartLCU;
UInt uiTileLCUX;
Int iNumSubstreamsPerTile = 1; // if independent.
Bool depSliceSegmentsEnabled = rpcPic->getSlice(rpcPic->getCurrSliceIdx())->getPPS()->getDependentSliceSegmentsEnabledFlag();
uiTileStartLCU = rpcPic->getPicSym()->getTComTile(rpcPic->getPicSym()->getTileIdxMap(iStartCUAddr))->getFirstCUAddr();
if( depSliceSegmentsEnabled )
{
if( (!rpcPic->getSlice(rpcPic->getCurrSliceIdx())->isNextSlice()) &&
iStartCUAddr != rpcPic->getPicSym()->getTComTile(rpcPic->getPicSym()->getTileIdxMap(iStartCUAddr))->getFirstCUAddr())
{
if(pcSlice->getPPS()->getEntropyCodingSyncEnabledFlag())
{
uiTileCol = rpcPic->getPicSym()->getTileIdxMap(iStartCUAddr) % (rpcPic->getPicSym()->getNumColumnsMinus1()+1);
m_pcBufferSbacDecoders[uiTileCol].loadContexts( CTXMem[1] );//2.LCU
if ( (iStartCUAddr%uiWidthInLCUs+1) >= uiWidthInLCUs )
{
uiTileLCUX = uiTileStartLCU % uiWidthInLCUs;
uiCol = iStartCUAddr % uiWidthInLCUs;
if(uiCol==uiTileLCUX)
{
CTXMem[0]->loadContexts(pcSbacDecoder);
}
}
}
pcSbacDecoder->loadContexts(CTXMem[0] ); //end of depSlice-1
pcSbacDecoders[uiSubStrm].loadContexts(pcSbacDecoder);
}
else
{
if(pcSlice->getPPS()->getEntropyCodingSyncEnabledFlag())
{
CTXMem[1]->loadContexts(pcSbacDecoder);
}
CTXMem[0]->loadContexts(pcSbacDecoder);
}
}
for( Int iCUAddr = iStartCUAddr; !uiIsLast && iCUAddr < rpcPic->getNumCUsInFrame(); iCUAddr = rpcPic->getPicSym()->xCalculateNxtCUAddr(iCUAddr) )
{
pcCU = rpcPic->getCU( iCUAddr );
pcCU->initCU( rpcPic, iCUAddr );
uiTileCol = rpcPic->getPicSym()->getTileIdxMap(iCUAddr) % (rpcPic->getPicSym()->getNumColumnsMinus1()+1); // what column of tiles are we in?
uiTileStartLCU = rpcPic->getPicSym()->getTComTile(rpcPic->getPicSym()->getTileIdxMap(iCUAddr))->getFirstCUAddr();
uiTileLCUX = uiTileStartLCU % uiWidthInLCUs;
uiCol = iCUAddr % uiWidthInLCUs;
// The 'line' is now relative to the 1st line in the slice, not the 1st line in the picture.
uiLin = (iCUAddr/uiWidthInLCUs)-(iStartCUAddr/uiWidthInLCUs);
// inherit from TR if necessary, select substream to use.
if( (pcSlice->getPPS()->getNumSubstreams() > 1) || ( depSliceSegmentsEnabled && (uiCol == uiTileLCUX)&&(pcSlice->getPPS()->getEntropyCodingSyncEnabledFlag()) ))
{
// independent tiles => substreams are "per tile". iNumSubstreams has already been multiplied.
iNumSubstreamsPerTile = iNumSubstreams/rpcPic->getPicSym()->getNumTiles();
uiSubStrm = rpcPic->getPicSym()->getTileIdxMap(iCUAddr)*iNumSubstreamsPerTile
+ uiLin%iNumSubstreamsPerTile;
m_pcEntropyDecoder->setBitstream( ppcSubstreams[uiSubStrm] );
// Synchronize cabac probabilities with upper-right LCU if it's available and we're at the start of a line.
if (((pcSlice->getPPS()->getNumSubstreams() > 1) || depSliceSegmentsEnabled ) && (uiCol == uiTileLCUX)&&(pcSlice->getPPS()->getEntropyCodingSyncEnabledFlag()))
{
// We'll sync if the TR is available.
TComDataCU *pcCUUp = pcCU->getCUAbove();
UInt uiWidthInCU = rpcPic->getFrameWidthInCU();
TComDataCU *pcCUTR = NULL;
if ( pcCUUp && ((iCUAddr%uiWidthInCU+1) < uiWidthInCU) )
{
pcCUTR = rpcPic->getCU( iCUAddr - uiWidthInCU + 1 );
}
UInt uiMaxParts = 1<<(pcSlice->getSPS()->getMaxCUDepth()<<1);
if ( (true/*bEnforceSliceRestriction*/ &&
((pcCUTR==NULL) || (pcCUTR->getSlice()==NULL) ||
((pcCUTR->getSCUAddr()+uiMaxParts-1) < pcSlice->getSliceCurStartCUAddr()) ||
((rpcPic->getPicSym()->getTileIdxMap( pcCUTR->getAddr() ) != rpcPic->getPicSym()->getTileIdxMap(iCUAddr)))
))
)
{
// TR not available.
}
else
{
// TR is available, we use it.
pcSbacDecoders[uiSubStrm].loadContexts( &m_pcBufferSbacDecoders[uiTileCol] );
}
}
pcSbacDecoder->load(&pcSbacDecoders[uiSubStrm]); //this load is used to simplify the code (avoid to change all the call to pcSbacDecoders)
}
else if ( pcSlice->getPPS()->getNumSubstreams() <= 1 )
{
// Set variables to appropriate values to avoid later code change.
iNumSubstreamsPerTile = 1;
}
if ( (iCUAddr == rpcPic->getPicSym()->getTComTile(rpcPic->getPicSym()->getTileIdxMap(iCUAddr))->getFirstCUAddr()) && // 1st in tile.
(iCUAddr!=0) && (iCUAddr!=rpcPic->getPicSym()->getPicSCUAddr(rpcPic->getSlice(rpcPic->getCurrSliceIdx())->getSliceCurStartCUAddr())/rpcPic->getNumPartInCU())
&& (iCUAddr!=rpcPic->getPicSym()->getPicSCUAddr(rpcPic->getSlice(rpcPic->getCurrSliceIdx())->getSliceSegmentCurStartCUAddr())/rpcPic->getNumPartInCU())
) // !1st in frame && !1st in slice
{
if (pcSlice->getPPS()->getNumSubstreams() > 1)
{
// We're crossing into another tile, tiles are independent.
// When tiles are independent, we have "substreams per tile". Each substream has already been terminated, and we no longer
// have to perform it here.
// For TILES_DECODER, there can be a header at the start of the 1st substream in a tile. These are read when the substreams
// are extracted, not here.
}
else
{
SliceType sliceType = pcSlice->getSliceType();
if (pcSlice->getCabacInitFlag())
{
switch (sliceType)
{
case P_SLICE: // change initialization table to B_SLICE intialization
sliceType = B_SLICE;
break;
case B_SLICE: // change initialization table to P_SLICE intialization
sliceType = P_SLICE;
break;
default : // should not occur
assert(0);
}
}
m_pcEntropyDecoder->updateContextTables( sliceType, pcSlice->getSliceQp() );
}
}
#if ENC_DEC_TRACE
g_bJustDoIt = g_bEncDecTraceEnable;
#endif
if ( pcSlice->getSPS()->getUseSAO() && (pcSlice->getSaoEnabledFlag()||pcSlice->getSaoEnabledFlagChroma()) )
{
SAOParam *saoParam = rpcPic->getPicSym()->getSaoParam();
saoParam->bSaoFlag[0] = pcSlice->getSaoEnabledFlag();
if (iCUAddr == iStartCUAddr)
{
saoParam->bSaoFlag[1] = pcSlice->getSaoEnabledFlagChroma();
}
Int numCuInWidth = saoParam->numCuInWidth;
Int cuAddrInSlice = iCUAddr - rpcPic->getPicSym()->getCUOrderMap(pcSlice->getSliceCurStartCUAddr()/rpcPic->getNumPartInCU());
Int cuAddrUpInSlice = cuAddrInSlice - numCuInWidth;
Int rx = iCUAddr % numCuInWidth;
Int ry = iCUAddr / numCuInWidth;
Int allowMergeLeft = 1;
Int allowMergeUp = 1;
if (rx!=0)
{
if (rpcPic->getPicSym()->getTileIdxMap(iCUAddr-1) != rpcPic->getPicSym()->getTileIdxMap(iCUAddr))
{
allowMergeLeft = 0;
}
}
if (ry!=0)
{
if (rpcPic->getPicSym()->getTileIdxMap(iCUAddr-numCuInWidth) != rpcPic->getPicSym()->getTileIdxMap(iCUAddr))
{
allowMergeUp = 0;
}
}
pcSbacDecoder->parseSaoOneLcuInterleaving(rx, ry, saoParam,pcCU, cuAddrInSlice, cuAddrUpInSlice, allowMergeLeft, allowMergeUp);
}
else if ( pcSlice->getSPS()->getUseSAO() )
{
Int addr = pcCU->getAddr();
SAOParam *saoParam = rpcPic->getPicSym()->getSaoParam();
for (Int cIdx=0; cIdx<3; cIdx++)
{
SaoLcuParam *saoLcuParam = &(saoParam->saoLcuParam[cIdx][addr]);
if ( ((cIdx == 0) && !pcSlice->getSaoEnabledFlag()) || ((cIdx == 1 || cIdx == 2) && !pcSlice->getSaoEnabledFlagChroma()))
{
saoLcuParam->mergeUpFlag = 0;
saoLcuParam->mergeLeftFlag = 0;
saoLcuParam->subTypeIdx = 0;
saoLcuParam->typeIdx = -1;
saoLcuParam->offset[0] = 0;
saoLcuParam->offset[1] = 0;
saoLcuParam->offset[2] = 0;
saoLcuParam->offset[3] = 0;
}
}
}
#if ENABLE_ANAYSIS_OUTPUT
UInt uiBefore = ppcSubstreams[uiSubStrm]->getByteLocation();
#endif
m_pcCuDecoder->decodeCU ( pcCU, uiIsLast );
#if ENABLE_ANAYSIS_OUTPUT
pcCU->getTotalBits() = ppcSubstreams[uiSubStrm]->getByteLocation() - uiBefore;
#endif
m_pcCuDecoder->decompressCU ( pcCU );
#if ENC_DEC_TRACE
g_bJustDoIt = g_bEncDecTraceDisable;
#endif
pcSbacDecoders[uiSubStrm].load(pcSbacDecoder);
//Store probabilities of second LCU in line into buffer
if ( (uiCol == uiTileLCUX+1)&& (depSliceSegmentsEnabled || (pcSlice->getPPS()->getNumSubstreams() > 1)) && (pcSlice->getPPS()->getEntropyCodingSyncEnabledFlag()) )
{
m_pcBufferSbacDecoders[uiTileCol].loadContexts( &pcSbacDecoders[uiSubStrm] );
}
if( uiIsLast && depSliceSegmentsEnabled )
{
if (pcSlice->getPPS()->getEntropyCodingSyncEnabledFlag())
{
CTXMem[1]->loadContexts( &m_pcBufferSbacDecoders[uiTileCol] );//ctx 2.LCU
}
CTXMem[0]->loadContexts( pcSbacDecoder );//ctx end of dep.slice
return;
}
}
}
Void TDecSlice::decompressSlice(TComInputBitstream* pcBitstream, TComInputBitstream** ppcSubstreams, TComPic*& rpcPic, TDecSbac* pcSbacDecoder, TDecSbac* pcSbacDecoders)
{
TComDataCU* pcCU;
UInt uiIsLast = 0;
Int iStartCUEncOrder = max(rpcPic->getSlice(rpcPic->getCurrSliceIdx())->getSliceCurStartCUAddr()/rpcPic->getNumPartInCU(), rpcPic->getSlice(rpcPic->getCurrSliceIdx())->getEntropySliceCurStartCUAddr()/rpcPic->getNumPartInCU());
Int iStartCUAddr = rpcPic->getPicSym()->getCUOrderMap(iStartCUEncOrder);
// decoder don't need prediction & residual frame buffer
rpcPic->setPicYuvPred( 0 );
rpcPic->setPicYuvResi( 0 );
#if ENC_DEC_TRACE
g_bJustDoIt = g_bEncDecTraceEnable;
#endif
DTRACE_CABAC_VL( g_nSymbolCounter++ );
DTRACE_CABAC_T( "\tPOC: " );
DTRACE_CABAC_V( rpcPic->getPOC() );
DTRACE_CABAC_T( "\n" );
#if ENC_DEC_TRACE
g_bJustDoIt = g_bEncDecTraceDisable;
#endif
UInt uiTilesAcross = rpcPic->getPicSym()->getNumColumnsMinus1()+1;
TComSlice* pcSlice = rpcPic->getSlice(rpcPic->getCurrSliceIdx());
UInt iSymbolMode = pcSlice->getPPS()->getEntropyCodingMode();
Int iNumSubstreams = pcSlice->getPPS()->getNumSubstreams();
if( iSymbolMode )
{
m_pcBufferSbacDecoders = new TDecSbac [uiTilesAcross];
m_pcBufferBinCABACs = new TDecBinCABAC[uiTilesAcross];
for (UInt ui = 0; ui < uiTilesAcross; ui++)
{
m_pcBufferSbacDecoders[ui].init(&m_pcBufferBinCABACs[ui]);
}
//save init. state
for (UInt ui = 0; ui < uiTilesAcross; ui++)
{
m_pcBufferSbacDecoders[ui].load(pcSbacDecoder);
}
}
if( iSymbolMode )
{
m_pcBufferLowLatSbacDecoders = new TDecSbac [uiTilesAcross];
m_pcBufferLowLatBinCABACs = new TDecBinCABAC[uiTilesAcross];
for (UInt ui = 0; ui < uiTilesAcross; ui++)
m_pcBufferLowLatSbacDecoders[ui].init(&m_pcBufferLowLatBinCABACs[ui]);
//save init. state
for (UInt ui = 0; ui < uiTilesAcross; ui++)
m_pcBufferLowLatSbacDecoders[ui].load(pcSbacDecoder);
}
UInt uiWidthInLCUs = rpcPic->getPicSym()->getFrameWidthInCU();
//UInt uiHeightInLCUs = rpcPic->getPicSym()->getFrameHeightInCU();
UInt uiCol=0, uiLin=0, uiSubStrm=0;
UInt uiTileCol;
UInt uiTileStartLCU;
UInt uiTileLCUX;
UInt uiTileLCUY;
UInt uiTileWidth;
UInt uiTileHeight;
Int iNumSubstreamsPerTile = 1; // if independent.
for( Int iCUAddr = iStartCUAddr; !uiIsLast && iCUAddr < rpcPic->getNumCUsInFrame(); iCUAddr = rpcPic->getPicSym()->xCalculateNxtCUAddr(iCUAddr) )
{
pcCU = rpcPic->getCU( iCUAddr );
pcCU->initCU( rpcPic, iCUAddr );
uiTileCol = rpcPic->getPicSym()->getTileIdxMap(iCUAddr) % (rpcPic->getPicSym()->getNumColumnsMinus1()+1); // what column of tiles are we in?
uiTileStartLCU = rpcPic->getPicSym()->getTComTile(rpcPic->getPicSym()->getTileIdxMap(iCUAddr))->getFirstCUAddr();
uiTileLCUX = uiTileStartLCU % uiWidthInLCUs;
uiTileLCUY = uiTileStartLCU / uiWidthInLCUs;
uiTileWidth = rpcPic->getPicSym()->getTComTile(rpcPic->getPicSym()->getTileIdxMap(iCUAddr))->getTileWidth();
uiTileHeight = rpcPic->getPicSym()->getTComTile(rpcPic->getPicSym()->getTileIdxMap(iCUAddr))->getTileHeight();
uiCol = iCUAddr % uiWidthInLCUs;
uiLin = iCUAddr / uiWidthInLCUs;
// inherit from TR if necessary, select substream to use.
if( iSymbolMode && pcSlice->getPPS()->getNumSubstreams() > 1 )
{
if (pcSlice->getPPS()->getNumSubstreams() > 1)
{
// independent tiles => substreams are "per tile". iNumSubstreams has already been multiplied.
iNumSubstreamsPerTile = iNumSubstreams/rpcPic->getPicSym()->getNumTiles();
uiSubStrm = rpcPic->getPicSym()->getTileIdxMap(iCUAddr)*iNumSubstreamsPerTile
+ uiLin%iNumSubstreamsPerTile;
}
else
{
// dependent tiles => substreams are "per frame".
uiSubStrm = uiLin % iNumSubstreams;
}
m_pcEntropyDecoder->setBitstream( ppcSubstreams[uiSubStrm] );
// Synchronize cabac probabilities with upper-right LCU if it's available and we're at the start of a line.
if (pcSlice->getPPS()->getNumSubstreams() > 1 && uiCol == uiTileLCUX)
{
// We'll sync if the TR is available.
TComDataCU *pcCUUp = pcCU->getCUAbove();
UInt uiWidthInCU = rpcPic->getFrameWidthInCU();
TComDataCU *pcCUTR = NULL;
if ( pcCUUp && ((iCUAddr%uiWidthInCU+1) < uiWidthInCU) )
{
pcCUTR = rpcPic->getCU( iCUAddr - uiWidthInCU + 1 );
}
UInt uiMaxParts = 1<<(pcSlice->getSPS()->getMaxCUDepth()<<1);
if ( (true/*bEnforceSliceRestriction*/ &&
((pcCUTR==NULL) || (pcCUTR->getSlice()==NULL) ||
((pcCUTR->getSCUAddr()+uiMaxParts-1) < pcSlice->getSliceCurStartCUAddr()) ||
((rpcPic->getPicSym()->getTileIdxMap( pcCUTR->getAddr() ) != rpcPic->getPicSym()->getTileIdxMap(iCUAddr)))
))||
(true/*bEnforceEntropySliceRestriction*/ &&
((pcCUTR==NULL) || (pcCUTR->getSlice()==NULL) ||
((pcCUTR->getSCUAddr()+uiMaxParts-1) < pcSlice->getEntropySliceCurStartCUAddr()) ||
((rpcPic->getPicSym()->getTileIdxMap( pcCUTR->getAddr() ) != rpcPic->getPicSym()->getTileIdxMap(iCUAddr)))
))
)
{
// TR not available.
}
else
{
// TR is available, we use it.
pcSbacDecoders[uiSubStrm].loadContexts( &m_pcBufferSbacDecoders[uiTileCol] );
}
}
pcSbacDecoder->load(&pcSbacDecoders[uiSubStrm]); //this load is used to simplify the code (avoid to change all the call to pcSbacDecoders)
}
else if ( iSymbolMode && pcSlice->getPPS()->getNumSubstreams() <= 1 )
{
// Set variables to appropriate values to avoid later code change.
iNumSubstreamsPerTile = 1;
}
if ( (iCUAddr == rpcPic->getPicSym()->getTComTile(rpcPic->getPicSym()->getTileIdxMap(iCUAddr))->getFirstCUAddr()) && // 1st in tile.
(iCUAddr!=0) && (iCUAddr!=rpcPic->getPicSym()->getPicSCUAddr(rpcPic->getSlice(rpcPic->getCurrSliceIdx())->getSliceCurStartCUAddr())/rpcPic->getNumPartInCU())) // !1st in frame && !1st in slice
{
if (pcSlice->getPPS()->getNumSubstreams() > 1)
{
// We're crossing into another tile, tiles are independent.
// When tiles are independent, we have "substreams per tile". Each substream has already been terminated, and we no longer
// have to perform it here.
// For TILES_DECODER, there can be a header at the start of the 1st substream in a tile. These are read when the substreams
// are extracted, not here.
}
else
{
#if CABAC_INIT_FLAG
SliceType sliceType = pcSlice->getSliceType();
if (pcSlice->getCabacInitFlag())
{
switch (sliceType)
{
case P_SLICE: // change initialization table to B_SLICE intialization
sliceType = B_SLICE;
break;
case B_SLICE: // change initialization table to P_SLICE intialization
sliceType = P_SLICE;
break;
default : // should not occur
assert(0);
}
}
m_pcEntropyDecoder->updateContextTables( sliceType, pcSlice->getSliceQp() );
#else
m_pcEntropyDecoder->updateContextTables( pcSlice->getSliceType(), pcSlice->getSliceQp() );
#endif
}
Bool bTileMarkerFoundFlag = false;
TComInputBitstream *pcTmpPtr;
pcTmpPtr = ppcSubstreams[uiSubStrm]; // for CABAC
for (UInt uiIdx=0; uiIdx<pcTmpPtr->getTileMarkerLocationCount(); uiIdx++)
{
if ( pcTmpPtr->getByteLocation() == (pcTmpPtr->getTileMarkerLocation( uiIdx )+2) )
{
bTileMarkerFoundFlag = true;
break;
}
}
if (bTileMarkerFoundFlag)
{
UInt uiTileIdx;
// Read tile index
m_pcEntropyDecoder->readTileMarker( uiTileIdx, rpcPic->getPicSym()->getBitsUsedByTileIdx() );
}
}
#if ENC_DEC_TRACE
g_bJustDoIt = g_bEncDecTraceEnable;
#endif
if ( pcSlice->getSPS()->getUseSAO() && pcSlice->getSaoInterleavingFlag() && pcSlice->getSaoEnabledFlag() )
{
pcSlice->getAPS()->getSaoParam()->bSaoFlag[0] = pcSlice->getSaoEnabledFlag();
if (iCUAddr == iStartCUAddr)
{
pcSlice->getAPS()->getSaoParam()->bSaoFlag[1] = pcSlice->getSaoEnabledFlagCb();
pcSlice->getAPS()->getSaoParam()->bSaoFlag[2] = pcSlice->getSaoEnabledFlagCr();
}
Int numCuInWidth = pcSlice->getAPS()->getSaoParam()->numCuInWidth;
Int cuAddrInSlice = iCUAddr - pcSlice->getSliceCurStartCUAddr()/rpcPic->getNumPartInCU();
Int cuAddrUpInSlice = cuAddrInSlice - numCuInWidth;
Int rx = iCUAddr % numCuInWidth;
Int ry = iCUAddr / numCuInWidth;
pcSbacDecoder->parseSaoOneLcuInterleaving(rx, ry, pcSlice->getAPS()->getSaoParam(),pcCU, cuAddrInSlice, cuAddrUpInSlice, pcSlice->getSPS()->getLFCrossSliceBoundaryFlag() );
}
m_pcCuDecoder->decodeCU ( pcCU, uiIsLast );
m_pcCuDecoder->decompressCU ( pcCU );
#if ENC_DEC_TRACE
g_bJustDoIt = g_bEncDecTraceDisable;
#endif
if( iSymbolMode )
{
/*If at the end of a LCU line but not at the end of a substream, perform CABAC flush*/
if (!uiIsLast && pcSlice->getPPS()->getNumSubstreams() > 1)
{
if ((uiCol == uiTileLCUX+uiTileWidth-1) && (uiLin+iNumSubstreamsPerTile < uiTileLCUY+uiTileHeight))
{
m_pcEntropyDecoder->decodeFlush();
}
}
pcSbacDecoders[uiSubStrm].load(pcSbacDecoder);
//Store probabilities of second LCU in line into buffer
if (pcSlice->getPPS()->getNumSubstreams() > 1 && (uiCol == uiTileLCUX+1))
{
m_pcBufferSbacDecoders[uiTileCol].loadContexts( &pcSbacDecoders[uiSubStrm] );
}
}
}
}
Bool TDecTop::xDecodeSlice(InputNALUnit &nalu, Int &iSkipFrame, Int iPOCLastDisplay )
{
m_apcSlicePilot->initSlice(); // the slice pilot is an object to prepare for a new slice
// it is not associated with picture, sps or pps structures.
if (m_bFirstSliceInPicture)
{
m_uiSliceIdx = 0;
}
else
{
m_apcSlicePilot->copySliceInfo( m_pcPic->getPicSym()->getSlice(m_uiSliceIdx-1) );
}
m_apcSlicePilot->setSliceIdx(m_uiSliceIdx);
m_apcSlicePilot->setNalUnitType(nalu.m_nalUnitType);
Bool nonReferenceFlag = (m_apcSlicePilot->getNalUnitType() == NAL_UNIT_CODED_SLICE_TRAIL_N ||
m_apcSlicePilot->getNalUnitType() == NAL_UNIT_CODED_SLICE_TSA_N ||
m_apcSlicePilot->getNalUnitType() == NAL_UNIT_CODED_SLICE_STSA_N ||
m_apcSlicePilot->getNalUnitType() == NAL_UNIT_CODED_SLICE_RADL_N ||
m_apcSlicePilot->getNalUnitType() == NAL_UNIT_CODED_SLICE_RASL_N);
m_apcSlicePilot->setTemporalLayerNonReferenceFlag(nonReferenceFlag);
m_apcSlicePilot->setReferenced(true); // Putting this as true ensures that picture is referenced the first time it is in an RPS
m_apcSlicePilot->setTLayerInfo(nalu.m_temporalId);
#if ENC_DEC_TRACE
const UInt64 originalSymbolCount = g_nSymbolCounter;
#endif
m_cEntropyDecoder.decodeSliceHeader (m_apcSlicePilot, &m_parameterSetManager);
// set POC for dependent slices in skipped pictures
if(m_apcSlicePilot->getDependentSliceSegmentFlag() && m_prevSliceSkipped)
{
m_apcSlicePilot->setPOC(m_skippedPOC);
}
m_apcSlicePilot->setAssociatedIRAPPOC(m_pocCRA);
m_apcSlicePilot->setAssociatedIRAPType(m_associatedIRAPType);
//For inference of NoOutputOfPriorPicsFlag
if (m_apcSlicePilot->getRapPicFlag())
{
if ((m_apcSlicePilot->getNalUnitType() >= NAL_UNIT_CODED_SLICE_BLA_W_LP && m_apcSlicePilot->getNalUnitType() <= NAL_UNIT_CODED_SLICE_IDR_N_LP) ||
(m_apcSlicePilot->getNalUnitType() == NAL_UNIT_CODED_SLICE_CRA && m_bFirstSliceInSequence) ||
(m_apcSlicePilot->getNalUnitType() == NAL_UNIT_CODED_SLICE_CRA && m_apcSlicePilot->getHandleCraAsBlaFlag()))
{
m_apcSlicePilot->setNoRaslOutputFlag(true);
}
//the inference for NoOutputPriorPicsFlag
if (!m_bFirstSliceInBitstream && m_apcSlicePilot->getRapPicFlag() && m_apcSlicePilot->getNoRaslOutputFlag())
{
if (m_apcSlicePilot->getNalUnitType() == NAL_UNIT_CODED_SLICE_CRA)
{
m_apcSlicePilot->setNoOutputPriorPicsFlag(true);
}
}
else
{
m_apcSlicePilot->setNoOutputPriorPicsFlag(false);
}
if(m_apcSlicePilot->getNalUnitType() == NAL_UNIT_CODED_SLICE_CRA)
{
m_craNoRaslOutputFlag = m_apcSlicePilot->getNoRaslOutputFlag();
}
}
if (m_apcSlicePilot->getRapPicFlag() && m_apcSlicePilot->getNoOutputPriorPicsFlag())
{
m_lastPOCNoOutputPriorPics = m_apcSlicePilot->getPOC();
m_isNoOutputPriorPics = true;
}
else
{
m_isNoOutputPriorPics = false;
}
//For inference of PicOutputFlag
if (m_apcSlicePilot->getNalUnitType() == NAL_UNIT_CODED_SLICE_RASL_N || m_apcSlicePilot->getNalUnitType() == NAL_UNIT_CODED_SLICE_RASL_R)
{
if ( m_craNoRaslOutputFlag )
{
m_apcSlicePilot->setPicOutputFlag(false);
}
}
if (m_apcSlicePilot->getNalUnitType() == NAL_UNIT_CODED_SLICE_CRA && m_craNoRaslOutputFlag) //Reset POC MSB when CRA has NoRaslOutputFlag equal to 1
{
TComPPS *pps = m_parameterSetManager.getPPS(m_apcSlicePilot->getPPSId());
assert (pps != 0);
TComSPS *sps = m_parameterSetManager.getSPS(pps->getSPSId());
assert (sps != 0);
Int iMaxPOClsb = 1 << sps->getBitsForPOC();
m_apcSlicePilot->setPOC( m_apcSlicePilot->getPOC() & (iMaxPOClsb - 1) );
}
// Skip pictures due to random access
if (isRandomAccessSkipPicture(iSkipFrame, iPOCLastDisplay))
{
m_prevSliceSkipped = true;
m_skippedPOC = m_apcSlicePilot->getPOC();
return false;
}
// Skip TFD pictures associated with BLA/BLANT pictures
if (isSkipPictureForBLA(iPOCLastDisplay))
{
m_prevSliceSkipped = true;
m_skippedPOC = m_apcSlicePilot->getPOC();
return false;
}
// clear previous slice skipped flag
m_prevSliceSkipped = false;
//we should only get a different poc for a new picture (with CTU address==0)
if (!m_apcSlicePilot->getDependentSliceSegmentFlag() && m_apcSlicePilot->getPOC()!=m_prevPOC && !m_bFirstSliceInSequence && (m_apcSlicePilot->getSliceCurStartCtuTsAddr() != 0))
{
printf ("Warning, the first slice of a picture might have been lost!\n");
}
// exit when a new picture is found
if (!m_apcSlicePilot->getDependentSliceSegmentFlag() && (m_apcSlicePilot->getSliceCurStartCtuTsAddr() == 0 && !m_bFirstSliceInPicture) )
{
if (m_prevPOC >= m_pocRandomAccess)
{
m_prevPOC = m_apcSlicePilot->getPOC();
#if ENC_DEC_TRACE
//rewind the trace counter since we didn't actually decode the slice
g_nSymbolCounter = originalSymbolCount;
#endif
return true;
}
m_prevPOC = m_apcSlicePilot->getPOC();
}
//detect lost reference picture and insert copy of earlier frame.
{
Int lostPoc;
while((lostPoc=m_apcSlicePilot->checkThatAllRefPicsAreAvailable(m_cListPic, m_apcSlicePilot->getRPS(), true, m_pocRandomAccess)) > 0)
{
xCreateLostPicture(lostPoc-1);
}
}
if (!m_apcSlicePilot->getDependentSliceSegmentFlag())
{
m_prevPOC = m_apcSlicePilot->getPOC();
}
// actual decoding starts here
xActivateParameterSets();
m_bFirstSliceInSequence = false;
m_bFirstSliceInBitstream = false;
TComSlice* pcSlice = m_pcPic->getPicSym()->getSlice(m_uiSliceIdx);
// When decoding the slice header, the stored start and end addresses were actually RS addresses, not TS addresses.
// Now, having set up the maps, convert them to the correct form.
pcSlice->setSliceSegmentCurStartCtuTsAddr( m_pcPic->getPicSym()->getCtuRsToTsAddrMap(pcSlice->getSliceSegmentCurStartCtuTsAddr()) );
pcSlice->setSliceSegmentCurEndCtuTsAddr( m_pcPic->getPicSym()->getCtuRsToTsAddrMap(pcSlice->getSliceSegmentCurEndCtuTsAddr()) );
if(!pcSlice->getDependentSliceSegmentFlag())
{
pcSlice->setSliceCurStartCtuTsAddr(m_pcPic->getPicSym()->getCtuRsToTsAddrMap(pcSlice->getSliceCurStartCtuTsAddr()));
pcSlice->setSliceCurEndCtuTsAddr(m_pcPic->getPicSym()->getCtuRsToTsAddrMap(pcSlice->getSliceCurEndCtuTsAddr()));
}
m_pcPic->setTLayer(nalu.m_temporalId);
if (!pcSlice->getDependentSliceSegmentFlag())
{
pcSlice->checkCRA(pcSlice->getRPS(), m_pocCRA, m_associatedIRAPType, m_cListPic );
// Set reference list
pcSlice->setRefPicList( m_cListPic, true );
// For generalized B
// note: maybe not existed case (always L0 is copied to L1 if L1 is empty)
if (pcSlice->isInterB() && pcSlice->getNumRefIdx(REF_PIC_LIST_1) == 0)
{
Int iNumRefIdx = pcSlice->getNumRefIdx(REF_PIC_LIST_0);
pcSlice->setNumRefIdx ( REF_PIC_LIST_1, iNumRefIdx );
for (Int iRefIdx = 0; iRefIdx < iNumRefIdx; iRefIdx++)
{
pcSlice->setRefPic(pcSlice->getRefPic(REF_PIC_LIST_0, iRefIdx), REF_PIC_LIST_1, iRefIdx);
}
}
if (!pcSlice->isIntra())
{
Bool bLowDelay = true;
Int iCurrPOC = pcSlice->getPOC();
Int iRefIdx = 0;
for (iRefIdx = 0; iRefIdx < pcSlice->getNumRefIdx(REF_PIC_LIST_0) && bLowDelay; iRefIdx++)
{
if ( pcSlice->getRefPic(REF_PIC_LIST_0, iRefIdx)->getPOC() > iCurrPOC )
{
bLowDelay = false;
}
}
if (pcSlice->isInterB())
{
for (iRefIdx = 0; iRefIdx < pcSlice->getNumRefIdx(REF_PIC_LIST_1) && bLowDelay; iRefIdx++)
{
if ( pcSlice->getRefPic(REF_PIC_LIST_1, iRefIdx)->getPOC() > iCurrPOC )
{
bLowDelay = false;
}
}
}
pcSlice->setCheckLDC(bLowDelay);
}
//---------------
pcSlice->setRefPOCList();
}
m_pcPic->setCurrSliceIdx(m_uiSliceIdx);
if(pcSlice->getSPS()->getScalingListFlag())
{
TComScalingList scalingList;
if(pcSlice->getPPS()->getScalingListPresentFlag())
{
scalingList = pcSlice->getPPS()->getScalingList();
}
else if (pcSlice->getSPS()->getScalingListPresentFlag())
{
scalingList = pcSlice->getSPS()->getScalingList();
}
else
{
scalingList.setDefaultScalingList();
}
m_cTrQuant.setScalingListDec(scalingList, pcSlice->getSPS()->getChromaFormatIdc());
m_cTrQuant.setUseScalingList(true);
}
else
{
m_cTrQuant.setFlatScalingList(pcSlice->getSPS()->getChromaFormatIdc());
m_cTrQuant.setUseScalingList(false);
}
// Decode a picture
m_cGopDecoder.decompressSlice(nalu.m_Bitstream, m_pcPic);
m_bFirstSliceInPicture = false;
m_uiSliceIdx++;
return false;
}
Void TDecTop::xActivateParameterSets()
{
if (m_bFirstSliceInPicture)
{
const TComPPS *pps = m_parameterSetManager.getPPS(m_apcSlicePilot->getPPSId()); // this is a temporary PPS object. Do not store this value
assert (pps != 0);
const TComSPS *sps = m_parameterSetManager.getSPS(pps->getSPSId()); // this is a temporary SPS object. Do not store this value
assert (sps != 0);
m_parameterSetManager.clearSPSChangedFlag(sps->getSPSId());
m_parameterSetManager.clearPPSChangedFlag(pps->getPPSId());
if (false == m_parameterSetManager.activatePPS(m_apcSlicePilot->getPPSId(),m_apcSlicePilot->isIRAP()))
{
printf ("Parameter set activation failed!");
assert (0);
}
// TODO: remove the use of the following globals:
for (UInt channel = 0; channel < MAX_NUM_CHANNEL_TYPE; channel++)
{
g_bitDepth[channel] = sps->getBitDepth(ChannelType(channel));
g_maxTrDynamicRange[channel] = (sps->getUseExtendedPrecision()) ? std::max<Int>(15, (g_bitDepth[channel] + 6)) : 15;
}
g_uiMaxCUWidth = sps->getMaxCUWidth();
g_uiMaxCUHeight = sps->getMaxCUHeight();
g_uiMaxCUDepth = sps->getMaxCUDepth();
g_uiAddCUDepth = max (0, sps->getLog2MinCodingBlockSize() - (Int)sps->getQuadtreeTULog2MinSize() + (Int)getMaxCUDepthOffset(sps->getChromaFormatIdc(), sps->getQuadtreeTULog2MinSize()));
// Get a new picture buffer. This will also set up m_pcPic, and therefore give us a SPS and PPS pointer that we can use.
xGetNewPicBuffer (*(sps), *(pps), m_pcPic, m_apcSlicePilot->getTLayer());
m_apcSlicePilot->applyReferencePictureSet(m_cListPic, m_apcSlicePilot->getRPS());
// make the slice-pilot a real slice, and set up the slice-pilot for the next slice
assert(m_pcPic->getNumAllocatedSlice() == (m_uiSliceIdx + 1));
m_apcSlicePilot = m_pcPic->getPicSym()->swapSliceObject(m_apcSlicePilot, m_uiSliceIdx);
// we now have a real slice:
TComSlice *pSlice = m_pcPic->getSlice(m_uiSliceIdx);
// Update the PPS and SPS pointers with the ones of the picture.
pps=pSlice->getPPS();
sps=pSlice->getSPS();
// Initialise the various objects for the new set of settings
m_cSAO.create( sps->getPicWidthInLumaSamples(), sps->getPicHeightInLumaSamples(), sps->getChromaFormatIdc(), sps->getMaxCUWidth(), sps->getMaxCUHeight(), sps->getMaxCUDepth(), pps->getSaoOffsetBitShift(CHANNEL_TYPE_LUMA), pps->getSaoOffsetBitShift(CHANNEL_TYPE_CHROMA) );
m_cLoopFilter.create( sps->getMaxCUDepth() );
m_cPrediction.initTempBuff(sps->getChromaFormatIdc());
Bool isField = false;
Bool isTopField = false;
if(!m_SEIs.empty())
{
// Check if any new Picture Timing SEI has arrived
SEIMessages pictureTimingSEIs = extractSeisByType (m_SEIs, SEI::PICTURE_TIMING);
if (pictureTimingSEIs.size()>0)
{
SEIPictureTiming* pictureTiming = (SEIPictureTiming*) *(pictureTimingSEIs.begin());
isField = (pictureTiming->m_picStruct == 1) || (pictureTiming->m_picStruct == 2) || (pictureTiming->m_picStruct == 9) || (pictureTiming->m_picStruct == 10) || (pictureTiming->m_picStruct == 11) || (pictureTiming->m_picStruct == 12);
isTopField = (pictureTiming->m_picStruct == 1) || (pictureTiming->m_picStruct == 9) || (pictureTiming->m_picStruct == 11);
}
}
//Set Field/Frame coding mode
m_pcPic->setField(isField);
m_pcPic->setTopField(isTopField);
// transfer any SEI messages that have been received to the picture
m_pcPic->setSEIs(m_SEIs);
m_SEIs.clear();
// Recursive structure
m_cCuDecoder.create ( sps->getMaxCUDepth(), sps->getMaxCUWidth(), sps->getMaxCUHeight(), sps->getChromaFormatIdc() );
m_cCuDecoder.init ( &m_cEntropyDecoder, &m_cTrQuant, &m_cPrediction );
m_cTrQuant.init ( sps->getMaxTrSize() );
m_cSliceDecoder.create();
}
else
{
// make the slice-pilot a real slice, and set up the slice-pilot for the next slice
m_pcPic->allocateNewSlice();
assert(m_pcPic->getNumAllocatedSlice() == (m_uiSliceIdx + 1));
m_apcSlicePilot = m_pcPic->getPicSym()->swapSliceObject(m_apcSlicePilot, m_uiSliceIdx);
TComSlice *pSlice = m_pcPic->getSlice(m_uiSliceIdx); // we now have a real slice.
const TComSPS *sps = pSlice->getSPS();
const TComPPS *pps = pSlice->getPPS();
// check that the current active PPS has not changed...
if (m_parameterSetManager.getSPSChangedFlag(sps->getSPSId()) )
{
printf("Error - a new SPS has been decoded while processing a picture\n");
exit(1);
}
if (m_parameterSetManager.getPPSChangedFlag(pps->getPPSId()) )
{
printf("Error - a new PPS has been decoded while processing a picture\n");
exit(1);
}
// Check if any new SEI has arrived
if(!m_SEIs.empty())
{
// Currently only decoding Unit SEI message occurring between VCL NALUs copied
SEIMessages &picSEI = m_pcPic->getSEIs();
SEIMessages decodingUnitInfos = extractSeisByType (m_SEIs, SEI::DECODING_UNIT_INFO);
picSEI.insert(picSEI.end(), decodingUnitInfos.begin(), decodingUnitInfos.end());
deleteSEIs(m_SEIs);
}
}
}
Void TDecTop::xActivateParameterSets()
{
if (m_bFirstSliceInPicture)
{
const TComPPS *pps = m_parameterSetManager.getPPS(m_apcSlicePilot->getPPSId()); // this is a temporary PPS object. Do not store this value
assert (pps != 0);
const TComSPS *sps = m_parameterSetManager.getSPS(pps->getSPSId()); // this is a temporary SPS object. Do not store this value
assert (sps != 0);
m_parameterSetManager.clearSPSChangedFlag(sps->getSPSId());
m_parameterSetManager.clearPPSChangedFlag(pps->getPPSId());
if (false == m_parameterSetManager.activatePPS(m_apcSlicePilot->getPPSId(),m_apcSlicePilot->isIRAP()))
{
printf ("Parameter set activation failed!");
assert (0);
}
xParsePrefixSEImessages();
#if RExt__HIGH_BIT_DEPTH_SUPPORT==0
if (sps->getSpsRangeExtension().getExtendedPrecisionProcessingFlag() || sps->getBitDepth(CHANNEL_TYPE_LUMA)>12 || sps->getBitDepth(CHANNEL_TYPE_CHROMA)>12 )
{
printf("High bit depth support must be enabled at compile-time in order to decode this bitstream\n");
assert (0);
exit(1);
}
#endif
// NOTE: globals were set up here originally. You can now use:
// g_uiMaxCUDepth = sps->getMaxTotalCUDepth();
// g_uiAddCUDepth = sps->getMaxTotalCUDepth() - sps->getLog2DiffMaxMinCodingBlockSize()
// Get a new picture buffer. This will also set up m_pcPic, and therefore give us a SPS and PPS pointer that we can use.
xGetNewPicBuffer (*(sps), *(pps), m_pcPic, m_apcSlicePilot->getTLayer());
m_apcSlicePilot->applyReferencePictureSet(m_cListPic, m_apcSlicePilot->getRPS());
// make the slice-pilot a real slice, and set up the slice-pilot for the next slice
assert(m_pcPic->getNumAllocatedSlice() == (m_uiSliceIdx + 1));
m_apcSlicePilot = m_pcPic->getPicSym()->swapSliceObject(m_apcSlicePilot, m_uiSliceIdx);
// we now have a real slice:
TComSlice *pSlice = m_pcPic->getSlice(m_uiSliceIdx);
// Update the PPS and SPS pointers with the ones of the picture.
pps=pSlice->getPPS();
sps=pSlice->getSPS();
// Initialise the various objects for the new set of settings
m_cSAO.create( sps->getPicWidthInLumaSamples(), sps->getPicHeightInLumaSamples(), sps->getChromaFormatIdc(), sps->getMaxCUWidth(), sps->getMaxCUHeight(), sps->getMaxTotalCUDepth(), pps->getPpsRangeExtension().getLog2SaoOffsetScale(CHANNEL_TYPE_LUMA), pps->getPpsRangeExtension().getLog2SaoOffsetScale(CHANNEL_TYPE_CHROMA) );
m_cLoopFilter.create( sps->getMaxTotalCUDepth() );
m_cPrediction.initTempBuff(sps->getChromaFormatIdc());
Bool isField = false;
Bool isTopField = false;
if(!m_SEIs.empty())
{
// Check if any new Picture Timing SEI has arrived
SEIMessages pictureTimingSEIs = getSeisByType(m_SEIs, SEI::PICTURE_TIMING);
if (pictureTimingSEIs.size()>0)
{
SEIPictureTiming* pictureTiming = (SEIPictureTiming*) *(pictureTimingSEIs.begin());
isField = (pictureTiming->m_picStruct == 1) || (pictureTiming->m_picStruct == 2) || (pictureTiming->m_picStruct == 9) || (pictureTiming->m_picStruct == 10) || (pictureTiming->m_picStruct == 11) || (pictureTiming->m_picStruct == 12);
isTopField = (pictureTiming->m_picStruct == 1) || (pictureTiming->m_picStruct == 9) || (pictureTiming->m_picStruct == 11);
}
}
//Set Field/Frame coding mode
m_pcPic->setField(isField);
m_pcPic->setTopField(isTopField);
// transfer any SEI messages that have been received to the picture
m_pcPic->setSEIs(m_SEIs);
m_SEIs.clear();
// Recursive structure
m_cCuDecoder.create ( sps->getMaxTotalCUDepth(), sps->getMaxCUWidth(), sps->getMaxCUHeight(), sps->getChromaFormatIdc() );
m_cCuDecoder.init ( &m_cEntropyDecoder, &m_cTrQuant, &m_cPrediction );
m_cTrQuant.init ( sps->getMaxTrSize() );
m_cSliceDecoder.create();
}
else
{
// make the slice-pilot a real slice, and set up the slice-pilot for the next slice
m_pcPic->allocateNewSlice();
assert(m_pcPic->getNumAllocatedSlice() == (m_uiSliceIdx + 1));
m_apcSlicePilot = m_pcPic->getPicSym()->swapSliceObject(m_apcSlicePilot, m_uiSliceIdx);
TComSlice *pSlice = m_pcPic->getSlice(m_uiSliceIdx); // we now have a real slice.
const TComSPS *sps = pSlice->getSPS();
const TComPPS *pps = pSlice->getPPS();
// check that the current active PPS has not changed...
if (m_parameterSetManager.getSPSChangedFlag(sps->getSPSId()) )
{
printf("Error - a new SPS has been decoded while processing a picture\n");
exit(1);
}
if (m_parameterSetManager.getPPSChangedFlag(pps->getPPSId()) )
{
printf("Error - a new PPS has been decoded while processing a picture\n");
exit(1);
}
xParsePrefixSEImessages();
// Check if any new SEI has arrived
if(!m_SEIs.empty())
{
// Currently only decoding Unit SEI message occurring between VCL NALUs copied
SEIMessages &picSEI = m_pcPic->getSEIs();
SEIMessages decodingUnitInfos = extractSeisByType (m_SEIs, SEI::DECODING_UNIT_INFO);
picSEI.insert(picSEI.end(), decodingUnitInfos.begin(), decodingUnitInfos.end());
deleteSEIs(m_SEIs);
}
}
}
