sequencestructure.cpp

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

  RNOK( FormattedStringParser::separatString            ( rcString,
                                                          cFDString, cMmcoString, cRplrStringL0, cRplrStringL1) );

  //===== parse basic parameters =====
  RNOKS( FormattedStringParser::extractFrameDescription ( cFDString,
                                                          m_ucType, m_uiFrameNumIncrement, m_bKeyPicture, m_uiLayer ) );
  m_bAnchor         = ( m_uiFrameNumIncrement > uiLastAnchorFrameNumIncrement || uiLastAnchorFrameNumIncrement == MSYS_UINT_MAX );
  m_uiFramesSkipped = ( m_bAnchor ? m_uiFrameNumIncrement - uiLastAnchorFrameNumIncrement - 1 : 0 );

  //===== parse and set MMCO and RPLR commands =====
  if( ! cMmcoString.empty() )
  {
    ROT( NULL == ( m_pcMmcoBuf = new MmcoBuffer ) );
    RNOK( FormattedStringParser::extractMmco( cMmcoString, *m_pcMmcoBuf ) );
  }

  if( ! cRplrStringL0.empty() )
  {
    ROT( NULL == ( m_apcRplrBuf[LIST_0] = new RplrBuffer ) );
    RNOK( FormattedStringParser::extractRplr( cRplrStringL0, *m_apcRplrBuf[LIST_0] ) ); 
  }

  if( ! cRplrStringL1.empty() )
  {
    ROT( NULL == ( m_apcRplrBuf[LIST_1] = new RplrBuffer ) );
    RNOK( FormattedStringParser::extractRplr( cRplrStringL1, *m_apcRplrBuf[LIST_1] ) ); 
  }

  m_bInit = true;

  return Err::m_nOK;
}


ErrVal
SequenceStructure::FrameDescriptor::reduceFramesSkipped( UInt uiNotCoded )
{
  ROFRS( isAnchor(), Err::m_nOK );

  ROT( uiNotCoded > m_uiFramesSkipped );
  m_uiFramesSkipped -= uiNotCoded;
  return Err::m_nOK;
}


ErrVal
SequenceStructure::FrameDescriptor::check() const
{
  ROFS( m_bInit );

 // limited version, since encoder support is limited
  ROTS( m_ucType == 's' || m_ucType == 'S' );

  if( m_pcMmcoBuf )
  {
    for( UInt uiPos = 0; ; uiPos++ )
    {
      Mmco cCommand = m_pcMmcoBuf->get( uiPos );
      if(  cCommand.isEnd() )
      {
        break;
      }
      UInt uiVal1, uiVal2;
      ROTS( cCommand.getCommand( uiVal1, uiVal2 ) != MMCO_SHORT_TERM_UNUSED );
    }
  }
  for( UInt uiList = 0; uiList < 2; uiList++ )
  {
    if( m_apcRplrBuf[uiList] )
    {
      for( UInt uiPos = 0; ; uiPos++ )
      {
        Rplr cCommand = m_apcRplrBuf[uiList]->get( uiPos );
        if(  cCommand.isEnd() )
        {
          break;
        }
        UInt uiVal;
        ROTS( cCommand.getCommand( uiVal ) != RPLR_NEG &&
              cCommand.getCommand( uiVal ) != RPLR_POS    );
      }
    }
  }


  return Err::m_nOK;
}

Bool
SequenceStructure::FrameDescriptor::isIDR() const
{
  AOF_DBG( m_bInit );
  return ( m_ucType == 'A' );
}

Bool
SequenceStructure::FrameDescriptor::isSkipped() const
{
  AOF_DBG( m_bInit );
  return ( m_ucType == 's' ) || ( m_ucType == 'S' );
}

Bool
SequenceStructure::FrameDescriptor::isCoded() const
{
  AOF_DBG( m_bInit );
  return ! isSkipped();
}

Bool
SequenceStructure::FrameDescriptor::isReference() const
{
  AOF_DBG( m_bInit );
  return ( m_ucType == 'A' || m_ucType == 'I' || m_ucType == 'P' || m_ucType == 'B' || m_ucType == 'S' );
}

Bool
SequenceStructure::FrameDescriptor::isAnchor() const
{
  AOF_DBG( m_bInit );
  return m_bAnchor;
}

Bool
SequenceStructure::FrameDescriptor::isKeyPicture() const
{
  AOF_DBG( m_bInit );
  return m_bKeyPicture;
}

UInt
SequenceStructure::FrameDescriptor::getIncrement() const
{
  AOF_DBG( m_bInit );
  return m_uiFrameNumIncrement;
}

UInt
SequenceStructure::FrameDescriptor::getFramesSkipped() const
{
  AOF_DBG( m_bInit );
  return m_uiFramesSkipped;
}


ErrVal
SequenceStructure::FrameDescriptor::setFrameSpec( FrameSpec&  rcFrameSpec,
                                                  UInt        uiFrameNumOffset ) const
{
  AOF_DBG( m_bInit );

  RNOK( rcFrameSpec.init( m_ucType,
                          m_uiFrameNumIncrement + uiFrameNumOffset,
                          m_bAnchor,
                          m_uiFramesSkipped,
                          m_bKeyPicture,
                          m_uiLayer,
                          m_pcMmcoBuf,
                          m_apcRplrBuf[LIST_0],
                          m_apcRplrBuf[LIST_1] ) );

  return Err::m_nOK;
}
//================================= Frame Descriptor : end ===================================





//================================= Frame Sequence Part : begin ===================================
SequenceStructure::FrameSequencePart::FrameSequencePart()
: m_bInit               ( false )
, m_pacFrameDescriptor  ( 0     )
{
}


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


Void
SequenceStructure::FrameSequencePart::uninit()
{
  delete[] m_pacFrameDescriptor;

  m_pacFrameDescriptor  = 0;
  m_bInit               = false;
}


ErrVal
SequenceStructure::FrameSequencePart::init( const String& rcString )
{
  uninit();

  //----- get number of repetitions and number of frames -----
  String cNoRepString;
  RNOKS( FormattedStringParser::extractRepetitions( rcString, cNoRepString, m_uiNumberOfRepetitions ) );
  RNOKS( FormattedStringParser::getNumberOfFrames (           cNoRepString, m_uiNumberOfFrames      ) );
  ROFS ( m_uiNumberOfRepetitions );
  ROFS ( m_uiNumberOfFrames      );

  //----- create array -----
  ROFS( ( m_pacFrameDescriptor = new FrameDescriptor [ m_uiNumberOfFrames ] ) );

  //----- initialize array -----
  UInt uiPos, uiIndex, uiLastAnchorFrameNumIncrement = MSYS_UINT_MAX;
  for( uiPos = 0, uiIndex = 0; uiIndex < m_uiNumberOfFrames; uiIndex++ )
  {
    String cFDString;
    RNOKS( FormattedStringParser::extractNextFrameDescription ( cNoRepString, cFDString, uiPos ) );
    m_pacFrameDescriptor[uiIndex].init                        ( cFDString, uiLastAnchorFrameNumIncrement );

    if( m_pacFrameDescriptor[uiIndex].isSkipped() )
    {
      for( Int iIdx = (Int)(uiIndex-1); iIdx >= 0; iIdx-- )
      {
        if( m_pacFrameDescriptor[iIdx].isAnchor() )
        {
          if( m_pacFrameDescriptor[iIdx].getIncrement() > m_pacFrameDescriptor[uiIndex].getIncrement() )
          {
            m_pacFrameDescriptor[iIdx].reduceFramesSkipped( 1 );
          }
          break;
        }
      }
      if( (Int)m_pacFrameDescriptor[uiIndex].getIncrement() > (Int)uiLastAnchorFrameNumIncrement )
      {
        uiLastAnchorFrameNumIncrement = m_pacFrameDescriptor[uiIndex].getIncrement();
      }
    }
    else if( m_pacFrameDescriptor[uiIndex].isAnchor() )
    {
      uiLastAnchorFrameNumIncrement = m_pacFrameDescriptor[uiIndex].getIncrement();
    }
  }

  //----- reset -----
  m_uiCurrentRepetition = 0;
  m_uiCurrentFrame      = 0;

  //----- get minimum required DPB sizes -----
  UInt*   pauiStored;
  ROFS( ( pauiStored = new UInt [ m_uiNumberOfFrames ] ) );
  ::memset( pauiStored, 0x00, m_uiNumberOfFrames*sizeof(UInt) );
  m_uiMinDPBSizeRef       = 0;
  m_uiMinDPBSizeNonRef    = 0;
  UInt    uiNextOutput    = 0;
  UInt    uiStoredRef     = 0;
  UInt    uiStoredNonRef  = 0;
  for( uiIndex = 0; uiIndex < m_uiNumberOfFrames; uiIndex++ )
  {
    UInt  uiCurrPos = m_pacFrameDescriptor[uiIndex].getIncrement();
    Bool  bRefFrame = m_pacFrameDescriptor[uiIndex].isReference ();

    if( uiCurrPos > uiNextOutput )
    {
      ROT( uiCurrPos >= m_uiNumberOfFrames );
      //===== store current frame =====
      if( bRefFrame )
      {
        pauiStored[uiCurrPos] = 1;
        uiStoredRef++;
      }
      else
      {
        pauiStored[uiCurrPos] = 2;
        uiStoredNonRef++;
      }
    }
    else
    {
      //===== check if stored frames can be outputted =====
      while( (++uiNextOutput) < m_uiNumberOfFrames )
      {
        if( pauiStored[uiNextOutput] )
        {
          if( pauiStored[uiNextOutput] == 1 )
          {
            uiStoredRef--;
          }
          else
          {
            uiStoredNonRef--;
          }
          pauiStored[uiNextOutput] = 0;
        }
        else
        {
          break;
        }
      }
    }
    //----- update minimum required DPB sizes -----
    m_uiMinDPBSizeRef     = max( m_uiMinDPBSizeRef,    uiStoredRef    );
    m_uiMinDPBSizeNonRef  = max( m_uiMinDPBSizeNonRef, uiStoredNonRef );
  }
  delete[] pauiStored;

  //---- set init flag ----
  m_bInit = true;

  return Err::m_nOK;
}


Void
SequenceStructure::FrameSequencePart::reset()
{
  AOF_DBG( m_bInit );

  m_uiCurrentFrame      = 0;
  m_uiCurrentRepetition = 0;
}


ErrVal
SequenceStructure::FrameSequencePart::check()
{
  ROFS( m_bInit );
  ROFS( m_uiNumberOfRepetitions );
  ROFS( m_uiNumberOfFrames );

  Bool*   pabCovered;
  UInt    uiIndex;
  ROFS( ( pabCovered = new Bool [ m_uiNumberOfFrames ] ) );
  for( uiIndex = 0; uiIndex < m_uiNumberOfFrames; uiIndex++ )
  {
    pabCovered[uiIndex] = false;
  }
  for( uiIndex = 0; uiIndex < m_uiNumberOfFrames; uiIndex++ )
  {
    RNOKS( m_pacFrameDescriptor[uiIndex].check() );

    UInt uiInc = m_pacFrameDescriptor[uiIndex].getIncrement();

    ROTS( uiInc >= m_uiNumberOfFrames );
    ROTS( pabCovered[ uiInc ] );

    pabCovered[uiInc] = true;
  }
  delete[] pabCovered;

  return Err::m_nOK;
}


Bool
SequenceStructure::FrameSequencePart::isFirstIDR()  const
{
  AOF_DBG( m_bInit );
  AOF_DBG( m_uiNumberOfFrames );
  return m_pacFrameDescriptor[0].isIDR();
}

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


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


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

  //----- set frame Spec -----
  ANOK( m_pacFrameDescriptor[ m_uiCurrentFrame ].setFrameSpec( rcFrameSpec, uiFrameNumPartOffset ) );

  //----- update parameters -----
  Bool  bPartFinished = false;
  if( ++m_uiCurrentFrame == m_uiNumberOfFrames )
  {
    m_uiCurrentFrame      = 0;
    uiFrameNumPartOffset += m_uiNumberOfFrames;

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

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





//================================= General Sequence Part : begin ===================================
SequenceStructure::GeneralSequencePart::GeneralSequencePart()
: m_bInit               ( false )
, m_papcSequencePart    ( 0     )
{
}

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


Void
SequenceStructure::GeneralSequencePart::uninit()
{
  if( m_papcSequencePart )
  {
    for( UInt uiIndex = 0; uiIndex < m_uiNumberOfParts; uiIndex++ )
    {
      delete m_papcSequencePart[uiIndex];
    }
    delete[] m_papcSequencePart;
  }

  m_papcSequencePart  = 0;
  m_bInit             = false;
}


ErrVal
SequenceStructure::GeneralSequencePart::init( const String& rcString )
{
  uninit();

  //----- get number of repetitions and number of frames -----
  String cNoRepString;
  RNOKS( FormattedStringParser::extractRepetitions ( rcString, cNoRepString, m_uiNumberOfRepetitions ) );
  RNOKS( FormattedStringParser::getNumberOfParts   (           cNoRepString, m_uiNumberOfParts       ) );
  ROFS ( m_uiNumberOfRepetitions );
  ROFS ( m_uiNumberOfParts       );

  //----- create array -----
  ROFS( ( m_papcSequencePart = new SequencePart* [ m_uiNumberOfParts ] ) );

  //----- initialize array -----
  UInt uiPos, uiIndex;
  for( uiPos = 0, uiIndex = 0; uiIndex < m_uiNumberOfParts; uiIndex++ )
  {
    String cPartString;
    RNOKS( FormattedStringParser::extractPart( cNoRepString, cPartString, uiPos ) );

    if( FormattedStringParser::isFrameSequencePart( cPartString ) )
    {
      ROFS( ( m_papcSequencePart[uiIndex] = new FrameSequencePart  () ) );
    }
    else
    {
      ROFS( ( m_papcSequencePart[uiIndex] = new GeneralSequencePart() ) );
    }

    m_papcSequencePart[uiIndex]->init( cPartString );
  }

  //----- reset -----
  m_uiCurrentRepetition = 0;
  m_uiCurrentPart       = 0;

  //----- check required DPB buffer sizes -----
  m_uiMinDPBSizeRef     = 0;
  m_uiMinDPBSizeNonRef  = 0;
  for( uiIndex = 0; uiIndex < m_uiNumberOfParts; uiIndex++ )
  {
    m_uiMinDPBSizeRef    = max( m_uiMinDPBSizeRef,    m_papcSequencePart[uiIndex]->getMinDPBSizeRef   () );
    m_uiMinDPBSizeNonRef = max( m_uiMinDPBSizeNonRef, m_papcSequencePart[uiIndex]->getMinDPBSizeNonRef() );
  }

  //----- set inititalization flag -----
  m_bInit = true;

  return Err::m_nOK;
}


Void
SequenceStructure::GeneralSequencePart::reset()
{
  AOF_DBG( m_bInit );

  for( UInt uiIndex = 0; uiIndex < m_uiNumberOfParts; uiIndex++ )