createrh264avcdecoder.cpp

JVT-Z203_jsvm.rar

  m_pcLastPrefixHeader  = 0;
  m_pcLastSliceHeader   = &rcSliceHeader;
  return Err::m_nOK;
}


ErrVal
AccessUnit::update( BinData* pcBinData )
{
  ROT( m_bComplete );
  ROT( m_bEndOfStream );

  Bool bEOS = ( pcBinData == 0 );

  if( pcBinData )
  {
    BinData* pcBinDataPrefix = 0;
    if( m_pcLastPrefixHeader && NalUnitType( pcBinData->data()[ 0 ] & 0x1F ) == NAL_UNIT_FILLER_DATA )
    {
      NALUnit*        pcLastNALUnit   = m_cNalUnitList.popBack();
      NonVCLNALUnit*  pcPrefixNALUnit = (NonVCLNALUnit*)pcLastNALUnit->getInstance();
      pcBinDataPrefix                 = pcPrefixNALUnit->getBinData();
      pcPrefixNALUnit->destroyNALOnly();
    }
    NonVCLNALUnit* pcNonVCLNALUnit = new NonVCLNALUnit( pcBinData, pcBinDataPrefix );
    ROF( pcNonVCLNALUnit );
    m_cNalUnitList.push_back( pcNonVCLNALUnit );
    bEOS = ( pcNonVCLNALUnit->getNalUnitType() == NAL_UNIT_END_OF_STREAM );
  }
  if( bEOS )
  {
    xSetComplete();
  }
  return Err::m_nOK;
}


ErrVal
AccessUnit::getAndRemoveNextNalUnit( NALUnit*& rpcNalUnit )
{
  ROF( m_bComplete );
  rpcNalUnit = m_cNalUnitList.popFront();
  if( rpcNalUnit->isVCLNALUnit() && rpcNalUnit->getInstance() == (Void*)m_pcLastVCLNALUnit )
  {
    m_pcLastVCLNALUnit = 0;
  }
  if( m_cNalUnitList.empty() )
  {
    xReInit();
  }
  return Err::m_nOK;
}


#define ISVCL(i)  ((*i)->isVCLNALUnit())
#define SLICE(i)  ((SliceDataNALUnit*)((*i)->getInstance()))

Void
AccessUnit::xSetComplete( SliceDataNALUnit* pcFirstSliceDataNALUnitOfNextAccessUnit,
                          SliceHeader*      pcFirstSliceHeaderOfNextAccessUnit )
{
  delete m_pcLastPrefixHeader;
  delete m_pcLastSliceHeader;
  m_bEndOfStream        = ( pcFirstSliceDataNALUnitOfNextAccessUnit == 0 );
  m_bComplete           = true;
  m_pcLastVCLNALUnit    = 0;
  m_pcLastPrefixHeader  = 0;
  m_pcLastSliceHeader   = pcFirstSliceHeaderOfNextAccessUnit;

  //===== remove redundant NAL units =====
  xRemoveRedundant();

  //===== find last slice data NAL unit =====
  {
    MyList<NALUnit*>::reverse_iterator iIter = m_cNalUnitList.rbegin();
    MyList<NALUnit*>::reverse_iterator iEnd  = m_cNalUnitList.rend  ();
    while( iIter != iEnd )
    {
      if( ISVCL(iIter) )
      {
        m_pcLastVCLNALUnit = SLICE(iIter);
        break;
      }
      iIter++;
    }
    AOF( m_pcLastVCLNALUnit );
  }

  //===== set NAL units of next access unit =====
  if( ! m_bEndOfStream )
  {
    MyList<NALUnit*>::iterator iIter = m_cNalUnitList.begin();
    MyList<NALUnit*>::iterator iEnd  = m_cNalUnitList.end  ();
    //--- goto the NAL unit after the last VCL NAL unit ---
    while( iIter != iEnd )
    {
      if( ISVCL(iIter) && SLICE(iIter) == m_pcLastVCLNALUnit )
      {
        iIter++;
        break;
      }
      iIter++;
    }
    //--- find first NAL of next access unit ---
    while( iIter != iEnd )
    {
      NalUnitType eNalUnitType = (*iIter)->getNalUnitType();
      if( ( eNalUnitType >= 6 && eNalUnitType <= 9 ) || ( eNalUnitType >= 14 && eNalUnitType <= 18 ) )
      {
        break;
      }
      iIter++;
    }
    //--- set NAL units of next access unit ---
    UInt  uiNumNALUnitsToRemove = 0;
    while( iIter != iEnd )
    {
      m_cStartOfNewAccessUnit.push_back( *iIter );
      uiNumNALUnitsToRemove++;
      iIter++;
    }
    m_cStartOfNewAccessUnit.push_back( pcFirstSliceDataNALUnitOfNextAccessUnit );
    //--- remove the NAL units from the current access unit ---
    while( uiNumNALUnitsToRemove )
    {
      m_cNalUnitList.pop_back();
      uiNumNALUnitsToRemove--;
    }
  }

  //===== analyse NAL units and set parameters of slice data NAL units =====
  xSetParameters();
}


MyList<NALUnit*>::iterator
getNextVCL( MyList<NALUnit*>::iterator iIter, MyList<NALUnit*>::iterator iEnd, Bool bFirst = false )
{
  if( iIter != iEnd )
  {
    if( ! bFirst )
    {
      iIter++;
    }
    while( iIter != iEnd )
    {
      if( (*iIter)->isVCLNALUnit() )
      {
        break;
      }
      iIter++;
    }
  }
  return iIter;
}


Void
AccessUnit::xRemoveRedundant()
{
  //===== remove redundant slices (could be used for error concealment in later version) =====
  {
    MyList<NALUnit*>::iterator iIter = m_cNalUnitList.begin();
    MyList<NALUnit*>::iterator iEnd  = m_cNalUnitList.end  ();
    while( iIter != iEnd )
    {
      if( ISVCL(iIter) && SLICE(iIter)->getRedundantPicCnt() )
      {
        delete *iIter;
        iIter = m_cNalUnitList.erase( iIter );
      }
      else
      {
        iIter++;
      }
    }
  }
}

Void
AccessUnit::xSetParameters()
{
  //===== remove non-required NAL units =====
  {
    MyList<NALUnit*>::reverse_iterator iIter = m_cNalUnitList.rbegin();
    MyList<NALUnit*>::reverse_iterator iEnd  = m_cNalUnitList.rend  ();
    while( iIter != iEnd )
    {
      if( ISVCL(iIter) )
      {
        break;
      }
      iIter++;
    }
    AOT( iIter == iEnd );
    UInt  uiCurrDQId = MSYS_UINT_MAX;
    UInt  uiNextDQId = SLICE(iIter)->getDQId();
    while( iIter != iEnd )
    {
      if( ! ISVCL(iIter) || SLICE(iIter)->getDQId() == uiCurrDQId )
      {
        iIter++;
      }
      else if( uiNextDQId == MSYS_UINT_MAX || SLICE(iIter)->getDQId() > uiNextDQId )
      {
        // remove non-required layer representation
        MyList<NALUnit*>::reverse_iterator iNext     = iIter; iNext++;
        MyList<NALUnit*>::iterator         iToDelete = iNext.base();
        delete *iToDelete;
        iToDelete = m_cNalUnitList.erase( iToDelete );
        iIter     = static_cast<MyList<NALUnit*>::reverse_iterator>( iToDelete );
        iEnd      = m_cNalUnitList.rend();
      }
      else if( ( SLICE(iIter)->getDQId() >> 4 ) == ( uiNextDQId >> 4 ) )
      {
        if( SLICE(iIter)->getDQId() != uiNextDQId )
        {
          printf( "WARNING: missing layer representation (Q=%d), chosing Q=%d\n", uiNextDQId & 15, SLICE(iIter)->getDQId() & 15 );
        }
        uiCurrDQId  = SLICE(iIter)->getDQId();
        uiNextDQId  = SLICE(iIter)->getRefLayerDQId();
        iIter++;
      }
      else
      {
        printf( "ERROR: referenced dependency representation missing (D=%d)\n", uiNextDQId >> 4 );
        AOT( 1 ); // replace with error concealment code in later versions
      }
    }
    AOF( uiNextDQId == MSYS_UINT_MAX ); // we are missing required packets (replace with error concealment in later version)
  }

  //===== set highest DQId for which AVC rewriting is possible =====
  UInt  uiHighestRewriteDQId = MSYS_UINT_MAX;
  {
    MyList<NALUnit*>::iterator iIter = m_cNalUnitList.begin();
    MyList<NALUnit*>::iterator iEnd  = m_cNalUnitList.end  ();
    while( iIter != iEnd )
    {
      if( ISVCL(iIter) )
      {
        if( SLICE(iIter)->getNalUnitType() == NAL_UNIT_CODED_SLICE      ||
            SLICE(iIter)->getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR  ||
            SLICE(iIter)->getTCoeffLevelPredictionFlag() )
        {
          uiHighestRewriteDQId = SLICE(iIter)->getDQId();
        }
      }
      iIter++;
    }
  }

  //===== set slice data properties =====
  MyList<NALUnit*>::iterator iEnd  = m_cNalUnitList.end();
  MyList<NALUnit*>::iterator iIter = getNextVCL( m_cNalUnitList.begin(), iEnd, true );
  MyList<NALUnit*>::iterator iNext = getNextVCL( iIter, iEnd );
  while( iIter != iEnd )
  {
    //----- check whether slice is the last slice in a layer or dependency representation ----
    Bool  bLastSliceInLayerRepresentation       = false;
    Bool  bLastSliceInDependencyRepresentation  = false;
    if( iNext == iEnd )
    {
      bLastSliceInLayerRepresentation       = true;
      bLastSliceInDependencyRepresentation  = true;
    }
    else
    {
      bLastSliceInLayerRepresentation       = ( SLICE(iIter)->getDQId         () != SLICE(iNext)->getDQId         () );
      bLastSliceInDependencyRepresentation  = ( SLICE(iIter)->getDependencyId () != SLICE(iNext)->getDependencyId () );
    }
    //----- check whether slices is part of an IDR access unit -----
    Bool  bIsPartOfIDRAccessUnit  = false;
    for( MyList<NALUnit*>::iterator iNIter = iIter; iNIter != iEnd && ! bIsPartOfIDRAccessUnit; iNIter = getNextVCL( iNIter, iEnd ) )
    {
      bIsPartOfIDRAccessUnit = SLICE(iNIter)->getIdrFlag();
    }
    //----- set parameters -----
    SLICE(iIter)->setDQIdMax                            ( SLICE(iIter)->getDQId         () == m_pcLastVCLNALUnit->getDQId        () );
    SLICE(iIter)->setDependencyIdMax                    ( SLICE(iIter)->getDependencyId () == m_pcLastVCLNALUnit->getDependencyId() );
    SLICE(iIter)->setLastSliceInLayerRepresentation     ( bLastSliceInLayerRepresentation );
    SLICE(iIter)->setLastSliceInDependencyRepresentation( bLastSliceInDependencyRepresentation );
    SLICE(iIter)->setLastSliceInAccessUnit              ( iNext == iEnd );
    SLICE(iIter)->setLastAccessUnitInStream             ( m_bEndOfStream );
    SLICE(iIter)->setPartOfIDRAccessUnit                ( bIsPartOfIDRAccessUnit );
    SLICE(iIter)->setHighestRewriteLayer                ( SLICE(iIter)->getDQId         () == uiHighestRewriteDQId );
    //----- update iterators ----
    iIter = iNext;
    iNext = getNextVCL( iIter, iEnd );
  }
}


Void
AccessUnit::xReInit()
{
  m_cNalUnitList = m_cStartOfNewAccessUnit;
  m_bComplete    = false;
  m_cStartOfNewAccessUnit.clear();
}

#undef ISVCL
#undef SLICE





CreaterH264AVCDecoder::CreaterH264AVCDecoder()
: m_pcH264AVCDecoder        ( 0 )
, m_pcParameterSetMngAUInit ( 0 )
, m_pcParameterSetMngDecode ( 0 )
, m_pcSliceReader           ( 0 )
, m_pcNalUnitParser         ( 0 )
, m_pcSliceDecoder          ( 0 )
, m_pcControlMng            ( 0 )
, m_pcBitReadBuffer         ( 0 )
, m_pcUvlcReader            ( 0 )
, m_pcMbParser              ( 0 )
, m_pcLoopFilter            ( 0 )
, m_pcMbDecoder             ( 0 )
, m_pcTransform             ( 0 )
, m_pcIntraPrediction       ( 0 )
, m_pcMotionCompensation    ( 0 )
, m_pcQuarterPelFilter      ( 0 )