Showing the changes to codec/decoder/core/src/au_parser.cpp (1 of 308 files). Show all
Unified · Split
| @@ -0,0 +1,1027 @@ | |||
| 1 | /*! | ||
| 2 | * \copy | ||
| 3 | * Copyright (c) 2009-2013, Cisco Systems | ||
| 4 | * All rights reserved. | ||
| 5 | * | ||
| 6 | * Redistribution and use in source and binary forms, with or without | ||
| 7 | * modification, are permitted provided that the following conditions | ||
| 8 | * are met: | ||
| 9 | * | ||
| 10 | * * Redistributions of source code must retain the above copyright | ||
| 11 | * notice, this list of conditions and the following disclaimer. | ||
| 12 | * | ||
| 13 | * * Redistributions in binary form must reproduce the above copyright | ||
| 14 | * notice, this list of conditions and the following disclaimer in | ||
| 15 | * the documentation and/or other materials provided with the | ||
| 16 | * distribution. | ||
| 17 | * | ||
| 18 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS | ||
| 19 | * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT | ||
| 20 | * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS | ||
| 21 | * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE | ||
| 22 | * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, | ||
| 23 | * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, | ||
| 24 | * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; | ||
| 25 | * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER | ||
| 26 | * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
| 27 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN | ||
| 28 | * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE | ||
| 29 | * POSSIBILITY OF SUCH DAMAGE. | ||
| 30 | * | ||
| 31 | * | ||
| 32 | * \file au_parser.c | ||
| 33 | * | ||
| 34 | * \brief Interfaces introduced in Access Unit level based parser | ||
| 35 | * | ||
| 36 | * \date 03/10/2009 Created | ||
| 37 | * | ||
| 38 | ************************************************************************************* | ||
| 39 | */ | ||
| 40 | #include <string.h> | ||
| 41 | #include "codec_def.h" | ||
| 42 | #include "ls_defines.h" | ||
| 43 | #include "macros.h" | ||
| 44 | #include "au_parser.h" | ||
| 45 | #include "decoder.h" | ||
| 46 | #include "error_code.h" | ||
| 47 | #include "dec_frame.h" | ||
| 48 | #include "dec_golomb.h" | ||
| 49 | #include "bit_stream.h" | ||
| 50 | #include "utils.h" | ||
| 51 | #include "codec_app_def.h" | ||
| 52 | #include "memmgr_nal_unit.h" | ||
| 53 | #include "decoder_core.h" | ||
| 54 | #include "wels_common_basis.h" | ||
| 55 | #include "decoder_core.h" | ||
| 56 | #include "manage_dec_ref.h" | ||
| 57 | #include "mem_align.h" | ||
| 58 | |||
| 59 | namespace WelsDec { | ||
| 60 | /*! | ||
| 61 | ************************************************************************************* | ||
| 62 | * \brief Start Code Prefix (0x 00 00 00 01) detection | ||
| 63 | * | ||
| 64 | * \param pBuf bitstream payload buffer | ||
| 65 | * \param pOffset offset between NAL rbsp and original bitsteam that | ||
| 66 | * start code prefix is seperated from. | ||
| 67 | * \param iBufSize count size of buffer | ||
| 68 | * | ||
| 69 | * \return RBSP buffer of start code prefix exclusive | ||
| 70 | * | ||
| 71 | * \note N/A | ||
| 72 | ************************************************************************************* | ||
| 73 | */ | ||
| 74 | uint8_t* DetectStartCodePrefix( const uint8_t *kpBuf, int32_t *pOffset, int32_t iBufSize ) | ||
| 75 | { | ||
| 76 | uint8_t *pBits = (uint8_t *)kpBuf; | ||
| 77 | |||
| 78 | do { | ||
| 79 | int32_t iIdx = 0; | ||
| 80 | while( (iIdx<iBufSize) && (!(*pBits)) ){ | ||
| 81 | ++ pBits; | ||
| 82 | ++ iIdx; | ||
| 83 | } | ||
| 84 | if( iIdx >= iBufSize ) break; | ||
| 85 | |||
| 86 | ++ iIdx; | ||
| 87 | ++ pBits; | ||
| 88 | |||
| 89 | if( (iIdx>=3) && ((*(pBits-1)) == 0x1) ){ | ||
| 90 | *pOffset = ((uint32_t)pBits) - ((uint32_t)kpBuf); | ||
| 91 | return pBits; | ||
| 92 | } | ||
| 93 | |||
| 94 | iBufSize -= iIdx; | ||
| 95 | } while (1); | ||
| 96 | |||
| 97 | return NULL; | ||
| 98 | } | ||
| 99 | |||
| 100 | /*! | ||
| 101 | ************************************************************************************* | ||
| 102 | * \brief to parse nal unit | ||
| 103 | * | ||
| 104 | * \param pCtx decoder context | ||
| 105 | * \param pNalUnitHeader parsed result of NAL Unit Header to output | ||
| 106 | * \param pSrcRbsp bitstream buffer to input | ||
| 107 | * \param iSrcRbspLen length size of bitstream buffer payload | ||
| 108 | * \param pSrcNal | ||
| 109 | * \param iSrcNalLen | ||
| 110 | * \param pConsumedBytes consumed bytes during parsing | ||
| 111 | * | ||
| 112 | * \return decoded bytes payload, might be (pSrcRbsp+1) if no escapes | ||
| 113 | * | ||
| 114 | * \note N/A | ||
| 115 | ************************************************************************************* | ||
| 116 | */ | ||
| 117 | uint8_t* ParseNalHeader( PWelsDecoderContext pCtx, SNalUnitHeader *pNalUnitHeader, uint8_t *pSrcRbsp, int32_t iSrcRbspLen, uint8_t *pSrcNal, int32_t iSrcNalLen, int32_t* pConsumedBytes ) | ||
| 118 | { | ||
| 119 | PNalUnit pCurNal = NULL; | ||
| 120 | uint8_t* pNal = pSrcRbsp; | ||
| 121 | int32_t iNalSize = iSrcRbspLen; | ||
| 122 | PBitStringAux pBs = NULL; | ||
| 123 | bool_t bExtensionFlag = false; | ||
| 124 | int32_t iErr = ERR_NONE; | ||
| 125 | int32_t iBitSize = 0; | ||
| 126 | |||
| 127 | pNalUnitHeader->eNalUnitType = NAL_UNIT_UNSPEC_0;//SHOULD init it. because pCtx->sCurNalHead is common variable. | ||
| 128 | |||
| 129 | //remove the consecutive ZERO at the end of current NAL in the reverse order.--2011.6.1 | ||
| 130 | { | ||
| 131 | int32_t iIndex = iSrcRbspLen - 1; | ||
| 132 | uint8_t uiBsZero = 0; | ||
| 133 | while ( iIndex >= 0 ) | ||
| 134 | { | ||
| 135 | uiBsZero = pSrcRbsp[iIndex]; | ||
| 136 | if ( 0 == uiBsZero ) | ||
| 137 | { | ||
| 138 | --iNalSize; | ||
| 139 | --iIndex; | ||
| 140 | } | ||
| 141 | else | ||
| 142 | { | ||
| 143 | break; | ||
| 144 | } | ||
| 145 | } | ||
| 146 | } | ||
| 147 | |||
| 148 | pNalUnitHeader->uiForbiddenZeroBit = (uint8_t)(pNal[0] >> 7); // uiForbiddenZeroBit | ||
| 149 | if ( pNalUnitHeader->uiForbiddenZeroBit )//2010.4.14 | ||
| 150 | { | ||
| 151 | return NULL; //uiForbiddenZeroBit should always equal to 0 | ||
| 152 | } | ||
| 153 | |||
| 154 | pNalUnitHeader->uiNalRefIdc = (uint8_t)(pNal[0] >> 5); // uiNalRefIdc | ||
| 155 | pNalUnitHeader->eNalUnitType = (ENalUnitType)(pNal[0] & 0x1f); // eNalUnitType | ||
| 156 | |||
| 157 | ++pNal; | ||
| 158 | --iNalSize; | ||
| 159 | ++(*pConsumedBytes); | ||
| 160 | |||
| 161 | #ifdef DEBUG_PARSE_INFO | ||
| 162 | WelsLog(pCtx, WELS_LOG_INFO, "nal type: %d \n", pNalUnitHeader->eNalUnitType); | ||
| 163 | #endif | ||
| 164 | |||
| 165 | if ( !(IS_SEI_NAL(pNalUnitHeader->eNalUnitType) || IS_SPS_NAL(pNalUnitHeader->eNalUnitType) || pCtx->bSpsExistAheadFlag) ) | ||
| 166 | { | ||
| 167 | 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); | ||
| 168 | pCtx->iErrorCode = dsNoParamSets; | ||
| 169 | return NULL; | ||
| 170 | } | ||
| 171 | if ( !(IS_SEI_NAL(pNalUnitHeader->eNalUnitType) || IS_PARAM_SETS_NALS(pNalUnitHeader->eNalUnitType) || pCtx->bPpsExistAheadFlag) ) | ||
| 172 | { | ||
| 173 | 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); | ||
| 174 | pCtx->iErrorCode = dsNoParamSets; | ||
| 175 | return NULL; | ||
| 176 | } | ||
| 177 | if ( (IS_VCL_NAL_AVC_BASE(pNalUnitHeader->eNalUnitType) && !(pCtx->bSpsExistAheadFlag || pCtx->bPpsExistAheadFlag)) || | ||
| 178 | (IS_NEW_INTRODUCED_NAL(pNalUnitHeader->eNalUnitType) && !(pCtx->bSpsExistAheadFlag || pCtx->bSubspsExistAheadFlag || pCtx->bPpsExistAheadFlag) ) ) | ||
| 179 | { | ||
| 180 | WelsLog( pCtx, WELS_LOG_WARNING, "ParseNalHeader(), no exist Parameter Sets ahead of sequence when try to decode slice(type:%d).\n", pNalUnitHeader->eNalUnitType); | ||
| 181 | pCtx->iErrorCode |= dsNoParamSets; | ||
| 182 | return NULL; | ||
| 183 | } | ||
| 184 | |||
| 185 | |||
| 186 | switch(pNalUnitHeader->eNalUnitType){ | ||
| 187 | case NAL_UNIT_SEI: | ||
| 188 | |||
| 189 | if ( pCtx->pAccessUnitList->uiAvailUnitsNum > 0 ) | ||
| 190 | { | ||
| 191 | pCtx->pAccessUnitList->uiEndPos = pCtx->pAccessUnitList->uiAvailUnitsNum - 1; | ||
| 192 | pCtx->bAuReadyFlag = true; | ||
| 193 | } | ||
| 194 | |||
| 195 | break; | ||
| 196 | |||
| 197 | case NAL_UNIT_SPS: | ||
| 198 | |||
| 199 | if ( pCtx->pAccessUnitList->uiAvailUnitsNum > 0 ) | ||
| 200 | { | ||
| 201 | pCtx->pAccessUnitList->uiEndPos = pCtx->pAccessUnitList->uiAvailUnitsNum - 1; | ||
| 202 | pCtx->bAuReadyFlag = true; | ||
| 203 | } | ||
| 204 | |||
| 205 | break; | ||
| 206 | |||
| 207 | case NAL_UNIT_PREFIX: | ||
| 208 | pCurNal = &pCtx->sPrefixNal; | ||
| 209 | |||
| 210 | if ( iNalSize < NAL_UNIT_HEADER_EXT_SIZE ) | ||
| 211 | { | ||
| 212 | return NULL; | ||
| 213 | } | ||
| 214 | |||
| 215 | DecodeNalHeaderExt( pCurNal, pNal ); | ||
| 216 | |||
| 217 | pNal += NAL_UNIT_HEADER_EXT_SIZE; | ||
| 218 | iNalSize -= NAL_UNIT_HEADER_EXT_SIZE; | ||
| 219 | *pConsumedBytes += NAL_UNIT_HEADER_EXT_SIZE; | ||
| 220 | |||
| 221 | pCurNal->sNalHeaderExt.sNalUnitHeader.uiForbiddenZeroBit = pNalUnitHeader->uiForbiddenZeroBit; | ||
| 222 | pCurNal->sNalHeaderExt.sNalUnitHeader.uiNalRefIdc = pNalUnitHeader->uiNalRefIdc; | ||
| 223 | pCurNal->sNalHeaderExt.sNalUnitHeader.eNalUnitType = pNalUnitHeader->eNalUnitType; | ||
| 224 | |||
| 225 | pBs = &pCtx->sBs; | ||
| 226 | |||
| 227 | iBitSize = (iNalSize<<3) - BsGetTrailingBits( pNal + iNalSize - 1 ); // convert into bit | ||
| 228 | |||
| 229 | InitBits( pBs, pNal, iBitSize); | ||
| 230 | |||
| 231 | ParsePrefixNalUnit( pCtx, pBs ); | ||
| 232 | |||
| 233 | break; | ||
| 234 | case NAL_UNIT_CODED_SLICE_EXT: | ||
| 235 | bExtensionFlag = true; | ||
| 236 | case NAL_UNIT_CODED_SLICE: | ||
| 237 | case NAL_UNIT_CODED_SLICE_IDR: | ||
| 238 | { | ||
| 239 | PAccessUnit pCurAu = NULL; | ||
| 240 | uint32_t uiAvailNalNum; | ||
| 241 | pCurNal = MemGetNextNal( &pCtx->pAccessUnitList ); | ||
| 242 | if( NULL == pCurNal ) | ||
| 243 | { | ||
| 244 | WelsLog( pCtx, WELS_LOG_WARNING, "MemGetNextNal() fail due out of memory.\n"); | ||
| 245 | pCtx->iErrorCode |= dsOutOfMemory; | ||
| 246 | return NULL; | ||
| 247 | } | ||
| 248 | |||
| 249 | pCurNal->sNalHeaderExt.sNalUnitHeader.uiForbiddenZeroBit = pNalUnitHeader->uiForbiddenZeroBit; | ||
| 250 | pCurNal->sNalHeaderExt.sNalUnitHeader.uiNalRefIdc = pNalUnitHeader->uiNalRefIdc; | ||
| 251 | pCurNal->sNalHeaderExt.sNalUnitHeader.eNalUnitType = pNalUnitHeader->eNalUnitType; | ||
| 252 | pCurAu = pCtx->pAccessUnitList; | ||
| 253 | uiAvailNalNum = pCurAu->uiAvailUnitsNum; | ||
| 254 | |||
| 255 | |||
| 256 | if( pNalUnitHeader->eNalUnitType == NAL_UNIT_CODED_SLICE_EXT ) | ||
| 257 | { | ||
| 258 | if ( iNalSize < NAL_UNIT_HEADER_EXT_SIZE ) | ||
| 259 | { | ||
| 260 | return NULL; | ||
| 261 | } | ||
| 262 | |||
| 263 | DecodeNalHeaderExt( pCurNal, pNal ); | ||
| 264 | if( pCurNal->sNalHeaderExt.uiQualityId != 0 || | ||
| 265 | pCurNal->sNalHeaderExt.bUseRefBasePicFlag ) | ||
| 266 | { | ||
| 267 | if( pCurNal->sNalHeaderExt.uiQualityId != 0 ) | ||
| 268 | WelsLog(pCtx, WELS_LOG_WARNING, "ParseNalHeader():uiQualityId (%d) != 0, MGS not supported!\n", pCurNal->sNalHeaderExt.uiQualityId); | ||
| 269 | if( pCurNal->sNalHeaderExt.bUseRefBasePicFlag != 0 ) | ||
| 270 | WelsLog(pCtx, WELS_LOG_WARNING, "ParseNalHeader():bUseRefBasePicFlag (%d) != 0, MGS not supported!\n", pCurNal->sNalHeaderExt.bUseRefBasePicFlag); | ||
| 271 | |||
| 272 | pCtx->iErrorCode |= dsInvalidArgument; | ||
| 273 | ForceClearCurrentNal( pCurAu ); | ||
| 274 | |||
| 275 | if ( uiAvailNalNum > 1 ) | ||
| 276 | { | ||
| 277 | pCurAu->uiEndPos = uiAvailNalNum - 2; | ||
| 278 | pCtx->bAuReadyFlag = true; | ||
| 279 | } | ||
| 280 | return NULL; | ||
| 281 | } | ||
| 282 | pNal += NAL_UNIT_HEADER_EXT_SIZE; | ||
| 283 | iNalSize -= NAL_UNIT_HEADER_EXT_SIZE; | ||
| 284 | *pConsumedBytes += NAL_UNIT_HEADER_EXT_SIZE; | ||
| 285 | |||
| 286 | } | ||
| 287 | else | ||
| 288 | { | ||
| 289 | |||
| 290 | |||
| 291 | if ( NAL_UNIT_PREFIX == pCtx->sPrefixNal.sNalHeaderExt.sNalUnitHeader.eNalUnitType ) | ||
| 292 | { | ||
| 293 | PrefetchNalHeaderExtSyntax( pCtx, pCurNal, &pCtx->sPrefixNal ); | ||
| 294 | } | ||
| 295 | |||
| 296 | pCurNal->sNalHeaderExt.bIdrFlag = ( NAL_UNIT_CODED_SLICE_IDR == pNalUnitHeader->eNalUnitType ) ? true : false; //SHOULD update this flag for AVC if no prefix NAL | ||
| 297 | pCurNal->sNalHeaderExt.iNoInterLayerPredFlag = 1; | ||
| 298 | } | ||
| 299 | |||
| 300 | pBs = &pCurAu->pNalUnitsList[uiAvailNalNum-1]->sNalData.sVclNal.sSliceBitsRead; | ||
| 301 | iBitSize = (iNalSize<<3) - BsGetTrailingBits( pNal+ iNalSize - 1 ); // convert into bit | ||
| 302 | InitBits( pBs, pNal, iBitSize); | ||
| 303 | iErr = ParseSliceHeaderSyntaxs( pCtx, pBs, bExtensionFlag ); | ||
| 304 | if ( iErr != ERR_NONE ) | ||
| 305 | { | ||
| 306 | //if current NAL occur error when parsing, should clean it from pNalUnitsList | ||
| 307 | //otherwise, when Next good NAL decoding, this corrupt NAL is considered as normal NAL and lead to decoder crash | ||
| 308 | ForceClearCurrentNal( pCurAu ); | ||
| 309 | |||
| 310 | if ( uiAvailNalNum > 1 ) | ||
| 311 | { | ||
| 312 | pCurAu->uiEndPos = uiAvailNalNum - 2; | ||
| 313 | pCtx->bAuReadyFlag = true; | ||
| 314 | |||
| 315 | |||
| 316 | } | ||
| 317 | #ifdef MOSAIC_AVOID_BASED_ON_SPS_PPS_ID | ||
| 318 | if ( dsNoParamSets & pCtx->iErrorCode ) | ||
| 319 | { | ||
| 320 | if ( uiAvailNalNum <= 1 ) //no any data to decode and SPS/PPS ID mismatch, SHOULD request IDR | ||
| 321 | { | ||
| 322 | #ifdef LONG_TERM_REF | ||
| 323 | pCtx->bParamSetsLostFlag = true; | ||
| 324 | #else | ||
| 325 | pCtx->bReferenceLostAtT0Flag = true; | ||
| 326 | #endif | ||
| 327 | ResetParameterSetsState( pCtx ); | ||
| 328 | } | ||
| 329 | return NULL; | ||
| 330 | } | ||
| 331 | else | ||
| 332 | { | ||
| 333 | return NULL; | ||
| 334 | } | ||
| 335 | #else | ||
| 336 | return NULL; | ||
| 337 | #endif //MOSAIC_AVOID_BASED_ON_SPS_PPS_ID | ||
| 338 | } | ||
| 339 | |||
| 340 | if ( (uiAvailNalNum > 1) && | ||
| 341 | CheckAccessUnitBoundary( pCurAu->pNalUnitsList[uiAvailNalNum-1], pCurAu->pNalUnitsList[uiAvailNalNum-2], | ||
| 342 | pCurAu->pNalUnitsList[uiAvailNalNum-1]->sNalData.sVclNal.sSliceHeaderExt.sSliceHeader.pSps) ) | ||
| 343 | { | ||
| 344 | pCurAu->uiEndPos = uiAvailNalNum - 2; | ||
| 345 | pCtx->bAuReadyFlag = true; | ||
| 346 | |||
| 347 | |||
| 348 | } | ||
| 349 | } | ||
| 350 | break; | ||
| 351 | default: | ||
| 352 | break; | ||
| 353 | } | ||
| 354 | |||
| 355 | return pNal; | ||
| 356 | } | ||
| 357 | |||
| 358 | |||
| 359 | bool_t CheckAccessUnitBoundaryExt( PNalUnitHeaderExt pLastNalHdrExt, PNalUnitHeaderExt pCurNalHeaderExt, PSliceHeader pLastSliceHeader, PSliceHeader pCurSliceHeader ) | ||
| 360 | { | ||
| 361 | const PSps kpSps = pCurSliceHeader->pSps; | ||
| 362 | |||
| 363 | //Sub-clause 7.1.4.1.1 temporal_id | ||
| 364 | if (pLastNalHdrExt->uiTemporalId != pCurNalHeaderExt->uiTemporalId) { | ||
| 365 | return TRUE; | ||
| 366 | } | ||
| 367 | |||
| 368 | // Subclause 7.4.1.2.5 | ||
| 369 | if ( pLastSliceHeader->iRedundantPicCnt < pCurSliceHeader->iRedundantPicCnt ) | ||
| 370 | return FALSE; | ||
| 371 | else if ( pLastSliceHeader->iRedundantPicCnt > pCurSliceHeader->iRedundantPicCnt ) | ||
| 372 | return TRUE; | ||
| 373 | |||
| 374 | // Subclause G7.4.1.2.4 | ||
| 375 | if ( pLastNalHdrExt->uiDependencyId < pCurNalHeaderExt->uiDependencyId ) | ||
| 376 | return FALSE; | ||
| 377 | else if ( pLastNalHdrExt->uiDependencyId > pCurNalHeaderExt->uiDependencyId ) | ||
| 378 | return TRUE; | ||
| 379 | if ( pLastNalHdrExt->uiQualityId < pCurNalHeaderExt->uiQualityId ) | ||
| 380 | return FALSE; | ||
| 381 | else if ( pLastNalHdrExt->uiQualityId > pCurNalHeaderExt->uiQualityId ) | ||
| 382 | return TRUE; | ||
| 383 | |||
| 384 | // Subclause 7.4.1.2.4 | ||
| 385 | if ( pLastSliceHeader->iFrameNum != pCurSliceHeader->iFrameNum ) | ||
| 386 | return TRUE; | ||
| 387 | if ( pLastSliceHeader->iPpsId != pCurSliceHeader->iPpsId ) | ||
| 388 | return TRUE; | ||
| 389 | if ( pLastSliceHeader->bFieldPicFlag != pCurSliceHeader->bFieldPicFlag ) | ||
| 390 | return TRUE; | ||
| 391 | if ( pLastSliceHeader->bBottomFiledFlag != pCurSliceHeader->bBottomFiledFlag ) | ||
| 392 | return TRUE; | ||
| 393 | if ( (pLastNalHdrExt->sNalUnitHeader.uiNalRefIdc != NRI_PRI_LOWEST) != (pCurNalHeaderExt->sNalUnitHeader.uiNalRefIdc != NRI_PRI_LOWEST) ) | ||
| 394 | return TRUE; | ||
| 395 | if ( pLastNalHdrExt->bIdrFlag != pCurNalHeaderExt->bIdrFlag ) | ||
| 396 | return TRUE; | ||
| 397 | if ( pCurNalHeaderExt->bIdrFlag ){ | ||
| 398 | if ( pLastSliceHeader->uiIdrPicId != pCurSliceHeader->uiIdrPicId ) | ||
| 399 | return TRUE; | ||
| 400 | } | ||
| 401 | if ( kpSps->uiPocType == 0 ){ | ||
| 402 | if ( pLastSliceHeader->iPicOrderCntLsb != pCurSliceHeader->iPicOrderCntLsb ) | ||
| 403 | return TRUE; | ||
| 404 | if ( pLastSliceHeader->iDeltaPicOrderCntBottom != pCurSliceHeader->iDeltaPicOrderCntBottom ) | ||
| 405 | return TRUE; | ||
| 406 | } | ||
| 407 | else if ( kpSps->uiPocType == 1 ){ | ||
| 408 | if ( pLastSliceHeader->iDeltaPicOrderCnt[0] != pCurSliceHeader->iDeltaPicOrderCnt[0] ) | ||
| 409 | return TRUE; | ||
| 410 | if ( pLastSliceHeader->iDeltaPicOrderCnt[1] != pCurSliceHeader->iDeltaPicOrderCnt[1] ) | ||
| 411 | return TRUE; | ||
| 412 | } | ||
| 413 | |||
| 414 | return FALSE; | ||
| 415 | } | ||
| 416 | |||
| 417 | |||
| 418 | bool_t CheckAccessUnitBoundary( const PNalUnit kpCurNal, const PNalUnit kpLastNal, const PSps kpSps ) | ||
| 419 | { | ||
| 420 | const PNalUnitHeaderExt kpLastNalHeaderExt = &kpLastNal->sNalHeaderExt; | ||
| 421 | const PNalUnitHeaderExt kpCurNalHeaderExt = &kpCurNal->sNalHeaderExt; | ||
| 422 | const SSliceHeader *kpLastSliceHeader = &kpLastNal->sNalData.sVclNal.sSliceHeaderExt.sSliceHeader; | ||
| 423 | const SSliceHeader *kpCurSliceHeader = &kpCurNal->sNalData.sVclNal.sSliceHeaderExt.sSliceHeader; | ||
| 424 | |||
| 425 | //Sub-clause 7.1.4.1.1 temporal_id | ||
| 426 | if (kpLastNalHeaderExt->uiTemporalId != kpCurNalHeaderExt->uiTemporalId) { | ||
| 427 | return TRUE; | ||
| 428 | } | ||
| 429 | |||
| 430 | // Subclause 7.4.1.2.5 | ||
| 431 | if ( kpLastSliceHeader->iRedundantPicCnt < kpCurSliceHeader->iRedundantPicCnt ) | ||
| 432 | return FALSE; | ||
| 433 | else if ( kpLastSliceHeader->iRedundantPicCnt > kpCurSliceHeader->iRedundantPicCnt ) | ||
| 434 | return TRUE; | ||
| 435 | |||
| 436 | // Subclause G7.4.1.2.4 | ||
| 437 | if ( kpLastNalHeaderExt->uiDependencyId < kpCurNalHeaderExt->uiDependencyId ) | ||
| 438 | return FALSE; | ||
| 439 | else if ( kpLastNalHeaderExt->uiDependencyId > kpCurNalHeaderExt->uiDependencyId ) | ||
| 440 | return TRUE; | ||
| 441 | if ( kpLastNalHeaderExt->uiQualityId < kpCurNalHeaderExt->uiQualityId ) | ||
| 442 | return FALSE; | ||
| 443 | else if ( kpLastNalHeaderExt->uiQualityId > kpCurNalHeaderExt->uiQualityId ) | ||
| 444 | return TRUE; | ||
| 445 | |||
| 446 | // Subclause 7.4.1.2.4 | ||
| 447 | if ( kpLastSliceHeader->iFrameNum != kpCurSliceHeader->iFrameNum ) | ||
| 448 | return TRUE; | ||
| 449 | if ( kpLastSliceHeader->iPpsId != kpCurSliceHeader->iPpsId ) | ||
| 450 | return TRUE; | ||
| 451 | if ( kpLastSliceHeader->bFieldPicFlag != kpCurSliceHeader->bFieldPicFlag ) | ||
| 452 | return TRUE; | ||
| 453 | if ( kpLastSliceHeader->bBottomFiledFlag != kpCurSliceHeader->bBottomFiledFlag ) | ||
| 454 | return TRUE; | ||
| 455 | if ( (kpLastNalHeaderExt->sNalUnitHeader.uiNalRefIdc != NRI_PRI_LOWEST) != (kpCurNalHeaderExt->sNalUnitHeader.uiNalRefIdc != NRI_PRI_LOWEST) ) | ||
| 456 | return TRUE; | ||
| 457 | if ( kpLastNalHeaderExt->bIdrFlag != kpCurNalHeaderExt->bIdrFlag ) | ||
| 458 | return TRUE; | ||
| 459 | if ( kpCurNalHeaderExt->bIdrFlag ){ | ||
| 460 | if ( kpLastSliceHeader->uiIdrPicId != kpCurSliceHeader->uiIdrPicId ) | ||
| 461 | return TRUE; | ||
| 462 | } | ||
| 463 | if ( kpSps->uiPocType == 0 ){ | ||
| 464 | if ( kpLastSliceHeader->iPicOrderCntLsb != kpCurSliceHeader->iPicOrderCntLsb ) | ||
| 465 | return TRUE; | ||
| 466 | if ( kpLastSliceHeader->iDeltaPicOrderCntBottom != kpCurSliceHeader->iDeltaPicOrderCntBottom ) | ||
| 467 | return TRUE; | ||
| 468 | } | ||
| 469 | else if ( kpSps->uiPocType == 1 ){ | ||
| 470 | if ( kpLastSliceHeader->iDeltaPicOrderCnt[0] != kpCurSliceHeader->iDeltaPicOrderCnt[0] ) | ||
| 471 | return TRUE; | ||
| 472 | if ( kpLastSliceHeader->iDeltaPicOrderCnt[1] != kpCurSliceHeader->iDeltaPicOrderCnt[1] ) | ||
| 473 | return TRUE; | ||
| 474 | } | ||
| 475 | |||
| 476 | return FALSE; | ||
| 477 | } | ||
| 478 | |||
| 479 | /*! | ||
| 480 | ************************************************************************************* | ||
| 481 | * \brief to parse NON VCL NAL Units | ||
| 482 | * | ||
| 483 | * \param pCtx decoder context | ||
| 484 | * \param rbsp rbsp buffer of NAL Unit | ||
| 485 | * \param src_len length of rbsp buffer | ||
| 486 | * | ||
| 487 | * \return 0 - successed | ||
| 488 | * 1 - failed | ||
| 489 | * | ||
| 490 | ************************************************************************************* | ||
| 491 | */ | ||
| 492 | int32_t ParseNonVclNal( PWelsDecoderContext pCtx, uint8_t *pRbsp, const int32_t kiSrcLen ) | ||
| 493 | { | ||
| 494 | PBitStringAux pBs = NULL; | ||
| 495 | ENalUnitType eNalType = NAL_UNIT_UNSPEC_0; // make initial value as unspecified | ||
| 496 | int32_t iPicWidth = 0; | ||
| 497 | int32_t iPicHeight = 0; | ||
| 498 | int32_t iBitSize = 0; | ||
| 499 | int32_t iErr = ERR_NONE; | ||
| 500 | |||
| 501 | pBs = &pCtx->sBs; // SBitStringAux instance for non VCL NALs decoding | ||
| 502 | iBitSize = (kiSrcLen<<3) - BsGetTrailingBits( pRbsp + kiSrcLen - 1 ); // convert into bit | ||
| 503 | eNalType = pCtx->sCurNalHead.eNalUnitType; | ||
| 504 | |||
| 505 | switch( eNalType ) { | ||
| 506 | case NAL_UNIT_SPS: | ||
| 507 | case NAL_UNIT_SUBSET_SPS: | ||
| 508 | if ( iBitSize > 0 ) | ||
| 509 | InitBits( pBs, pRbsp, iBitSize ); | ||
| 510 | #ifdef DEBUG_PARSE_INFO | ||
| 511 | WelsLog(pCtx, WELS_LOG_INFO, "parsing nal: %d \n", eNalType); | ||
| 512 | #endif | ||
| 513 | iErr = ParseSps( pCtx, pBs, &iPicWidth, &iPicHeight ); | ||
| 514 | if ( ERR_NONE != iErr ) // modified for pSps/pSubsetSps invalid, 12/1/2009 | ||
| 515 | { | ||
| 516 | pCtx->iErrorCode |= dsNoParamSets; | ||
| 517 | return iErr; | ||
| 518 | } | ||
| 519 | |||
| 520 | if ( ERR_NONE == iErr ) | ||
| 521 | UpdateMaxPictureResolution( pCtx, iPicWidth, iPicHeight ); | ||
| 522 | |||
| 523 | break; | ||
| 524 | |||
| 525 | case NAL_UNIT_PPS: | ||
| 526 | if ( iBitSize > 0 ) | ||
| 527 | InitBits( pBs, pRbsp, iBitSize ); | ||
| 528 | #ifdef DEBUG_PARSE_INFO | ||
| 529 | WelsLog(pCtx, WELS_LOG_INFO, "parsing nal: %d \n", eNalType); | ||
| 530 | #endif | ||
| 531 | iErr = ParsePps( pCtx, &pCtx->sPpsBuffer[0], pBs ); | ||
| 532 | if ( ERR_NONE != iErr ) // modified for pps invalid, 12/1/2009 | ||
| 533 | { | ||
| 534 | pCtx->iErrorCode |= dsNoParamSets; | ||
| 535 | return iErr; | ||
| 536 | } | ||
| 537 | |||
| 538 | pCtx->bPpsExistAheadFlag = true; | ||
| 539 | |||
| 540 | break; | ||
| 541 | |||
| 542 | case NAL_UNIT_SEI: | ||
| 543 | |||
| 544 | break; | ||
| 545 | |||
| 546 | case NAL_UNIT_PREFIX: | ||
| 547 | break; | ||
| 548 | case NAL_UNIT_CODED_SLICE_DPA: | ||
| 549 | case NAL_UNIT_CODED_SLICE_DPB: | ||
| 550 | case NAL_UNIT_CODED_SLICE_DPC: | ||
| 551 | |||
| 552 | break; | ||
| 553 | |||
| 554 | default: | ||
| 555 | break; | ||
| 556 | } | ||
| 557 | |||
| 558 | return iErr; | ||
| 559 | } | ||
| 560 | |||
| 561 | void_t ParseRefBasePicMarking ( PBitStringAux pBs, PRefBasePicMarking pRefBasePicMarking ) | ||
| 562 | { | ||
| 563 | const bool_t kbAdaptiveMarkingModeFlag = !!BsGetOneBit( pBs ); | ||
| 564 | pRefBasePicMarking->bAdaptiveRefBasePicMarkingModeFlag = kbAdaptiveMarkingModeFlag; | ||
| 565 | if ( kbAdaptiveMarkingModeFlag ){ | ||
| 566 | int32_t iIdx = 0; | ||
| 567 | do { | ||
| 568 | const uint32_t kuiMmco = BsGetUe( pBs ); | ||
| 569 | |||
| 570 | pRefBasePicMarking->mmco_base[iIdx].uiMmcoType = kuiMmco; | ||
| 571 | |||
| 572 | if (kuiMmco == MMCO_END) | ||
| 573 | break; | ||
| 574 | |||
| 575 | if (kuiMmco == MMCO_SHORT2UNUSED){ | ||
| 576 | pRefBasePicMarking->mmco_base[iIdx].uiDiffOfPicNums = 1 + BsGetUe( pBs ); | ||
| 577 | pRefBasePicMarking->mmco_base[iIdx].iShortFrameNum = 0; | ||
| 578 | } | ||
| 579 | else if (kuiMmco == MMCO_LONG2UNUSED){ | ||
| 580 | pRefBasePicMarking->mmco_base[iIdx].uiLongTermPicNum = BsGetUe( pBs ); | ||
| 581 | } | ||
| 582 | ++ iIdx; | ||
| 583 | } while(iIdx < MAX_MMCO_COUNT); | ||
| 584 | } | ||
| 585 | } | ||
| 586 | |||
| 587 | void_t ParsePrefixNalUnit ( PWelsDecoderContext pCtx, PBitStringAux pBs ) | ||
| 588 | { | ||
| 589 | PNalUnit pCurNal = &pCtx->sPrefixNal; | ||
| 590 | |||
| 591 | if ( pCurNal->sNalHeaderExt.sNalUnitHeader.uiNalRefIdc != 0 ){ | ||
| 592 | PNalUnitHeaderExt head_ext = &pCurNal->sNalHeaderExt; | ||
| 593 | PPrefixNalUnit sPrefixNal = &pCurNal->sNalData.sPrefixNal; | ||
| 594 | sPrefixNal->bStoreRefBasePicFlag = !!BsGetOneBit( pBs ); | ||
| 595 | if ( (head_ext->bUseRefBasePicFlag || sPrefixNal->bStoreRefBasePicFlag) && !head_ext->bIdrFlag ) | ||
| 596 | { | ||
| 597 | ParseRefBasePicMarking ( pBs, &sPrefixNal->sRefPicBaseMarking ); | ||
| 598 | } | ||
| 599 | sPrefixNal->bPrefixNalUnitAdditionalExtFlag = !!BsGetOneBit( pBs ); | ||
| 600 | if ( sPrefixNal->bPrefixNalUnitAdditionalExtFlag ){ | ||
| 601 | sPrefixNal->bPrefixNalUnitExtFlag = !!BsGetOneBit( pBs ); | ||
| 602 | } | ||
| 603 | } | ||
| 604 | } | ||
| 605 | |||
| 606 | |||
| 607 | int32_t DecodeSpsSvcExt( PWelsDecoderContext pCtx, PSubsetSps pSpsExt, PBitStringAux pBs ) | ||
| 608 | { | ||
| 609 | PSpsSvcExt pExt = NULL; | ||
| 610 | uint8_t uiChromaArrayType = 1; | ||
| 611 | |||
| 612 | pExt = &pSpsExt->sSpsSvcExt; | ||
| 613 | |||
| 614 | pExt->bInterLayerDeblockingFilterCtrlPresentFlag = !!BsGetOneBit( pBs ); | ||
| 615 | pExt->uiExtendedSpatialScalability = BsGetBits( pBs, 2 ); | ||
| 616 | if ( pExt->uiExtendedSpatialScalability > 2 ) | ||
| 617 | { | ||
| 618 | WelsLog(pCtx, WELS_LOG_WARNING, "DecodeSpsSvcExt():extended_spatial_scalability (%d) != 0, ESS not supported!\n", pExt->uiExtendedSpatialScalability); | ||
| 619 | return GENERATE_ERROR_NO(ERR_LEVEL_PARAM_SETS, ERR_INFO_INVALID_ESS); | ||
| 620 | } | ||
| 621 | |||
| 622 | pExt->uiChromaPhaseXPlus1Flag = 0; // FIXME: Incoherent with JVT X201 standard (= 1), but conformance to JSVM (= 0) implementation. | ||
| 623 | pExt->uiChromaPhaseYPlus1 = 1; | ||
| 624 | uiChromaArrayType = pSpsExt->sSps.uiChromaArrayType; | ||
| 625 | |||
| 626 | pExt->uiChromaPhaseXPlus1Flag = BsGetOneBit( pBs ); | ||
| 627 | pExt->uiChromaPhaseYPlus1 = BsGetBits( pBs, 2 ); | ||
| 628 | |||
| 629 | pExt->uiSeqRefLayerChromaPhaseXPlus1Flag = pExt->uiChromaPhaseXPlus1Flag; | ||
| 630 | pExt->uiSeqRefLayerChromaPhaseYPlus1 = pExt->uiChromaPhaseYPlus1; | ||
| 631 | memset(&pExt->sSeqScaledRefLayer, 0, sizeof(SPosOffset)); | ||
| 632 | |||
| 633 | if ( pExt->uiExtendedSpatialScalability == 1 ){ | ||
| 634 | SPosOffset* const kpPos = &pExt->sSeqScaledRefLayer; | ||
| 635 | pExt->uiSeqRefLayerChromaPhaseXPlus1Flag = BsGetOneBit( pBs ); | ||
| 636 | pExt->uiSeqRefLayerChromaPhaseYPlus1 = BsGetBits( pBs, 2 ); | ||
| 637 | |||
| 638 | kpPos->iLeftOffset = BsGetSe( pBs ); | ||
| 639 | kpPos->iTopOffset = BsGetSe( pBs ); | ||
| 640 | kpPos->iRightOffset = BsGetSe( pBs ); | ||
| 641 | kpPos->iBottomOffset= BsGetSe( pBs ); | ||
| 642 | } | ||
| 643 | |||
| 644 | pExt->bSeqTCoeffLevelPredFlag = !!BsGetOneBit( pBs ); | ||
| 645 | pExt->bAdaptiveTCoeffLevelPredFlag = false; | ||
| 646 | if ( pExt->bSeqTCoeffLevelPredFlag ) | ||
| 647 | pExt->bAdaptiveTCoeffLevelPredFlag = !!BsGetOneBit( pBs ); | ||
| 648 | pExt->bSliceHeaderRestrictionFlag = !!BsGetOneBit( pBs ); | ||
| 649 | |||
| 650 | |||
| 651 | |||
| 652 | return 0; | ||
| 653 | } | ||
| 654 | |||
| 655 | /*! | ||
| 656 | ************************************************************************************* | ||
| 657 | * \brief to parse Sequence Parameter Set (SPS) | ||
| 658 | * | ||
| 659 | * \param pCtx Decoder context | ||
| 660 | * \param pBsAux bitstream reader auxiliary | ||
| 661 | * \param pPicWidth picture width current Sps represented | ||
| 662 | * \param pPicHeight picture height current Sps represented | ||
| 663 | * | ||
| 664 | * \return 0 - successed | ||
| 665 | * 1 - failed | ||
| 666 | * | ||
| 667 | * \note Call it in case eNalUnitType is SPS. | ||
| 668 | ************************************************************************************* | ||
| 669 | */ | ||
| 670 | |||
| 671 | |||
| 672 | int32_t ParseSps( PWelsDecoderContext pCtx, PBitStringAux pBsAux, int32_t *pPicWidth, int32_t *pPicHeight ) | ||
| 673 | { | ||
| 674 | PBitStringAux pBs = pBsAux; | ||
| 675 | PSps pSps = NULL; | ||
| 676 | PSubsetSps pSubsetSps = NULL; | ||
| 677 | SNalUnitHeader *pNalHead= &pCtx->sCurNalHead; | ||
| 678 | ProfileIdc uiProfileIdc; | ||
| 679 | uint8_t uiLevelIdc; | ||
| 680 | int32_t iSpsId; | ||
| 681 | bool_t bConstraintSetFlags[6] = { false }; | ||
| 682 | const bool_t kbUseSubsetFlag = IS_SUBSET_SPS_NAL(pNalHead->eNalUnitType); | ||
| 683 | |||
| 684 | |||
| 685 | if ( kbUseSubsetFlag ) // SubsetSps | ||
| 686 | { | ||
| 687 | pCtx->bSubspsExistAheadFlag = true; | ||
| 688 | } | ||
| 689 | else // Sps | ||
| 690 | { | ||
| 691 | pCtx->bSpsExistAheadFlag = true; | ||
| 692 | |||
| 693 | // added for EC, 10/28/2009 | ||
| 694 | // for safe | ||
| 695 | memset( &pCtx->bSpsAvailFlags[0], 0, sizeof(pCtx->bSpsAvailFlags) ); | ||
| 696 | memset( &pCtx->bSubspsAvailFlags[0], 0, sizeof(pCtx->bSubspsAvailFlags) ); | ||
| 697 | memset( &pCtx->bPpsAvailFlags[0], 0, sizeof(pCtx->bPpsAvailFlags) ); | ||
| 698 | |||
| 699 | #ifdef MOSAIC_AVOID_BASED_ON_SPS_PPS_ID | ||
| 700 | pCtx->iSpsTotalNum = 0; | ||
| 701 | pCtx->iSubspsTotalNum = 0; | ||
| 702 | pCtx->iPpsTotalNum = 0; | ||
| 703 | #endif //MOSAIC_AVOID_BASED_ON_SPS_PPS_ID | ||
| 704 | } | ||
| 705 | |||
| 706 | uiProfileIdc = BsGetBits( pBs, 8 ); | ||
| 707 | bConstraintSetFlags[0] = !!BsGetOneBit( pBs ); // constraint_set0_flag | ||
| 708 | bConstraintSetFlags[1] = !!BsGetOneBit( pBs ); // constraint_set1_flag | ||
| 709 | bConstraintSetFlags[2] = !!BsGetOneBit( pBs ); // constraint_set2_flag | ||
| 710 | bConstraintSetFlags[3] = !!BsGetOneBit( pBs ); // constraint_set3_flag | ||
| 711 | bConstraintSetFlags[4] = !!BsGetOneBit( pBs ); // constraint_set4_flag | ||
| 712 | bConstraintSetFlags[5] = !!BsGetOneBit( pBs ); // constraint_set5_flag | ||
| 713 | BsGetBits( pBs, 2 ); // reserved_zero_2bits, equal to 0 | ||
| 714 | uiLevelIdc = BsGetBits( pBs, 8 ); // level_idc | ||
| 715 | |||
| 716 | iSpsId = BsGetUe( pBs ); // seq_parameter_set_id | ||
| 717 | |||
| 718 | |||
| 719 | if ( iSpsId >= MAX_SPS_COUNT || iSpsId < 0 ) // Modified to check invalid negative iSpsId, 12/1/2009 | ||
| 720 | { | ||
| 721 | WelsLog( pCtx, WELS_LOG_WARNING, " iSpsId is out of range! \n"); | ||
| 722 | return GENERATE_ERROR_NO(ERR_LEVEL_PARAM_SETS, ERR_INFO_SPS_ID_OVERFLOW); | ||
| 723 | } | ||
| 724 | |||
| 725 | if ( kbUseSubsetFlag ) | ||
| 726 | { | ||
| 727 | #ifdef MOSAIC_AVOID_BASED_ON_SPS_PPS_ID | ||
| 728 | pSubsetSps = &pCtx->sSubsetSpsBuffer[pCtx->iSubspsTotalNum]; | ||
| 729 | pCtx->bSubspsAvailFlags[pCtx->iSubspsTotalNum] = true; | ||
| 730 | |||
| 731 | pSubsetSps->sSps.iSpsId = iSpsId; | ||
| 732 | pSps = &pSubsetSps->sSps; | ||
| 733 | ++pCtx->iSubspsTotalNum; | ||
| 734 | #else | ||
| 735 | pSubsetSps = &pCtx->sSubsetSpsBuffer[iSpsId]; | ||
| 736 | pSps = &pSubsetSps->sSps; | ||
| 737 | pCtx->bSubspsAvailFlags[iSpsId] = true; // added for EC, 10/28/2009 | ||
| 738 | #endif //MOSAIC_AVOID_BASED_ON_SPS_PPS_ID | ||
| 739 | } | ||
| 740 | else | ||
| 741 | { | ||
| 742 | #ifdef MOSAIC_AVOID_BASED_ON_SPS_PPS_ID | ||
| 743 | pSps = &pCtx->sSpsBuffer[pCtx->iSpsTotalNum]; | ||
| 744 | pCtx->bSpsAvailFlags[pCtx->iSpsTotalNum] = true; | ||
| 745 | |||
| 746 | pSps->iSpsId = iSpsId; | ||
| 747 | ++pCtx->iSpsTotalNum; | ||
| 748 | #else | ||
| 749 | pSps = &pCtx->sSpsBuffer[iSpsId]; | ||
| 750 | pCtx->bSpsAvailFlags[iSpsId] = true; // added for EC, 10/28/2009 | ||
| 751 | #endif //MOSAIC_AVOID_BASED_ON_SPS_PPS_ID | ||
| 752 | } | ||
| 753 | |||
| 754 | // syntax elements in default | ||
| 755 | pSps->uiChromaFormatIdc = 1; | ||
| 756 | pSps->uiBitDepthLuma = | ||
| 757 | pSps->uiBitDepthChroma = 8; | ||
| 758 | |||
| 759 | pSps->uiProfileIdc = uiProfileIdc; | ||
| 760 | pSps->uiLevelIdc = uiLevelIdc; | ||
| 761 | pSps->iSpsId = iSpsId; | ||
| 762 | |||
| 763 | if ( PRO_SCALABLE_BASELINE == uiProfileIdc || PRO_SCALABLE_HIGH == uiProfileIdc || | ||
| 764 | PRO_HIGH == uiProfileIdc || PRO_HIGH10 == uiProfileIdc || | ||
| 765 | PRO_HIGH422 == uiProfileIdc || PRO_HIGH444 == uiProfileIdc || | ||
| 766 | PRO_CAVLC444 == uiProfileIdc || 44 == uiProfileIdc ){ | ||
| 767 | |||
| 768 | pSps->uiChromaFormatIdc = BsGetUe( pBs ); | ||
| 769 | if( pSps->uiChromaFormatIdc != 1 ) | ||
| 770 | { | ||
| 771 | WelsLog( pCtx, WELS_LOG_WARNING, "ParseSps(): chroma_format_idc (%d) = 1 supported.\n", pSps->uiChromaFormatIdc); | ||
| 772 | return GENERATE_ERROR_NO(ERR_LEVEL_PARAM_SETS, ERR_INFO_UNSUPPORTED_NON_BASELINE); | ||
| 773 | } | ||
| 774 | pSps->uiChromaArrayType = pSps->uiChromaFormatIdc; | ||
| 775 | pSps->uiBitDepthLuma = 8 + BsGetUe( pBs ); | ||
| 776 | if( pSps->uiBitDepthLuma != 8 ) | ||
| 777 | { | ||
| 778 | WelsLog( pCtx, WELS_LOG_WARNING, "ParseSps(): bit_depth_luma (%d) Only 8 bit supported.\n", pSps->uiBitDepthLuma); | ||
| 779 | return GENERATE_ERROR_NO(ERR_LEVEL_PARAM_SETS, ERR_INFO_UNSUPPORTED_NON_BASELINE); | ||
| 780 | } | ||
| 781 | |||
| 782 | pSps->uiBitDepthChroma = 8 + BsGetUe( pBs ); | ||
| 783 | if( pSps->uiBitDepthChroma != 8 ) | ||
| 784 | { | ||
| 785 | WelsLog( pCtx, WELS_LOG_WARNING, "ParseSps(): bit_depth_chroma (%d). Only 8 bit supported.\n", pSps->uiBitDepthChroma); | ||
| 786 | return GENERATE_ERROR_NO(ERR_LEVEL_PARAM_SETS, ERR_INFO_UNSUPPORTED_NON_BASELINE); | ||
| 787 | } | ||
| 788 | pSps->bQpPrimeYZeroTransfBypassFlag = !!BsGetOneBit( pBs ); | ||
| 789 | pSps->bSeqScalingMatrixPresentFlag = !!BsGetOneBit( pBs ); | ||
| 790 | |||
| 791 | if ( pSps->bSeqScalingMatrixPresentFlag ){ // For high profile, it is not used in current application. FIXME | ||
| 792 | WelsLog( pCtx, WELS_LOG_WARNING, "ParseSps(): seq_scaling_matrix_present_flag (%d). Feature not supported.\n", pSps->bSeqScalingMatrixPresentFlag); | ||
| 793 | return GENERATE_ERROR_NO(ERR_LEVEL_PARAM_SETS, ERR_INFO_UNSUPPORTED_NON_BASELINE); | ||
| 794 | } | ||
| 795 | } | ||
| 796 | |||
| 797 | pSps->uiLog2MaxFrameNum = 4 + BsGetUe( pBs ); // log2_max_frame_num_minus4 | ||
| 798 | pSps->uiPocType = BsGetUe( pBs ); // pic_order_cnt_type | ||
| 799 | |||
| 800 | if ( 0 == pSps->uiPocType ) | ||
| 801 | { | ||
| 802 | pSps->iLog2MaxPocLsb = 4 + BsGetUe( pBs ); // log2_max_pic_order_cnt_lsb_minus4 | ||
| 803 | |||
| 804 | } | ||
| 805 | else if ( 1 == pSps->uiPocType ) | ||
| 806 | { | ||
| 807 | int32_t i; | ||
| 808 | pSps->bDeltaPicOrderAlwaysZeroFlag = !!BsGetOneBit( pBs ); // bDeltaPicOrderAlwaysZeroFlag | ||
| 809 | pSps->iOffsetForNonRefPic = BsGetSe( pBs ); // iOffsetForNonRefPic | ||
| 810 | pSps->iOffsetForTopToBottomField = BsGetSe( pBs ); // iOffsetForTopToBottomField | ||
| 811 | pSps->iNumRefFramesInPocCycle = BsGetUe( pBs ); // num_ref_frames_in_pic_order_cnt_cycle | ||
| 812 | for( i = 0; i < pSps->iNumRefFramesInPocCycle; i++ ) | ||
| 813 | pSps->iOffsetForRefFrame[ i ] = BsGetSe( pBs ); // iOffsetForRefFrame[ i ] | ||
| 814 | } | ||
| 815 | if ( pSps->uiPocType > 2 ) | ||
| 816 | { | ||
| 817 | WelsLog( pCtx, WELS_LOG_WARNING, " illegal pic_order_cnt_type: %d ! \n", pSps->uiPocType ); | ||
| 818 | return GENERATE_ERROR_NO(ERR_LEVEL_PARAM_SETS, ERR_INFO_INVALID_POC_TYPE); | ||
| 819 | } | ||
| 820 | |||
| 821 | pSps->iNumRefFrames = BsGetUe( pBs ); // max_num_ref_frames | ||
| 822 | pSps->bGapsInFrameNumValueAllowedFlag = !!BsGetOneBit( pBs ); // bGapsInFrameNumValueAllowedFlag | ||
| 823 | pSps->iMbWidth = 1 + BsGetUe( pBs ); // pic_width_in_mbs_minus1 | ||
| 824 | pSps->iMbHeight = 1 + BsGetUe( pBs ); // pic_height_in_map_units_minus1 | ||
| 825 | pSps->uiTotalMbCount = pSps->iMbWidth * pSps->iMbHeight; | ||
| 826 | pSps->bFrameMbsOnlyFlag = !!BsGetOneBit( pBs ); // frame_mbs_only_flag | ||
| 827 | |||
| 828 | if ( !pSps->bFrameMbsOnlyFlag ) | ||
| 829 | { | ||
| 830 | WelsLog( pCtx, WELS_LOG_WARNING, "ParseSps(): frame_mbs_only_flag (%d) not supported.\n", pSps->bFrameMbsOnlyFlag); | ||
| 831 | return GENERATE_ERROR_NO(ERR_LEVEL_PARAM_SETS, ERR_INFO_UNSUPPORTED_MBAFF); | ||
| 832 | } | ||
| 833 | pSps->bDirect8x8InferenceFlag = !!BsGetOneBit( pBs ); // direct_8x8_inference_flag | ||
| 834 | pSps->bFrameCroppingFlag = !!BsGetOneBit( pBs ); // frame_cropping_flag | ||
| 835 | if ( pSps->bFrameCroppingFlag ) | ||
| 836 | { | ||
| 837 | pSps->sFrameCrop.iLeftOffset = BsGetUe( pBs ); // frame_crop_left_offset | ||
| 838 | pSps->sFrameCrop.iRightOffset = BsGetUe( pBs ); // frame_crop_right_offset | ||
| 839 | pSps->sFrameCrop.iTopOffset = BsGetUe( pBs ); // frame_crop_top_offset | ||
| 840 | pSps->sFrameCrop.iBottomOffset = BsGetUe( pBs ); // frame_crop_bottom_offset | ||
| 841 | } | ||
| 842 | else | ||
| 843 | { | ||
| 844 | pSps->sFrameCrop.iLeftOffset = 0; // frame_crop_left_offset | ||
| 845 | pSps->sFrameCrop.iRightOffset = 0; // frame_crop_right_offset | ||
| 846 | pSps->sFrameCrop.iTopOffset = 0; // frame_crop_top_offset | ||
| 847 | pSps->sFrameCrop.iBottomOffset = 0; // frame_crop_bottom_offset | ||
| 848 | } | ||
| 849 | pSps->bVuiParamPresentFlag = !!BsGetOneBit( pBs ); // vui_parameters_present_flag | ||
| 850 | |||
| 851 | // Check if SPS SVC extension applicated | ||
| 852 | if ( kbUseSubsetFlag && ( PRO_SCALABLE_BASELINE == uiProfileIdc || PRO_SCALABLE_HIGH == uiProfileIdc ) ) | ||
| 853 | { | ||
| 854 | if ( DecodeSpsSvcExt( pCtx, pSubsetSps, pBs ) != ERR_NONE ){ | ||
| 855 | return -1; | ||
| 856 | } | ||
| 857 | |||
| 858 | pSubsetSps->bSvcVuiParamPresentFlag = !!BsGetOneBit( pBs ); | ||
| 859 | if ( pSubsetSps->bSvcVuiParamPresentFlag ){ | ||
| 860 | } | ||
| 861 | } | ||
| 862 | |||
| 863 | |||
| 864 | if ( PRO_SCALABLE_BASELINE == uiProfileIdc || PRO_SCALABLE_HIGH == uiProfileIdc ) | ||
| 865 | pCtx->bAvcBasedFlag = false; | ||
| 866 | else | ||
| 867 | pCtx->bAvcBasedFlag = true; // added for avc base pBs | ||
| 868 | |||
| 869 | *pPicWidth = pSps->iMbWidth << 4; | ||
| 870 | *pPicHeight = pSps->iMbHeight << 4; | ||
| 871 | |||
| 872 | return 0; | ||
| 873 | } | ||
| 874 | |||
| 875 | /*! | ||
| 876 | ************************************************************************************* | ||
| 877 | * \brief to parse Picture Parameter Set (PPS) | ||
| 878 | * | ||
| 879 | * \param pCtx Decoder context | ||
| 880 | * \param pPpsList pps list | ||
| 881 | * \param pBsAux bitstream reader auxiliary | ||
| 882 | * | ||
| 883 | * \return 0 - successed | ||
| 884 | * 1 - failed | ||
| 885 | * | ||
| 886 | * \note Call it in case eNalUnitType is PPS. | ||
| 887 | ************************************************************************************* | ||
| 888 | */ | ||
| 889 | int32_t ParsePps( PWelsDecoderContext pCtx, PPps pPpsList, PBitStringAux pBsAux ) | ||
| 890 | { | ||
| 891 | |||
| 892 | PPps pPps = NULL; | ||
| 893 | uint32_t uiPpsId = 0; | ||
| 894 | uint32_t iTmp; | ||
| 895 | |||
| 896 | uiPpsId = BsGetUe(pBsAux); | ||
| 897 | if ( uiPpsId >= MAX_PPS_COUNT ) | ||
| 898 | { | ||
| 899 | return ERR_INFO_PPS_ID_OVERFLOW; | ||
| 900 | } | ||
| 901 | |||
| 902 | #ifdef MOSAIC_AVOID_BASED_ON_SPS_PPS_ID | ||
| 903 | pPps = &pPpsList[pCtx->iPpsTotalNum]; | ||
| 904 | #else | ||
| 905 | pPps = &pPpsList[uiPpsId]; | ||
| 906 | #endif //MOSAIC_AVOID_BASED_ON_SPS_PPS_ID | ||
| 907 | |||
| 908 | |||
| 909 | pPps->iPpsId = uiPpsId; | ||
| 910 | pPps->iSpsId = BsGetUe(pBsAux); | ||
| 911 | |||
| 912 | if (pPps->iSpsId >= MAX_SPS_COUNT) | ||
| 913 | { | ||
| 914 | return ERR_INFO_SPS_ID_OVERFLOW; | ||
| 915 | } | ||
| 916 | |||
| 917 | pPps->bEntropyCodingModeFlag = !!BsGetOneBit(pBsAux); | ||
| 918 | pPps->bPicOrderPresentFlag = !!BsGetOneBit(pBsAux); | ||
| 919 | |||
| 920 | pPps->uiNumSliceGroups = 1 + BsGetUe(pBsAux); | ||
| 921 | |||
| 922 | if (pPps->uiNumSliceGroups > MAX_SLICEGROUP_IDS) | ||
| 923 | { | ||
| 924 | return ERR_INFO_INVALID_SLICEGROUP; | ||
| 925 | } | ||
| 926 | |||
| 927 | if (pPps->uiNumSliceGroups > 1) | ||
| 928 | { | ||
| 929 | pPps->uiSliceGroupMapType = BsGetUe(pBsAux); | ||
| 930 | if( pPps->uiSliceGroupMapType > 1) | ||
| 931 | { | ||
| 932 | WelsLog( pCtx, WELS_LOG_WARNING, "ParsePps(): slice_group_map_type (%d): support only 0,1.\n", pPps->uiSliceGroupMapType); | ||
| 933 | return GENERATE_ERROR_NO(ERR_LEVEL_PARAM_SETS, ERR_INFO_UNSUPPORTED_FMOTYPE); | ||
| 934 | } | ||
| 935 | |||
| 936 | switch(pPps->uiSliceGroupMapType) | ||
| 937 | { | ||
| 938 | case 0: | ||
| 939 | for (iTmp = 0; iTmp < pPps->uiNumSliceGroups; iTmp++) | ||
| 940 | { | ||
| 941 | pPps->uiRunLength[iTmp] = 1 + BsGetUe(pBsAux); | ||
| 942 | } | ||
| 943 | break; | ||
| 944 | default: | ||
| 945 | break; | ||
| 946 | } | ||
| 947 | } | ||
| 948 | |||
| 949 | pPps->uiNumRefIdxL0Active = 1 + BsGetUe(pBsAux); | ||
| 950 | pPps->uiNumRefIdxL1Active = 1 + BsGetUe(pBsAux); | ||
| 951 | |||
| 952 | if (pPps->uiNumRefIdxL0Active > MAX_REF_PIC_COUNT || | ||
| 953 | pPps->uiNumRefIdxL1Active > MAX_REF_PIC_COUNT) | ||
| 954 | { | ||
| 955 | return ERR_INFO_REF_COUNT_OVERFLOW; | ||
| 956 | } | ||
| 957 | |||
| 958 | pPps->bWeightedPredFlag = !!BsGetOneBit(pBsAux); | ||
| 959 | pPps->uiWeightedBipredIdc = BsGetBits(pBsAux, 2); | ||
| 960 | if( pPps->bWeightedPredFlag || pPps->uiWeightedBipredIdc != 0 ) | ||
| 961 | { | ||
| 962 | WelsLog( pCtx, WELS_LOG_WARNING, "ParsePps(): weighted_pred_flag (%d) weighted_bipred_idc (%d) neither supported.\n", pPps->bWeightedPredFlag, pPps->uiWeightedBipredIdc); | ||
| 963 | return GENERATE_ERROR_NO(ERR_LEVEL_PARAM_SETS, ERR_INFO_UNSUPPORTED_WP); | ||
| 964 | } | ||
| 965 | |||
| 966 | pPps->iPicInitQp = 26 + BsGetSe(pBsAux); | ||
| 967 | pPps->iPicInitQs = 26 + BsGetSe(pBsAux); | ||
| 968 | |||
| 969 | pPps->iChromaQpIndexOffset = BsGetSe(pBsAux); | ||
| 970 | pPps->bDeblockingFilterControlPresentFlag = !!BsGetOneBit(pBsAux); | ||
| 971 | pPps->bConstainedIntraPredFlag = !!BsGetOneBit(pBsAux); | ||
| 972 | pPps->bRedundantPicCntPresentFlag = !!BsGetOneBit(pBsAux); | ||
| 973 | |||
| 974 | |||
| 975 | #ifdef MOSAIC_AVOID_BASED_ON_SPS_PPS_ID | ||
| 976 | pCtx->bPpsAvailFlags[pCtx->iPpsTotalNum] = true; | ||
| 977 | ++pCtx->iPpsTotalNum; | ||
| 978 | #else | ||
| 979 | pCtx->bPpsAvailFlags[uiPpsId] = true; // added for EC, 10/28/2009 | ||
| 980 | #endif //MOSAIC_AVOID_BASED_ON_SPS_PPS_ID | ||
| 981 | |||
| 982 | return ERR_NONE; | ||
| 983 | } | ||
| 984 | |||
| 985 | /*! | ||
| 986 | ************************************************************************************* | ||
| 987 | * \brief to parse SEI message payload | ||
| 988 | * | ||
| 989 | * \param pSei sei message to be parsed output | ||
| 990 | * \param pBsAux bitstream reader auxiliary | ||
| 991 | * | ||
| 992 | * \return 0 - successed | ||
| 993 | * 1 - failed | ||
| 994 | * | ||
| 995 | * \note Call it in case eNalUnitType is NAL_UNIT_SEI. | ||
| 996 | ************************************************************************************* | ||
| 997 | */ | ||
| 998 | int32_t ParseSei( void_t *pSei, PBitStringAux pBsAux ) // reserved Sei_Msg type | ||
| 999 | { | ||
| 1000 | |||
| 1001 | |||
| 1002 | return ERR_NONE; | ||
| 1003 | } | ||
| 1004 | |||
| 1005 | /*! | ||
| 1006 | ************************************************************************************* | ||
| 1007 | * \brief reset fmo list due to got Sps now | ||
| 1008 | * | ||
| 1009 | * \param pCtx decoder context | ||
| 1010 | * | ||
| 1011 | * \return count number of fmo context units are reset | ||
| 1012 | ************************************************************************************* | ||
| 1013 | */ | ||
| 1014 | int32_t ResetFmoList( PWelsDecoderContext pCtx ) | ||
| 1015 | { | ||
| 1016 | int32_t iCountNum = 0; | ||
| 1017 | if ( NULL != pCtx ) | ||
| 1018 | { | ||
| 1019 | // Fixed memory leak due to PPS_ID might not be continuous sometimes, 1/5/2010 | ||
| 1020 | UninitFmoList( &pCtx->sFmoList[0], MAX_PPS_COUNT, pCtx->iActiveFmoNum ); | ||
| 1021 | iCountNum = pCtx->iActiveFmoNum; | ||
| 1022 | pCtx->iActiveFmoNum = 0; | ||
| 1023 | } | ||
| 1024 | return iCountNum; | ||
| 1025 | } | ||
| 1026 | |||
| 1027 | } // namespace WelsDec | ||