sequencestructure.cpp

JMVM MPEG MVC/3DAV 测试平台 国际通用标准

  {
    m_papcSequencePart[uiIndex]->reset();
  }

  m_uiCurrentPart       = 0;
  m_uiCurrentRepetition = 0;
}


ErrVal
SequenceStructure::GeneralSequencePart::check()
{
  ROFS( m_bInit );
  ROFS( m_uiNumberOfRepetitions );
  ROFS( m_uiNumberOfParts );

  for( UInt uiIndex = 0; uiIndex < m_uiNumberOfParts; uiIndex++ )
  {
    RNOKS( m_papcSequencePart[uiIndex]->check() );
  }

  return Err::m_nOK;
}


Bool
SequenceStructure::GeneralSequencePart::isFirstIDR()  const
{
  AOF_DBG( m_bInit );
  AOF_DBG( m_uiNumberOfParts );
  return m_papcSequencePart[0]->isFirstIDR();
}

UInt
SequenceStructure::GeneralSequencePart::getMinDPBSizeRef()  const
{
  AOF_DBG(m_bInit);
  return m_uiMinDPBSizeRef;
}


UInt
SequenceStructure::GeneralSequencePart::getMinDPBSizeNonRef()  const
{
  AOF_DBG(m_bInit);
  return m_uiMinDPBSizeNonRef;
}


Bool
SequenceStructure::GeneralSequencePart::getNextFrameSpec( FrameSpec& rcFrameSpec,
                                                          UInt&      uiFrameNumPartOffset)
{
  AOF_DBG( m_bInit );

  //----- set frame Spec -----
  Bool  bPartFinished     = false;
  Bool  bCurrPartFinished = m_papcSequencePart[ m_uiCurrentPart ]->getNextFrameSpec( rcFrameSpec, uiFrameNumPartOffset );

  //----- update parameters -----
  if( bCurrPartFinished )
  {
    if( ++m_uiCurrentPart == m_uiNumberOfParts )
    {
      m_uiCurrentPart = 0;

      if( ++m_uiCurrentRepetition == m_uiNumberOfRepetitions )
      {
        m_uiCurrentRepetition = 0;
        bPartFinished         = true;
      }
    }
  }

  return bPartFinished;
}
//================================= General Sequence Part : end ===================================





//================================= Sequence Structure : begin ===================================
SequenceStructure::SequenceStructure()
: m_bInit             ( false )
, m_pcSequencePart    ( 0     )
{
}

SequenceStructure::~SequenceStructure()
{
  uninit();
}


ErrVal
SequenceStructure::create( SequenceStructure*& rpcSequenceStructure )
{
  rpcSequenceStructure = new SequenceStructure;
  ROT( rpcSequenceStructure == NULL );
  return Err::m_nOK;
}

ErrVal
SequenceStructure::destroy()
{
  delete this;
  return Err::m_nOK;
}

ErrVal
SequenceStructure::uninit()
{
  m_cFrameSpec.uninit();

  delete m_pcSequencePart;
  m_pcSequencePart = 0;

  m_bInit = false;
  return Err::m_nOK;
}

ErrVal
SequenceStructure::init( const String& rcString,
                         UInt          uiNumberOfFrames )
{
  uninit();

  if( FormattedStringParser::isFrameSequencePart( rcString ) )
  {
    ROFS( ( m_pcSequencePart = new FrameSequencePart   () ) );
    RNOKS(   m_pcSequencePart->init( rcString ) );
  }
  else
  {
    ROFS( ( m_pcSequencePart = new GeneralSequencePart () ) );
    String cString = "*n{" + rcString + "}";   // to be on the safe side
    RNOKS(   m_pcSequencePart->init( cString ) );
  }

  //----- init parameters -----
  m_bInit                     = true;
  m_uiNumberOfTotalFrames     = uiNumberOfFrames;
  m_uiNumberOfFramesProcessed = 0;
  m_uiFrameNumPartOffset      = 0;
  m_uiNumIDR                  = 0;
  m_uiNumIntra                = 0;
  m_uiNumRef                  = 0;
  m_uiNumCoded                = 0;
  m_uiMaxAbsFrameDiffRef      = 0;
  m_uiMinDelay                = 0;
  m_uiMaxLayer                = 0;

  if( uiNumberOfFrames != MSYS_UINT_MAX )
  {
    xInitParameters();
  }

  return Err::m_nOK;
}

Void
SequenceStructure::reset()
{
  m_pcSequencePart->reset  ();
  m_cFrameSpec    . uninit ();

  m_uiNumberOfFramesProcessed = 0;
  m_uiFrameNumPartOffset      = 0;
}


ErrVal
SequenceStructure::check()
{
  ROFS  ( m_bInit );
  RNOKS ( m_pcSequencePart->check() );
  return Err::m_nOK;
}


const FrameSpec&
SequenceStructure::getFrameSpec()
{
  AOF_DBG( m_bInit );
  AOF_DBG( m_cFrameSpec.isInitialized() );
  return m_cFrameSpec;
}


const FrameSpec&
SequenceStructure::getNextFrameSpec()
{
  AOF_DBG( m_bInit );
  ANOK   ( xGetNextValidFrameSpec( m_cFrameSpec, m_uiNumberOfTotalFrames ) );
  return m_cFrameSpec;
}


Bool
SequenceStructure::checkString( const String&  rcString )
{
  SequenceStructure cSStruct;
  
  ROFRS( cSStruct.init        ( rcString, MSYS_UINT_MAX ) == Err::m_nOK, true );
  ROFRS( cSStruct.check       ()                          == Err::m_nOK, true );
  ROFRS( cSStruct.xIsFirstIDR (),                                        true );
  return false;
}


ErrVal
SequenceStructure::debugOutput( const String&  rcString,
                                UInt           uiNumberOfFrames,
                                FILE*          pcFile )
{
  SequenceStructure cSStruct;

  RNOKS( cSStruct.init  ( rcString, uiNumberOfFrames )  );
  RNOKS( cSStruct.check () );

  for( UInt uiIndex = 0; uiIndex < uiNumberOfFrames; uiIndex++ )
  {
    const FrameSpec&  cFSpec   = cSStruct.getNextFrameSpec();
    String            cTypeStr;
    String            cStoreStr;
    String            cKeyStr;
    String            cMmcoString;
    String            cRplrL0String;
    String            cRplrL1String;

    if( cFSpec.getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR )
    {
      cTypeStr = " IDR ";
    }
    else if( cFSpec.getSliceType() == I_SLICE )
    {
      cTypeStr = "   I ";
    }
    else if( cFSpec.getSliceType() == P_SLICE )
    {
      cTypeStr = "   P ";
    }
    else if( cFSpec.getSliceType() == B_SLICE )
    {
      cTypeStr = "   B ";
    }
    else
    {
     AF();
    }

    if( cFSpec.getNalRefIdc() == NAL_REF_IDC_PRIORITY_LOWEST )
    {
      cStoreStr = "        ";
    }
    else
    {
      cStoreStr = " stored ";
    }

    if( cFSpec.isKeyPicture() )
    {
      cKeyStr   = " key ";
    }
    else
    {
      cKeyStr   = "     ";
    }

    if( cFSpec.getMmcoBuf() )
    {
      cMmcoString = " MMCO ";
    }
    else
    {
      cMmcoString = "      ";
    }

    if( cFSpec.getRplrBuf( LIST_0 ) )
    {
      cRplrL0String = " RPLR-L0 ";
    }
    else
    {
      cRplrL0String = "         ";
    }

    if( cFSpec.getRplrBuf( LIST_1 ) )
    {
      cRplrL1String = " RPLR-L1 ";
    }
    else
    {
      cRplrL1String = "         ";
    }

    fprintf( pcFile, "%5d%sL%d%s%s%s%s%s\n",
      cFSpec.getContFrameNumber(),
      cTypeStr.c_str(),
      cFSpec.getTemporalLayer(),
      cStoreStr.c_str(),
      cKeyStr.c_str(),
      cMmcoString.c_str(),
      cRplrL0String.c_str(),
      cRplrL1String.c_str() );
  }

  return Err::m_nOK;
}


UInt
SequenceStructure::getNumberOfTotalFrames()  const
{
  AOF_DBG(m_bInit); 
  return m_uiNumberOfTotalFrames;
}

UInt
SequenceStructure::getNumberOfIDRFrames()  const 
{
  AOF_DBG(m_bInit); 
  return m_uiNumIDR; 
}

UInt
SequenceStructure::getNumberOfIntraFrames()  const 
{
  AOF_DBG(m_bInit); 
  return m_uiNumIntra; 
}

UInt
SequenceStructure::getNumberOfInterFrames()  const
{
  AOF_DBG(m_bInit); 
  return m_uiNumCoded - m_uiNumIntra;
}

UInt
SequenceStructure::getNumberOfRefFrames()  const
{ 
  AOF_DBG( m_bInit );
  return m_uiNumRef;
}

UInt
SequenceStructure::getNumberOfCodedFrames()  const
{
  AOF_DBG( m_bInit );
  return m_uiNumCoded;
}

UInt
SequenceStructure::getMaxAbsFrameDiffRef()  const 
{ 
  AOF_DBG( m_bInit ); 
  return m_uiMaxAbsFrameDiffRef;
}

UInt
SequenceStructure::getMinDelay()  const
{ 
  AOF_DBG( m_bInit ); 
  return m_uiMinDelay;
}

UInt
SequenceStructure::getNumTemporalLayers()  const 
{ 
  AOF_DBG( m_bInit );
  return m_uiMaxLayer + 1;
}



Bool
SequenceStructure::xIsFirstIDR()
{
  AOF_DBG( m_bInit );
  return m_pcSequencePart->isFirstIDR();
}


Void
SequenceStructure::xInitParameters()
{
  AOF_DBG( m_bInit );

  m_uiNumIDR                  = 0;
  m_uiNumIntra                = 0;
  m_uiNumRef                  = 0;
  m_uiNumCoded                = 0;
  m_uiMaxAbsFrameDiffRef      = 0;
  m_uiMinDelay                = 0;
  m_uiMaxLayer                = 0;
  Int       iLastFrameNumRef  = 0;
  FrameSpec cFSpec;

  for( UInt uiIndex = 0; uiIndex < m_uiNumberOfTotalFrames; uiIndex++ )
  {
    ANOK( xGetNextValidFrameSpec( cFSpec, m_uiNumberOfTotalFrames ) );

    //----- add up frame counts -----
    if( ! cFSpec.isSkipped() )
    {
      m_uiNumCoded++;
    }
    if( cFSpec.getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR )
    {
      m_uiNumIDR++;
    }
    if( cFSpec.getSliceType() == I_SLICE )
    {
      m_uiNumIntra++;
    }
    if( cFSpec.getNalRefIdc() )
    {
      m_uiNumRef++;
    }

    //----- check Delay -----
    if( (Int)uiIndex - (Int)cFSpec.getContFrameNumber() > (Int)m_uiMinDelay )
    {
      m_uiMinDelay = uiIndex - cFSpec.getContFrameNumber ();
    }

    //----- check Layer -----
    if( cFSpec.getTemporalLayer() > m_uiMaxLayer )
    {
      m_uiMaxLayer = cFSpec.getTemporalLayer();
    }

    //----- check POC differences -----
    if( uiIndex == 0 )
    {
      AOT_DBG( cFSpec.getNalUnitType() != NAL_UNIT_CODED_SLICE_IDR );
      iLastFrameNumRef = cFSpec.getContFrameNumber();
    }
    else
    {
      if( ! cFSpec.isSkipped() )
      {
        Int   iFrameNumber      = cFSpec.getContFrameNumber();
        UInt  uiAbsFrameDiffRef = abs( iFrameNumber - iLastFrameNumRef );
        if( uiAbsFrameDiffRef > m_uiMaxAbsFrameDiffRef )
        {
          m_uiMaxAbsFrameDiffRef = uiAbsFrameDiffRef;
        }
        if( cFSpec.getNalRefIdc() )
        {
          iLastFrameNumRef = iFrameNumber;
        }
      }
    }
  }

  reset();
}


ErrVal
SequenceStructure::xGetNextValidFrameSpec( FrameSpec& rcFrameSpec,
                                           UInt       uiTotalFrames )
{
  rcFrameSpec.uninit();

  ROF( m_uiNumberOfFramesProcessed < uiTotalFrames );

  while( ! rcFrameSpec.isInitialized() )
  {
    m_pcSequencePart->getNextFrameSpec( rcFrameSpec, m_uiFrameNumPartOffset );

    if( rcFrameSpec.getContFrameNumber() >= uiTotalFrames )
    {
      rcFrameSpec.uninit();
    }
  }

  m_uiNumberOfFramesProcessed++;
  return Err::m_nOK;
}
//================================= Sequence Structure : end ===================================





//================================= FormattedStringParser : begin ===================================
const String FormattedStringParser::sm_cSetOfTypes      ("AIPBSipbs");
const String FormattedStringParser::sm_cSetOfDigits     ("0123456789");
const String FormattedStringParser::sm_cSetOfPartStart  ("AIPBSipbs*");