/*! * \copy *     Copyright (c)  2009-2013, Cisco Systems *     All rights reserved. * *     Redistribution and use in source and binary forms, with or without *     modification, are permitted provided that the following conditions *     are met: * *        * Redistributions of source code must retain the above copyright *          notice, this list of conditions and the following disclaimer. * *        * Redistributions in binary form must reproduce the above copyright *          notice, this list of conditions and the following disclaimer in *          the documentation and/or other materials provided with the *          distribution. * *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS *     "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT *     LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS *     FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE *     COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, *     INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, *     BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER *     CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT *     LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN *     ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE *     POSSIBILITY OF SUCH DAMAGE. * * * \file	au_parser.c * * \brief	Interfaces introduced in Access Unit level based parser * * \date	03/10/2009 Created * ************************************************************************************* */#include <string.h>#include "codec_def.h"#include "ls_defines.h"#include "macros.h"#include "au_parser.h"#include "decoder.h"#include "error_code.h"#include "dec_frame.h"#include "dec_golomb.h"#include "bit_stream.h"#include "utils.h"#include "codec_app_def.h"#include "memmgr_nal_unit.h"#include "decoder_core.h"#include "wels_common_basis.h"#include "decoder_core.h"#include "manage_dec_ref.h"#include "mem_align.h" namespace WelsDec {/*! ************************************************************************************* * \brief	Start Code Prefix (0x 00 00 00 01) detection * * \param 	pBuf		bitstream payload buffer * \param	pOffset		offset between NAL rbsp and original bitsteam that * 				start code prefix is seperated from. * \param	iBufSize	count size of buffer * * \return	RBSP buffer of start code prefix exclusive * * \note	N/A ************************************************************************************* */uint8_t* DetectStartCodePrefix (const uint8_t* kpBuf, int32_t* pOffset, int32_t iBufSize) {  uint8_t* pBits = (uint8_t*)kpBuf;   do {    int32_t iIdx = 0;    while ((iIdx < iBufSize) && (! (*pBits))) {      ++ pBits;      ++ iIdx;    }    if (iIdx >= iBufSize)  break;     ++ iIdx;    ++ pBits;     if ((iIdx >= 3) && ((* (pBits - 1)) == 0x1)) {      *pOffset = ((uintptr_t)pBits) - ((uintptr_t)kpBuf);      return pBits;    }     iBufSize -= iIdx;  }  while (1);   return NULL;} /*! ************************************************************************************* * \brief	to parse nal unit * * \param	pCtx		    decoder context * \param 	pNalUnitHeader	parsed result of NAL Unit Header to output * \param   pSrcRbsp        bitstream buffer to input * \param   iSrcRbspLen     length size of bitstream buffer payload * \param	pSrcNal * \param	iSrcNalLen * \param	pConsumedBytes	consumed bytes during parsing * * \return	decoded bytes payload, might be (pSrcRbsp+1) if no escapes * * \note	N/A ************************************************************************************* */uint8_t* ParseNalHeader (PWelsDecoderContext pCtx, SNalUnitHeader* pNalUnitHeader, uint8_t* pSrcRbsp,                         int32_t iSrcRbspLen, uint8_t* pSrcNal, int32_t iSrcNalLen, int32_t* pConsumedBytes) {  PNalUnit pCurNal = NULL;  uint8_t* pNal     = pSrcRbsp;  int32_t iNalSize  = iSrcRbspLen;  PBitStringAux pBs = NULL;  bool_t bExtensionFlag = false;  int32_t iErr	= ERR_NONE;  int32_t iBitSize = 0;   pNalUnitHeader->eNalUnitType = NAL_UNIT_UNSPEC_0;//SHOULD init it. because pCtx->sCurNalHead is common variable.   //remove the consecutive ZERO at the end of current NAL in the reverse order.--2011.6.1  {    int32_t iIndex = iSrcRbspLen - 1;    uint8_t uiBsZero = 0;    while (iIndex >= 0) {      uiBsZero = pSrcRbsp[iIndex];      if (0 == uiBsZero) {        --iNalSize;        --iIndex;      } else {        break;      }    }  }   pNalUnitHeader->uiForbiddenZeroBit	= (uint8_t) (pNal[0] >> 7);			// uiForbiddenZeroBit  if (pNalUnitHeader->uiForbiddenZeroBit) { //2010.4.14    return NULL; //uiForbiddenZeroBit should always equal to 0  }   pNalUnitHeader->uiNalRefIdc		= (uint8_t) (pNal[0] >> 5);			// uiNalRefIdc  pNalUnitHeader->eNalUnitType		= (ENalUnitType) (pNal[0] & 0x1f);	// eNalUnitType   ++pNal;  --iNalSize;  ++ (*pConsumedBytes); #ifdef DEBUG_PARSE_INFO  WelsLog (pCtx, WELS_LOG_INFO, "nal type: %d \n", pNalUnitHeader->eNalUnitType);#endif   if (! (IS_SEI_NAL (pNalUnitHeader->eNalUnitType) || IS_SPS_NAL (pNalUnitHeader->eNalUnitType)         || pCtx->bSpsExistAheadFlag)) {    WelsLog (pCtx, WELS_LOG_WARNING,             "parse_nal(), no exist Sequence Parameter Sets ahead of sequence when try to decode NAL(type:%d).\n",             pNalUnitHeader->eNalUnitType);    pCtx->iErrorCode	= dsNoParamSets;    return NULL;  }  if (! (IS_SEI_NAL (pNalUnitHeader->eNalUnitType) || IS_PARAM_SETS_NALS (pNalUnitHeader->eNalUnitType)         || pCtx->bPpsExistAheadFlag)) {    WelsLog (pCtx, WELS_LOG_WARNING,             "parse_nal(), no exist Picture Parameter Sets ahead of sequence when try to decode NAL(type:%d).\n",             pNalUnitHeader->eNalUnitType);    pCtx->iErrorCode	= dsNoParamSets;    return NULL;  }  if ((IS_VCL_NAL_AVC_BASE (pNalUnitHeader->eNalUnitType) && ! (pCtx->bSpsExistAheadFlag || pCtx->bPpsExistAheadFlag)) ||      (IS_NEW_INTRODUCED_NAL (pNalUnitHeader->eNalUnitType) && ! (pCtx->bSpsExistAheadFlag || pCtx->bSubspsExistAheadFlag          || pCtx->bPpsExistAheadFlag))) {    WelsLog (pCtx, WELS_LOG_WARNING,             "ParseNalHeader(), no exist Parameter Sets ahead of sequence when try to decode slice(type:%d).\n",             pNalUnitHeader->eNalUnitType);    pCtx->iErrorCode	|= dsNoParamSets;    return NULL;  }    switch (pNalUnitHeader->eNalUnitType) {  case NAL_UNIT_SEI:     if (pCtx->pAccessUnitList->uiAvailUnitsNum > 0) {      pCtx->pAccessUnitList->uiEndPos = pCtx->pAccessUnitList->uiAvailUnitsNum - 1;      pCtx->bAuReadyFlag = true;    }     break;   case NAL_UNIT_SPS:     if (pCtx->pAccessUnitList->uiAvailUnitsNum > 0) {      pCtx->pAccessUnitList->uiEndPos = pCtx->pAccessUnitList->uiAvailUnitsNum - 1;      pCtx->bAuReadyFlag = true;    }     break;   case NAL_UNIT_PREFIX:    pCurNal = &pCtx->sPrefixNal;     if (iNalSize < NAL_UNIT_HEADER_EXT_SIZE) {      return NULL;    }     DecodeNalHeaderExt (pCurNal, pNal);     pNal            += NAL_UNIT_HEADER_EXT_SIZE;    iNalSize        -= NAL_UNIT_HEADER_EXT_SIZE;    *pConsumedBytes += NAL_UNIT_HEADER_EXT_SIZE;     pCurNal->sNalHeaderExt.sNalUnitHeader.uiForbiddenZeroBit = pNalUnitHeader->uiForbiddenZeroBit;    pCurNal->sNalHeaderExt.sNalUnitHeader.uiNalRefIdc		  = pNalUnitHeader->uiNalRefIdc;    pCurNal->sNalHeaderExt.sNalUnitHeader.eNalUnitType	      = pNalUnitHeader->eNalUnitType;     pBs = &pCtx->sBs;     iBitSize = (iNalSize << 3) - BsGetTrailingBits (pNal + iNalSize - 1); // convert into bit     InitBits (pBs, pNal, iBitSize);     ParsePrefixNalUnit (pCtx, pBs);     break;  case NAL_UNIT_CODED_SLICE_EXT:    bExtensionFlag = true;  case NAL_UNIT_CODED_SLICE:  case NAL_UNIT_CODED_SLICE_IDR: {    PAccessUnit pCurAu		= NULL;    uint32_t uiAvailNalNum;    pCurNal = MemGetNextNal (&pCtx->pAccessUnitList);    if (NULL == pCurNal) {      WelsLog (pCtx, WELS_LOG_WARNING, "MemGetNextNal() fail due out of memory.\n");      pCtx->iErrorCode	|= dsOutOfMemory;      return NULL;    }     pCurNal->sNalHeaderExt.sNalUnitHeader.uiForbiddenZeroBit = pNalUnitHeader->uiForbiddenZeroBit;    pCurNal->sNalHeaderExt.sNalUnitHeader.uiNalRefIdc		  = pNalUnitHeader->uiNalRefIdc;    pCurNal->sNalHeaderExt.sNalUnitHeader.eNalUnitType	  = pNalUnitHeader->eNalUnitType;    pCurAu	      = pCtx->pAccessUnitList;    uiAvailNalNum = pCurAu->uiAvailUnitsNum;      if (pNalUnitHeader->eNalUnitType == NAL_UNIT_CODED_SLICE_EXT) {      if (iNalSize < NAL_UNIT_HEADER_EXT_SIZE) {        return NULL;      }       DecodeNalHeaderExt (pCurNal, pNal);      if (pCurNal->sNalHeaderExt.uiQualityId != 0 ||          pCurNal->sNalHeaderExt.bUseRefBasePicFlag) {        if (pCurNal->sNalHeaderExt.uiQualityId != 0)          WelsLog (pCtx, WELS_LOG_WARNING, "ParseNalHeader():uiQualityId (%d) != 0, MGS not supported!\n",                   pCurNal->sNalHeaderExt.uiQualityId);        if (pCurNal->sNalHeaderExt.bUseRefBasePicFlag != 0)          WelsLog (pCtx, WELS_LOG_WARNING, "ParseNalHeader():bUseRefBasePicFlag (%d) != 0, MGS not supported!\n",                   pCurNal->sNalHeaderExt.bUseRefBasePicFlag);         pCtx->iErrorCode |= dsInvalidArgument;        ForceClearCurrentNal (pCurAu);         if (uiAvailNalNum > 1) {          pCurAu->uiEndPos = uiAvailNalNum - 2;          pCtx->bAuReadyFlag = true;        }        return NULL;      }      pNal            += NAL_UNIT_HEADER_EXT_SIZE;      iNalSize        -= NAL_UNIT_HEADER_EXT_SIZE;      *pConsumedBytes += NAL_UNIT_HEADER_EXT_SIZE;     } else {        if (NAL_UNIT_PREFIX == pCtx->sPrefixNal.sNalHeaderExt.sNalUnitHeader.eNalUnitType) {        PrefetchNalHeaderExtSyntax (pCtx, pCurNal, &pCtx->sPrefixNal);      }       pCurNal->sNalHeaderExt.bIdrFlag = (NAL_UNIT_CODED_SLICE_IDR == pNalUnitHeader->eNalUnitType) ? true :                                        false;   //SHOULD update this flag for AVC if no prefix NAL      pCurNal->sNalHeaderExt.iNoInterLayerPredFlag = 1;    }     pBs = &pCurAu->pNalUnitsList[uiAvailNalNum - 1]->sNalData.sVclNal.sSliceBitsRead;    iBitSize = (iNalSize << 3) - BsGetTrailingBits (pNal + iNalSize - 1); // convert into bit    InitBits (pBs, pNal, iBitSize);    iErr = ParseSliceHeaderSyntaxs (pCtx, pBs, bExtensionFlag);    if (iErr != ERR_NONE) {      //if current NAL occur error when parsing, should clean it from pNalUnitsList      //otherwise, when Next good NAL decoding, this corrupt NAL is considered as normal NAL and lead to decoder crash      ForceClearCurrentNal (pCurAu);       if (uiAvailNalNum > 1) {        pCurAu->uiEndPos = uiAvailNalNum - 2;        pCtx->bAuReadyFlag = true;        }#ifdef MOSAIC_AVOID_BASED_ON_SPS_PPS_ID      if (dsNoParamSets & pCtx->iErrorCode) {        if (uiAvailNalNum <= 1) { //no any data to decode and SPS/PPS ID mismatch, SHOULD request IDR#ifdef LONG_TERM_REF          pCtx->bParamSetsLostFlag = true;#else          pCtx->bReferenceLostAtT0Flag = true;#endif          ResetParameterSetsState (pCtx);        }        return NULL;      } else {        return NULL;      }#else      return NULL;#endif //MOSAIC_AVOID_BASED_ON_SPS_PPS_ID    }     if ((uiAvailNalNum > 1) &&        CheckAccessUnitBoundary (pCurAu->pNalUnitsList[uiAvailNalNum - 1], pCurAu->pNalUnitsList[uiAvailNalNum - 2],                                 pCurAu->pNalUnitsList[uiAvailNalNum - 1]->sNalData.sVclNal.sSliceHeaderExt.sSliceHeader.pSps)) {      pCurAu->uiEndPos = uiAvailNalNum - 2;      pCtx->bAuReadyFlag = true;      }  }  break;  default:    break;  }   return pNal;}  bool_t CheckAccessUnitBoundaryExt (PNalUnitHeaderExt pLastNalHdrExt, PNalUnitHeaderExt pCurNalHeaderExt,                                   PSliceHeader pLastSliceHeader, PSliceHeader pCurSliceHeader) {  const PSps kpSps = pCurSliceHeader->pSps;   //Sub-clause 7.1.4.1.1 temporal_id  if (pLastNalHdrExt->uiTemporalId != pCurNalHeaderExt->uiTemporalId) {    return TRUE;  }   // Subclause 7.4.1.2.5  if (pLastSliceHeader->iRedundantPicCnt < pCurSliceHeader->iRedundantPicCnt)    return FALSE;  else if (pLastSliceHeader->iRedundantPicCnt > pCurSliceHeader->iRedundantPicCnt)    return TRUE;   // Subclause G7.4.1.2.4  if (pLastNalHdrExt->uiDependencyId < pCurNalHeaderExt->uiDependencyId)    return FALSE;  else if (pLastNalHdrExt->uiDependencyId > pCurNalHeaderExt->uiDependencyId)    return TRUE;  if (pLastNalHdrExt->uiQualityId < pCurNalHeaderExt->uiQualityId)    return FALSE;  else if (pLastNalHdrExt->uiQualityId > pCurNalHeaderExt->uiQualityId)    return TRUE;   // Subclause 7.4.1.2.4  if (pLastSliceHeader->iFrameNum != pCurSliceHeader->iFrameNum)    return TRUE;  if (pLastSliceHeader->iPpsId != pCurSliceHeader->iPpsId)    return TRUE;  if (pLastSliceHeader->bFieldPicFlag != pCurSliceHeader->bFieldPicFlag)    return TRUE;  if (pLastSliceHeader->bBottomFiledFlag != pCurSliceHeader->bBottomFiledFlag)    return TRUE;  if ((pLastNalHdrExt->sNalUnitHeader.uiNalRefIdc != NRI_PRI_LOWEST) != (pCurNalHeaderExt->sNalUnitHeader.uiNalRefIdc !=      NRI_PRI_LOWEST))    return TRUE;  if (pLastNalHdrExt->bIdrFlag != pCurNalHeaderExt->bIdrFlag)    return TRUE;  if (pCurNalHeaderExt->bIdrFlag) {    if (pLastSliceHeader->uiIdrPicId != pCurSliceHeader->uiIdrPicId)      return TRUE;  }  if (kpSps->uiPocType == 0) {    if (pLastSliceHeader->iPicOrderCntLsb != pCurSliceHeader->iPicOrderCntLsb)      return TRUE;    if (pLastSliceHeader->iDeltaPicOrderCntBottom != pCurSliceHeader->iDeltaPicOrderCntBottom)      return TRUE;  } else if (kpSps->uiPocType == 1) {    if (pLastSliceHeader->iDeltaPicOrderCnt[0] != pCurSliceHeader->iDeltaPicOrderCnt[0])      return TRUE;    if (pLastSliceHeader->iDeltaPicOrderCnt[1] != pCurSliceHeader->iDeltaPicOrderCnt[1])      return TRUE;  }   return FALSE;}  bool_t CheckAccessUnitBoundary (const PNalUnit kpCurNal, const PNalUnit kpLastNal, const PSps kpSps) {  const PNalUnitHeaderExt kpLastNalHeaderExt = &kpLastNal->sNalHeaderExt;  const PNalUnitHeaderExt kpCurNalHeaderExt = &kpCurNal->sNalHeaderExt;  const SSliceHeader* kpLastSliceHeader = &kpLastNal->sNalData.sVclNal.sSliceHeaderExt.sSliceHeader;  const SSliceHeader* kpCurSliceHeader = &kpCurNal->sNalData.sVclNal.sSliceHeaderExt.sSliceHeader;   //Sub-clause 7.1.4.1.1 temporal_id  if (kpLastNalHeaderExt->uiTemporalId != kpCurNalHeaderExt->uiTemporalId) {    return TRUE;  }   // Subclause 7.4.1.2.5  if (kpLastSliceHeader->iRedundantPicCnt < kpCurSliceHeader->iRedundantPicCnt)    return FALSE;  else if (kpLastSliceHeader->iRedundantPicCnt > kpCurSliceHeader->iRedundantPicCnt)    return TRUE;   // Subclause G7.4.1.2.4  if (kpLastNalHeaderExt->uiDependencyId < kpCurNalHeaderExt->uiDependencyId)    return FALSE;  else if (kpLastNalHeaderExt->uiDependencyId > kpCurNalHeaderExt->uiDependencyId)    return TRUE;  if (kpLastNalHeaderExt->uiQualityId < kpCurNalHeaderExt->uiQualityId)    return FALSE;  else if (kpLastNalHeaderExt->uiQualityId > kpCurNalHeaderExt->uiQualityId)    return TRUE;   // Subclause 7.4.1.2.4  if (kpLastSliceHeader->iFrameNum != kpCurSliceHeader->iFrameNum)    return TRUE;  if (kpLastSliceHeader->iPpsId != kpCurSliceHeader->iPpsId)    return TRUE;  if (kpLastSliceHeader->bFieldPicFlag != kpCurSliceHeader->bFieldPicFlag)    return TRUE;  if (kpLastSliceHeader->bBottomFiledFlag != kpCurSliceHeader->bBottomFiledFlag)    return TRUE;  if ((kpLastNalHeaderExt->sNalUnitHeader.uiNalRefIdc != NRI_PRI_LOWEST) != (kpCurNalHeaderExt->sNalUnitHeader.uiNalRefIdc      != NRI_PRI_LOWEST))    return TRUE;  if (kpLastNalHeaderExt->bIdrFlag != kpCurNalHeaderExt->bIdrFlag)    return TRUE;  if (kpCurNalHeaderExt->bIdrFlag) {    if (kpLastSliceHeader->uiIdrPicId != kpCurSliceHeader->uiIdrPicId)      return TRUE;  }  if (kpSps->uiPocType == 0) {    if (kpLastSliceHeader->iPicOrderCntLsb != kpCurSliceHeader->iPicOrderCntLsb)      return TRUE;    if (kpLastSliceHeader->iDeltaPicOrderCntBottom != kpCurSliceHeader->iDeltaPicOrderCntBottom)      return TRUE;  } else if (kpSps->uiPocType == 1) {    if (kpLastSliceHeader->iDeltaPicOrderCnt[0] != kpCurSliceHeader->iDeltaPicOrderCnt[0])      return TRUE;    if (kpLastSliceHeader->iDeltaPicOrderCnt[1] != kpCurSliceHeader->iDeltaPicOrderCnt[1])      return TRUE;  }   return FALSE;} /*! ************************************************************************************* * \brief	to parse NON VCL NAL Units * * \param 	pCtx		decoder context * \param	rbsp		rbsp buffer of NAL Unit * \param	src_len		length of rbsp buffer * * \return	0 - successed *	    	1 - failed * ************************************************************************************* */int32_t ParseNonVclNal (PWelsDecoderContext pCtx, uint8_t* pRbsp, const int32_t kiSrcLen) {  PBitStringAux	pBs = NULL;  ENalUnitType eNalType	= NAL_UNIT_UNSPEC_0; // make initial value as unspecified  int32_t iPicWidth		= 0;  int32_t iPicHeight		= 0;  int32_t iBitSize		= 0;  int32_t iErr				= ERR_NONE;   pBs	     = &pCtx->sBs;	// SBitStringAux instance for non VCL NALs decoding  iBitSize = (kiSrcLen << 3) - BsGetTrailingBits (pRbsp + kiSrcLen - 1); // convert into bit  eNalType = pCtx->sCurNalHead.eNalUnitType;   switch (eNalType) {  case NAL_UNIT_SPS:  case NAL_UNIT_SUBSET_SPS:    if (iBitSize > 0)      InitBits (pBs, pRbsp, iBitSize);#ifdef DEBUG_PARSE_INFO    WelsLog (pCtx, WELS_LOG_INFO, "parsing nal: %d \n", eNalType);#endif    iErr = ParseSps (pCtx, pBs, &iPicWidth, &iPicHeight);    if (ERR_NONE != iErr) {	// modified for pSps/pSubsetSps invalid, 12/1/2009      pCtx->iErrorCode |= dsNoParamSets;      return iErr;    } 

Lines 1–500 of 1041. Load more