nalunitencoder.cpp

JVT-Z203_jsvm.rar

            ROT( pcCurrentWriteBuffer->nextBitWriteBufferActive() );
            for(ULong uiBitIdx = 0; uiBitIdx< 16; uiBitIdx++)
            {
              uicrcMsb = ( uicrcVal >> 15 ) & 1;
              BitVal = 0;
              uicrcVal = (((uicrcVal<<1) + BitVal ) & 0xffff)^(uicrcMsb*0x1021);
            }
            pcH264AVCEncoder->m_uicrcVal[uiLayerCGSSNR] = uicrcVal;
            pcH264AVCEncoder->m_pcIntegrityCheckSEI->setNumInfoEntriesMinus1(uiLayerCGSSNR);
            pcH264AVCEncoder->m_pcIntegrityCheckSEI->setEntryDependencyId(uiLayerCGSSNR,uiLayerCGSSNR);
            pcH264AVCEncoder->m_pcIntegrityCheckSEI->setQualityLayerCRC(uiLayerCGSSNR,uicrcVal);
          }
        }

        //JVT-W052 bug_fixed
        if(pcH264AVCEncoder->getCodingParameter()->getNumberOfLayers() == 1)
        {
          pcH264AVCEncoder->m_pcIntegrityCheckSEI->setNumInfoEntriesMinus1(0);
          pcH264AVCEncoder->m_pcIntegrityCheckSEI->setEntryDependencyId(0,0);
          pcH264AVCEncoder->m_pcIntegrityCheckSEI->setQualityLayerCRC(0,0);
        }
        //JVT-W052 bug_fixed
      }
      //JVT-W052
    }

    ExtBinDataAccessor* pcNewExtBinDataAccessor = new ExtBinDataAccessor;
    ROF( pcNewExtBinDataAccessor );

    rcBinData               .reset          ();
    rcBinData               .set            (  pucNewBuffer, uiBytes );
    rcBinData               .setMemAccessor ( *pcNewExtBinDataAccessor );
    rcExtBinDataAccessorList.push_back      (  pcNewExtBinDataAccessor );

    rcBinData               .reset          ();
    rcBinData               .setMemAccessor ( *pcExtBinDataAccessor );

    if( !pcCurrentWriteBuffer->nextBitWriteBufferActive() )
    {
      break;
    }
    pucRBSP              = pcCurrentWriteBuffer->getNextBuffersPacket();
    pcCurrentWriteBuffer = pcCurrentWriteBuffer->getNextBitWriteBuffer();
    uiFragment++;
  }

  RNOK( m_pcBitWriteBuffer->uninit() );

  //==== reset parameters =====
  m_bIsUnitActive     = false;
  m_pucBuffer         = NULL;
  m_pcBinDataAccessor = NULL;
  m_eNalUnitType      = NAL_UNIT_UNSPECIFIED_0;
  m_eNalRefIdc        = NAL_REF_IDC_PRIORITY_LOWEST;
  return Err::m_nOK;
}



ErrVal
NalUnitEncoder::closeNalUnit( UInt& ruiBits )
{
  ROF( m_bIsUnitActive );

  //===== write trailing bits =====
  if( NAL_UNIT_END_OF_SEQUENCE != m_eNalUnitType &&
      NAL_UNIT_END_OF_STREAM   != m_eNalUnitType &&
     (NAL_UNIT_PREFIX          != m_eNalUnitType || m_eNalRefIdc != NAL_REF_IDC_PRIORITY_LOWEST) )
  {
    RNOK ( xWriteTrailingBits() );
  }
  RNOK( m_pcBitWriteBuffer->flushBuffer() );

  //===== convert to payload and add header =====
  UInt  uiHeaderBytes = 1;
  if( m_eNalUnitType == NAL_UNIT_CODED_SLICE_SCALABLE || m_eNalUnitType == NAL_UNIT_PREFIX )
  {
    uiHeaderBytes += NAL_UNIT_HEADER_SVC_EXTENSION_BYTES;
  }

  UInt  uiBits = ( m_pcBitWriteBuffer->getNumberOfWrittenBits() + 7 ) >> 3;

  RNOK( convertRBSPToPayload( uiBits, uiHeaderBytes, m_pucBuffer, m_pucTempBuffer, m_uiPacketLength ) );
  RNOK( m_pcBinDataAccessor->decreaseEndPos( m_pcBinDataAccessor->size() - uiBits ) );
  ruiBits             = 8*uiBits;

  //==== reset parameters =====
  m_bIsUnitActive     = false;
  m_pucBuffer         = NULL;
  m_pcBinDataAccessor = NULL;
  m_eNalUnitType      = NAL_UNIT_UNSPECIFIED_0;
  m_eNalRefIdc        = NAL_REF_IDC_PRIORITY_LOWEST;
  return Err::m_nOK;
}

ErrVal
NalUnitEncoder::convertRBSPToPayload( UInt         &ruiBytesWritten,
                                       UInt          uiHeaderBytes,
                                       UChar        *pcPayload,
                                       const UChar  *pcRBSP,
                                       UInt          uiPayloadBufferSize )
{
  UInt uiZeroCount    = 0;
  UInt uiReadOffset   = uiHeaderBytes;
  UInt uiWriteOffset  = uiHeaderBytes;

  //===== NAL unit header =====
  for( UInt uiIndex = 0; uiIndex < uiHeaderBytes; uiIndex++ )
  {
    pcPayload[uiIndex] = pcRBSP[uiIndex];
  }

  //===== NAL unit payload =====
  for( ; uiReadOffset < ruiBytesWritten ; uiReadOffset++, uiWriteOffset++ )
  {
    ROT( uiWriteOffset >= uiPayloadBufferSize );

    if( 2 == uiZeroCount && 0 == ( pcRBSP[uiReadOffset] & 0xfc ) )
    {
      uiZeroCount                   = 0;
      pcPayload[uiWriteOffset++]  = 0x03;
    }

    pcPayload[uiWriteOffset] = pcRBSP[uiReadOffset];

    if( 0 == pcRBSP[uiReadOffset] )
    {
      uiZeroCount++;
    }
    else
    {
      uiZeroCount = 0;
    }
  }
  if( ( 0x00 == pcPayload[uiWriteOffset-1] ) && ( 0x00 == pcPayload[uiWriteOffset-2] ) )
  {
    ROT( uiWriteOffset >= uiPayloadBufferSize );
    pcPayload[uiWriteOffset++] = 0x03;
  }
  ruiBytesWritten = uiWriteOffset;

  return Err::m_nOK;
}

ErrVal NalUnitEncoder::xWriteTrailingBits( )
{
  RNOK( m_pcBitWriteBuffer->write( 1 ) );
  RNOK( m_pcBitWriteBuffer->writeAlignZero() );

  BitWriteBufferIf* pcCurrentBitWriter = m_pcBitWriteBuffer;
  while( pcCurrentBitWriter->nextBitWriteBufferActive() )
  {
    pcCurrentBitWriter = pcCurrentBitWriter->getNextBitWriteBuffer();
    RNOK( pcCurrentBitWriter->write( 1 ) );
    RNOK( pcCurrentBitWriter->writeAlignZero() );
  }
  return Err::m_nOK;
}


ErrVal
NalUnitEncoder::write( const SequenceParameterSet& rcSPS )
{
  RNOK( rcSPS.write( m_pcHeaderSymbolWriteIf ) );
  m_eNalUnitType  = rcSPS.getNalUnitType();
  m_eNalRefIdc    = NAL_REF_IDC_PRIORITY_HIGHEST;
  return Err::m_nOK;
}


ErrVal
NalUnitEncoder::write( const PictureParameterSet& rcPPS )
{
  RNOK( rcPPS.write( m_pcHeaderSymbolWriteIf ) );

  m_eNalUnitType  = rcPPS.getNalUnitType();
  m_eNalRefIdc    = NAL_REF_IDC_PRIORITY_HIGHEST;
  return Err::m_nOK;
}


ErrVal
NalUnitEncoder::writePrefix( const SliceHeader& rcSH )
{
  RNOK( rcSH.writePrefix( *m_pcHeaderSymbolWriteIf ) );
  m_eNalUnitType  = NAL_UNIT_PREFIX;
  m_eNalRefIdc    = rcSH.getNalRefIdc();
  return Err::m_nOK;
}


ErrVal
NalUnitEncoder::write( const SliceHeader& rcSH )
{
  SliceHeader           cSH           = rcSH;
  HeaderSymbolWriteIf*  pcCurrWriteIf = m_pcHeaderSymbolWriteIf;
  UInt                  uiSourceLayer = g_nLayer;

  for( UInt uiMGSFragment = 0; true; uiMGSFragment++ )
  {
    ETRACE_DECLARE( Bool m_bTraceEnable = true );

    //----- modify copy of slice header -----
    cSH.setDependencyId                   ( rcSH.getLayerCGSSNR         () );
    cSH.setQualityId                      ( rcSH.getQualityLevelCGSSNR  () + uiMGSFragment );
    cSH.setDiscardableFlag                ( rcSH.getDiscardableFlag     () );
    cSH.setNoInterLayerPredFlag           ( rcSH.getNoInterLayerPredFlag() && cSH.getQualityId() == 0 );
    cSH.setScanIdxStart                   ( rcSH.getSPS().getMGSCoeffStart( uiMGSFragment ) );
    cSH.setScanIdxStop                    ( rcSH.getSPS().getMGSCoeffStop ( uiMGSFragment ) );
    cSH.setRefLayerDQId                   ( uiMGSFragment == 0 ? rcSH.getRefLayerDQId                   () : ( rcSH.getLayerCGSSNR() << 4 ) + rcSH.getQualityLevelCGSSNR() + uiMGSFragment - 1 );
    cSH.setAdaptiveBaseModeFlag           ( uiMGSFragment == 0 ? rcSH.getAdaptiveBaseModeFlag           () : false  );
    cSH.setAdaptiveMotionPredictionFlag   ( uiMGSFragment == 0 ? rcSH.getAdaptiveMotionPredictionFlag   () : false  );
    cSH.setAdaptiveResidualPredictionFlag ( uiMGSFragment == 0 ? rcSH.getAdaptiveResidualPredictionFlag () : false  );
    cSH.setDefaultBaseModeFlag            ( uiMGSFragment == 0 ? rcSH.getDefaultBaseModeFlag            () : true   );
    cSH.setDefaultMotionPredictionFlag    ( uiMGSFragment == 0 ? rcSH.getDefaultMotionPredictionFlag    () : true   );
    cSH.setDefaultResidualPredictionFlag  ( uiMGSFragment == 0 ? rcSH.getDefaultResidualPredictionFlag  () : true   );

    //----- write copy of slice header -----
    RNOK( cSH.write( *pcCurrWriteIf ) );
    if( rcSH.getSPS().getMGSCoeffStop( uiMGSFragment ) == 16 )
    {
      break;
    }

    //----- update -----
    g_nLayer++;
    ETRACE_LAYER( g_nLayer );
    pcCurrWriteIf = pcCurrWriteIf->getHeaderSymbolWriteIfNextSlice( true );
  }

  ETRACE_DECLARE( Bool m_bTraceEnable = true );
  g_nLayer = uiSourceLayer;
  ETRACE_LAYER( g_nLayer );

  m_eNalUnitType  = rcSH.getNalUnitType ();
  m_eNalRefIdc    = rcSH.getNalRefIdc   ();
  return Err::m_nOK;
}


ErrVal
NalUnitEncoder::write( SEI::MessageList& rcSEIMessageList )
{
  RNOK( SEI::write( m_pcHeaderSymbolWriteIf, m_pcHeaderSymbolTestIf, &rcSEIMessageList ) );

  m_eNalUnitType  = NAL_UNIT_SEI;
  m_eNalRefIdc    = NAL_REF_IDC_PRIORITY_LOWEST;
  return Err::m_nOK;
}

// JVT-T073 {
ErrVal
NalUnitEncoder::writeNesting( SEI::MessageList& rcSEIMessageList )
{
  RNOK( SEI::writeNesting( m_pcHeaderSymbolWriteIf, m_pcHeaderSymbolTestIf, &rcSEIMessageList ) );
  m_eNalUnitType  = NAL_UNIT_SEI;
  m_eNalRefIdc    = NAL_REF_IDC_PRIORITY_LOWEST;
  return Err::m_nOK;
}
// JVT-T073 }

// JVT-V068 {
ErrVal
NalUnitEncoder::writeScalableNestingSei( SEI::MessageList& rcSEIMessageList )
{
  RNOK( SEI::writeScalableNestingSei( m_pcHeaderSymbolWriteIf, m_pcHeaderSymbolTestIf, &rcSEIMessageList ) );
  m_eNalUnitType  = NAL_UNIT_SEI;
  m_eNalRefIdc    = NAL_REF_IDC_PRIORITY_LOWEST;
  return Err::m_nOK;
}
// JVT-V068 }

H264AVC_NAMESPACE_END