sequencestructure.cpp

JVT-Z203_jsvm.rar

//================================= 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.isBaseRep() )
    {
      cKeyStr   = " base ";
    }
    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*");


ErrVal
FormattedStringParser::separatString( const String& rcString,
                                      String&       rcFDString,
                                      String&       rcMmcoString,
                                      String&       rcRplrStringL0,
                                      String&       rcRplrStringL1 )
{
  UInt uiMPos   = rcString.find_first_of( "M" );
  UInt uiR1Pos  = rcString.find_first_of( "R" );
  UInt uiR2Pos  = rcString.find_last_of ( "R" );
  UInt uiSize   = rcString.size();

  if( String::npos == uiMPos ) // MMCO commands are not present
  {
    rcMmcoString           = "";

    if( String::npos == uiR1Pos )
    {
      rcFDString           = rcString;
      rcRplrStringL0       = "";
      rcRplrStringL1       = "";
    }
    else
    {
      rcFDString           = rcString.substr( 0,     uiR1Pos );

      if( uiR1Pos == uiR2Pos )
      {
        rcRplrStringL0     = rcString.substr( uiR1Pos, uiSize - uiR1Pos );
        rcRplrStringL1     = "";
      }
      else
      {
        rcRplrStringL0     = rcString.substr( uiR1Pos, uiR2Pos - uiR1Pos );
        rcRplrStringL1     = rcString.substr( uiR2Pos, uiSize  - uiR2Pos );
      }
    }
  }
  else
  {