📄 extractor.cpp
字号:
for(UInt ui = 0; ui < (UInt)m_aaiNumLevels[uiLayer][uiNumFrame]; ui++)
{
m_aaauiBytesForQualityLevel[uiLayer][ui][uiNumFrame] = cPacketDescription.auiDeltaBytesRateOfLevelQL[ui];
m_aaadQualityLevel[uiLayer][ui][uiNumFrame] = cPacketDescription.auiQualityLevelQL[ui];
}
bApplyToNext = false;
}
else
{
if(m_bQualityLevelInSEI == false)
{
if(uiFGSLayer != 0)
m_aaadQualityLevel[uiLayer][uiFGSLayer][uiNumFrame] = uiPId;
else
m_aaadQualityLevel[uiLayer][uiFGSLayer][uiNumFrame] = 63;
}
}
}
//}}Quality level estimation and modified truncation- JVTO044 and m12007
//S051{
if(m_bUseSIP)
{
const MyList<ExtractorParameter::Point>& rcExtList = m_pcExtractorParameter->getExtractionList();
ROT( rcExtList.size() != 1 );
MyList<ExtractorParameter::Point>::const_iterator cIter = rcExtList.begin ();
const ExtractorParameter::Point& rcExtPoint = *cIter;
UInt uiExtLayer = MSYS_UINT_MAX;
//----- layer -----
for( UInt i = 0; i < m_cScalableStreamDescription.getNumberOfLayers(); i++ )
{
if( rcExtPoint.uiWidth < m_cScalableStreamDescription.getFrameWidth (i) ||
rcExtPoint.uiHeight < m_cScalableStreamDescription.getFrameHeight(i) )
{
break;
}
uiExtLayer = i;
}
if(!cPacketDescription.bDiscardable||cPacketDescription.Layer>=uiExtLayer)
{
RNOK( m_cScalableStreamDescription.addPacket( uiPacketSize, uiLayer, uiLevel, uiFGSLayer, bNewPicture ) );
}
else
{
RNOK( m_cScalableStreamDescription.addPacketNoUse( uiPacketSize, uiLayer, uiLevel, uiFGSLayer, bNewPicture ) );
}
}
else
//S051}
//JVT-P031
if(!m_bExtractDeadSubstream[uiLayer]|| !cPacketDescription.bDiscardable)
RNOK( m_cScalableStreamDescription.addPacket( uiPacketSize, uiLayer, uiLevel, uiFGSLayer, bNewPicture ) );
//~JVT-P031
UInt eNalUnitType = cPacketDescription.NalUnitType;
if( !cPacketDescription.bDiscardable && (eNalUnitType == NAL_UNIT_CODED_SLICE ||
eNalUnitType == NAL_UNIT_CODED_SLICE_IDR ||
eNalUnitType == NAL_UNIT_CODED_SLICE_SCALABLE ||
eNalUnitType == NAL_UNIT_CODED_SLICE_IDR_SCALABLE) )
{
m_cScalableStreamDescription.m_bSPSRequired[uiLayer][cPacketDescription.SPSid] = true;
m_cScalableStreamDescription.m_bPPSRequired[uiLayer][cPacketDescription.PPSid] = true;
}
//JVT-P031
//add packet to calculate maxrate (rate before discardable stream
if(!m_bExtractDeadSubstream[uiLayer] || !cPacketDescription.bDiscardable)
m_aaadMaxRate[uiLayer][uiNumFrame] += uiPacketSize;
//~JVT-P031
//{{Quality level estimation and modified truncation- JVTO044 and m12007
//France Telecom R&D-(nathalie.cammas@francetelecom.com)
addPacket(uiLayer, uiNumFrame,uiFGSLayer,uiPacketSize);
if(bNewPicture)
setLevel(uiLayer, uiLevel,uiNumFrame);
//}}Quality level estimation and modified truncation- JVTO044 and m12007
if(pcBinData)
{
RNOK( m_pcReadBitstream->releasePacket( pcBinData ) );
pcBinData = NULL;
}
}
RNOK( m_cScalableStreamDescription.analyse() );
m_uiScalableNumLayersMinus1 = pcTmpScalableSei->getNumLayersMinus1();
for( UInt uiScalableLayerId = 0; uiScalableLayerId <= m_uiScalableNumLayersMinus1; uiScalableLayerId++ )
{
UInt uiDependencyId = pcTmpScalableSei->getDependencyId( uiScalableLayerId );
UInt uiQualityLevel = pcTmpScalableSei->getQualityLevel(uiScalableLayerId);
UInt uiTempLevel = pcTmpScalableSei->getTemporalLevel(uiScalableLayerId);
m_auiDependencyId[uiScalableLayerId] = uiDependencyId;
m_auiTempLevel [uiScalableLayerId] = uiTempLevel;
m_auiQualityLevel[uiScalableLayerId] = uiQualityLevel;
UInt uiBitrate = pcTmpScalableSei->getAvgBitrate(uiScalableLayerId);
m_auiFrmWidth[uiScalableLayerId] = (pcTmpScalableSei->getFrmWidthInMbsMinus1(uiScalableLayerId)+1) << 4;
m_auiFrmHeight[uiScalableLayerId] = (pcTmpScalableSei->getFrmHeightInMbsMinus1(uiScalableLayerId)+1) << 4;
m_adFramerate[uiScalableLayerId] = (pcTmpScalableSei->getAvgFrmRate(uiScalableLayerId))/256.0;
m_aaauiScalableLayerId[uiDependencyId][uiTempLevel][uiQualityLevel] = uiScalableLayerId;
m_aaadSingleBitrate[uiDependencyId][uiTempLevel][uiQualityLevel] = (Double) uiBitrate;
m_adTotalBitrate[uiScalableLayerId] = 0; //initial value
if(pcTmpScalableSei->getNumDirectlyDependentLayers(uiScalableLayerId))
m_auiDirDepLayer[uiScalableLayerId] = pcTmpScalableSei->getNumDirectlyDependentLayerIdDeltaMinus1(uiScalableLayerId, 0); //JVT-S036 lsj
else
m_auiDirDepLayer[uiScalableLayerId] = MSYS_UINT_MAX;
if(!m_adFrameRate[uiTempLevel])
m_adFrameRate[uiTempLevel] = pcTmpScalableSei->getAvgFrmRate(uiScalableLayerId)/256.0;
}
uiMaxLayer = pcTmpScalableSei->getDependencyId( m_uiScalableNumLayersMinus1);
uiMaxTempLevel = pcTmpScalableSei->getTemporalLevel(m_uiScalableNumLayersMinus1);
//NS leak fix extractor begin
if (pcTmpScalableSei)
{
pcScalableSei = (h264::SEI::ScalableSei*) pcTmpScalableSei;
delete pcScalableSei;
pcTmpScalableSei = NULL;
pcScalableSei = NULL;
}
//NS leak fix extractor end
for( UInt uiDependencyId = 0; uiDependencyId <= uiMaxLayer; uiDependencyId++)
{
UInt uiMinTL = 0;
for( UInt uiTempLevel = uiMinTL; uiTempLevel <= uiMaxTempLevel; uiTempLevel++)
{
for( UInt uiFGS = 0; uiFGS < MAX_QUALITY_LEVELS; uiFGS++)
{
UInt uiScalableLayerIdDes = getScalableLayer( uiDependencyId, uiTempLevel, uiFGS );
if(uiScalableLayerIdDes == MSYS_UINT_MAX) // No such scalable layers
continue;
if(m_auiDirDepLayer[uiScalableLayerIdDes] == MSYS_UINT_MAX) // no direct dependent layer
{ //usually base layer: D=0,T=0,Q=0
m_aadMinBitrate[uiDependencyId][uiTempLevel] = m_aaadSingleBitrate[uiDependencyId][uiTempLevel][uiFGS];
m_adTotalBitrate[uiScalableLayerIdDes] = m_aaadSingleBitrate[uiDependencyId][uiTempLevel][uiFGS];
}
else//with direct dependent layer
{
UInt uiScalableLayerIdBas = uiScalableLayerIdDes - m_auiDirDepLayer[uiScalableLayerIdDes];
UInt uiDepLayer = m_auiDependencyId[uiScalableLayerIdBas];
UInt uiDepTL = m_auiTempLevel[uiScalableLayerIdBas];
if( uiFGS ) //Q!=0
{
assert(uiScalableLayerIdBas == getScalableLayer( uiDependencyId, uiTempLevel, uiFGS-1 ));
m_adTotalBitrate[uiScalableLayerIdDes] = m_adTotalBitrate[uiScalableLayerIdBas];
for( UInt uiTIndex = 0; uiTIndex <= uiTempLevel; uiTIndex++)
m_adTotalBitrate[uiScalableLayerIdDes] += m_aaadSingleBitrate[uiDependencyId][uiTIndex][uiFGS]
*m_cScalableStreamDescription.getNumPictures( uiMaxLayer, uiTIndex )
/m_cScalableStreamDescription.getNumPictures( uiMaxLayer, uiTempLevel )
*(1 << (uiTempLevel-uiTIndex));
}
else if( uiTempLevel ) // T != 0, Q = 0
{
m_aadMinBitrate[uiDependencyId][uiTempLevel] = m_aadMinBitrate[uiDepLayer][uiDepTL]
*m_cScalableStreamDescription.getNumPictures( uiMaxLayer, uiDepTL )
/m_cScalableStreamDescription.getFrameRate(uiMaxLayer, uiDepTL )
*m_cScalableStreamDescription.getFrameRate(uiMaxLayer, uiTempLevel )
/m_cScalableStreamDescription.getNumPictures( uiMaxLayer, uiTempLevel );
m_aadMinBitrate[uiDependencyId][uiTempLevel] += m_aaadSingleBitrate[uiDependencyId][uiTempLevel][uiFGS];
m_adTotalBitrate[uiScalableLayerIdDes] = m_adTotalBitrate[uiScalableLayerIdBas]
*m_cScalableStreamDescription.getNumPictures( uiMaxLayer, uiDepTL )
/m_cScalableStreamDescription.getNumPictures( uiMaxLayer, uiTempLevel )
*(1 << (uiTempLevel-uiDepTL));
m_adTotalBitrate[uiScalableLayerIdDes] += m_aaadSingleBitrate[uiDependencyId][uiTempLevel][uiFGS];
if( uiDependencyId ) //D>0, T>0, Q=0
{
UInt uiTmpDependencyId = uiDependencyId;
while(true)
{
UInt uiTmpScalableLayer = getScalableLayer(uiTmpDependencyId, 0, 0);
UInt uiTmpScalableLayerIdBas = uiTmpScalableLayer - m_auiDirDepLayer[uiTmpScalableLayer];
UInt uiTmpDepLayer = m_auiDependencyId[uiTmpScalableLayerIdBas];
UInt uiTmpDepQuality = m_auiQualityLevel[uiTmpScalableLayerIdBas];
//bitrate calculation
m_aadMinBitrate[uiDependencyId][uiTempLevel] += m_aaadSingleBitrate[uiTmpDepLayer][uiTempLevel][uiFGS];
for( UInt uiQualityLevel = 0; uiQualityLevel <= uiTmpDepQuality; uiQualityLevel++ )
m_adTotalBitrate[uiScalableLayerIdDes] += m_aaadSingleBitrate[uiTmpDepLayer][uiTempLevel][uiQualityLevel];
uiTmpDependencyId = uiTmpDepLayer;
if( !uiTmpDependencyId )
break;
}
}
}
else //D!=0, T=0, Q=0
{
m_aadMinBitrate[uiDependencyId][uiTempLevel] = m_aadMinBitrate[uiDepLayer][uiTempLevel]
+ m_aaadSingleBitrate[uiDependencyId][uiTempLevel][uiFGS];
m_adTotalBitrate[uiScalableLayerIdDes] = m_aaadSingleBitrate[uiDependencyId][uiTempLevel][uiFGS]
+ m_adTotalBitrate[uiScalableLayerIdBas];
}
}
}
}
}
xOutput( );
//----- reset input file -----
RNOKS( static_cast<ReadBitstreamFile*>(m_pcReadBitstream)->uninit() );
RNOKS( static_cast<ReadBitstreamFile*>(m_pcReadBitstream)->init ( m_pcExtractorParameter->getInFile() ) );
//initialize max rate for each frame
//if dead substream is present for the layer: max rate is equal to max rate before dead substream
//else max rate is equal to the rate of the frame
if(m_bInInputStreamQL)
{
setQualityLevel();
UInt uiLayerDeb = 0;
if(m_bInInputStreamDS == false)
{
uiLayerDeb = 0;
}
else
{
uiLayerDeb = m_cScalableStreamDescription.getNumberOfLayers()-1;
}
for(uiLayer = uiLayerDeb; uiLayer < m_cScalableStreamDescription.getNumberOfLayers();uiLayer++)
{
CalculateMaxRate(uiLayer);
}
}
//}}Quality level estimation and modified truncation- JVTO044 and m12007
return Err::m_nOK;
}
UInt Extractor::addPIDToTable(UInt uiPID)
{
//look if uiPID already in table
UInt ui;
for(ui=0;ui<m_uiNbPID;ui++)
{
if(m_auiPID[ui] == uiPID)
return 0;
}
m_auiPID[m_uiNbPID] = uiPID;
m_uiNbPID++;
return 1;
}
ErrVal
Extractor::xSetParameters()
{
RNOK( xGetExtParameters() );
UInt uiLayer, uiLevel, uiFGSLayer;
UInt uiExtLayer = m_pcExtractorParameter->getLayer();
UInt uiExtLevel = m_pcExtractorParameter->getLevel();
//JVT-T054{
Bool bQuit = false;
//JVT-T054}
//=========== clear all ===========
for( uiLayer = 0; uiLayer < MAX_LAYERS; uiLayer++ )
for( uiLevel = 0; uiLevel <= MAX_DSTAGES; uiLevel++ )
{
m_aadTargetSNRLayer[uiLayer][uiLevel] = -1;
m_aadTargetSNRLayerNoUse[uiLayer][uiLevel] = -1;
}
//===== get and set required base layer packets ======
Double dRemainingBytes = m_pcExtractorParameter->getTargetRate();
RNOK( GetAndCheckBaseLayerPackets( dRemainingBytes ) );
if( dRemainingBytes < 0 )
return Err::m_nOK;
//===== set maximum possible bytes for included layers ======
for( uiLayer = 0; uiLayer < uiExtLayer; uiLayer++ )
{
for( uiLevel = 0; uiLevel <= uiExtLevel; uiLevel++ )
{
for( uiFGSLayer = 1; uiFGSLayer < MAX_QUALITY_LEVELS; uiFGSLayer++ )
{
Int64 i64NALUBytes = m_cScalableStreamDescription.getNALUBytes( uiLayer, uiLevel, uiFGSLayer );
if( (Double)i64NALUBytes <= dRemainingBytes )
{
dRemainingBytes -= (Double)i64NALUBytes;
m_aadTargetSNRLayer[uiLayer][uiLevel] = (Double)uiFGSLayer;
m_pcExtractorParameter->setMaxFGSLayerKept(uiFGSLayer);
}
else
{
//JVT-T054{
if(m_bEnableQLTruncation[uiLayer][uiFGSLayer-1])
{
//JVT-T054}
//====== set fractional FGS layer and exit =====
m_uiTruncateLayer = uiLayer;
m_uiTruncateLevel = uiLevel;
m_uiTruncateFGSLayer = uiFGSLayer;
Double dFGSLayer = dRemainingBytes / (Double)i64NALUBytes;
m_aadTargetSNRLayer[uiLayer][uiLevel] += dFGSLayer;
m_pcExtractorParameter->setMaxFGSLayerKept(uiFGSLayer);
Double dDecBitrate = m_aaadSingleBitrate[m_uiTruncateLayer][m_uiTruncateLevel][m_uiTruncateFGSLayer] * (1-dFGSLayer);
RNOK( xResetSLFGSBitrate( m_uiTruncateLayer, m_uiTruncateLevel, m_uiTruncateFGSLayer, dDecBitrate ) );
RNOK( xResetSLFGSBitrate( m_uiTruncateLayer, m_uiTruncateLevel+1, 0, 0 ) );
return Err::m_nOK;
//JVT-T054{
}
else
{
dRemainingBytes -= (Double)i64NALUBytes;
m_aadTargetSNRLayer[uiLayer][uiLevel] = (Double)uiFGSLayer;
m_pcExtractorParameter->setMaxFGSLayerKept(uiFGSLayer);
bQuit = true;
}
//JVT-T054}
}
}
}
}
//JVT-T054{
if(bQuit)
{
m_uiTruncateLayer = uiExtLayer;
m_uiTruncateLevel = uiExtLevel;
m_uiTruncateFGSLayer = m_pcExtractorParameter->getMaxFGSLayerKept();
return Err::m_nOK;
}
//JVT-T054}
//===== set FGS layer for current layer =====
for( uiFGSLayer = 1; uiFGSLayer < MAX_QUALITY_LEVELS; uiFGSLayer++ )
{
Int64 i64FGSLayerBytes = 0;
for( uiLevel = 0; uiLevel <= uiExtLevel; uiLevel++ )
{
i64FGSLayerBytes += m_cScalableStreamDescription.getNALUBytes( uiExtLayer, uiLevel, uiFGSLayer );
}
if( (Double)i64FGSLayerBytes <= dRemainingBytes )
{
dRemainingBytes -= (Double)i64FGSLayerBytes;
for( uiLevel = 0; uiLevel <= uiExtLevel; uiLevel++ )
{
m_aadTargetSNRLayer[uiExtLayer][uiLevel] = (Double)uiFGSLayer;
m_pcExtractorParameter->setMaxFGSLayerKept(uiFGSLayer);
}
}
else
{
//JVT-T054{
if(!m_bEnableQLTruncation[uiExtLayer][uiFGSLayer-1])
{
m_uiTruncateLayer = uiExtLayer;
m_uiTruncateLevel = uiExtLevel;
m_uiTruncateFGSLayer = uiFGSLayer;
for( uiLevel = 0; uiLevel <= uiExtLevel; uiLevel++ )
{
i64FGSLayerBytes = m_cScalableStreamDescription.getNALUBytes( uiExtLayer, uiLevel, uiFGSLayer );
if( (Double)i64FGSLayerBytes <= dRemainingBytes )
{
dRemainingBytes -= (Double)i64FGSLayerBytes;
m_aadTargetSNRLayer[uiExtLayer][uiLevel] = (Double)uiFGSLayer;
m_pcExtractorParameter->setMaxFGSLayerKept(uiFGSLayer);
}
else
{
UInt uiTL;
m_uiTruncateLevel = uiLevel;
//Then reset all above layers' bitrate
for( uiTL = uiLevel; uiTL < MAX_TEMP_LEVELS; uiTL++ )
m_aaadSingleBitrate[uiExtLayer][uiTL][uiFGSLayer] = 0;
for( uiTL = 0; uiTL < MAX_TEMP_LEVELS; uiTL++ )
for( UInt uiFGS = m_uiTruncateFGSLayer+1; uiFGS < MAX_QUALITY_LEVELS; uiFGS++ )
m_aaadSingleBitrate[uiExtLayer][uiTL][uiFGS] = 0;
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -