sequencestructure.cpp

JVT-Z203_jsvm.rar

{
  AOF_DBG( m_bInit );
  return m_bAnchor;
}

Bool
SequenceStructure::FrameDescriptor::isBaseRep() const
{
  AOF_DBG( m_bInit );
  return m_bUseBaseRep;
}

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_bUseBaseRep,
                          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++ )
  {
    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 ===================================