| /* |
| * Copyright (C) 2009 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| /*------------------------------------------------------------------------------ |
| |
| Table of contents |
| |
| 1. Include headers |
| 2. External compiler flags |
| 3. Module defines |
| 4. Local function prototypes |
| 5. Functions |
| h264bsdDecodeSeiMessage |
| DecodeBufferingPeriod |
| DecodePictureTiming |
| DecodePanScanRectangle |
| DecodeFillerPayload |
| DecodeUserDataRegisteredITuTT35 |
| DecodeUserDataUnregistered |
| DecodeRecoveryPoint |
| DecodeDecRefPicMarkingRepetition |
| DecodeSparePic |
| DecodeSceneInfo |
| DecodeSubSeqInfo |
| DecodeSubSeqLayerCharacteristics |
| DecodeSubSeqCharacteristics |
| DecodeFullFrameFreeze |
| DecodeFullFrameSnapshot |
| DecodeProgressiveRefinementSegmentStart |
| DecodeProgressiveRefinementSegmentEnd |
| DecodeMotionConstrainedSliceGroupSet |
| DecodeReservedSeiMessage |
| |
| ------------------------------------------------------------------------------*/ |
| |
| /*------------------------------------------------------------------------------ |
| 1. Include headers |
| ------------------------------------------------------------------------------*/ |
| |
| #include "h264bsd_sei.h" |
| #include "basetype.h" |
| #include "h264bsd_util.h" |
| #include "h264bsd_stream.h" |
| #include "h264bsd_vlc.h" |
| #include "h264bsd_seq_param_set.h" |
| #include "h264bsd_slice_header.h" |
| |
| /*------------------------------------------------------------------------------ |
| 2. External compiler flags |
| -------------------------------------------------------------------------------- |
| |
| -------------------------------------------------------------------------------- |
| 3. Module defines |
| ------------------------------------------------------------------------------*/ |
| |
| static const u32 numClockTS[9] = {1,1,1,2,2,3,3,2,3}; |
| static const u32 ceilLog2NumSliceGroups[9] = {0,1,1,2,2,3,3,3,3}; |
| |
| /*------------------------------------------------------------------------------ |
| 4. Local function prototypes |
| ------------------------------------------------------------------------------*/ |
| |
| static u32 DecodeBufferingPeriod( |
| strmData_t *pStrmData, |
| seiBufferingPeriod_t *pBufferingPeriod, |
| u32 cpbCnt, |
| u32 initialCpbRemovalDelayLength, |
| u32 nalHrdBpPresentFlag, |
| u32 vclHrdBpPresentFlag); |
| |
| static u32 DecodePictureTiming( |
| strmData_t *pStrmData, |
| seiPicTiming_t *pPicTiming, |
| u32 cpbRemovalDelayLength, |
| u32 dpbOutputDelayLength, |
| u32 timeOffsetLength, |
| u32 cpbDpbDelaysPresentFlag, |
| u32 picStructPresentFlag); |
| |
| static u32 DecodePanScanRectangle( |
| strmData_t *pStrmData, |
| seiPanScanRect_t *pPanScanRectangle); |
| |
| static u32 DecodeFillerPayload(strmData_t *pStrmData, u32 payloadSize); |
| |
| static u32 DecodeUserDataRegisteredITuTT35( |
| strmData_t *pStrmData, |
| seiUserDataRegisteredItuTT35_t *pUserDataRegisteredItuTT35, |
| u32 payloadSize); |
| |
| static u32 DecodeUserDataUnregistered( |
| strmData_t *pStrmData, |
| seiUserDataUnregistered_t *pUserDataUnregistered, |
| u32 payloadSize); |
| |
| static u32 DecodeRecoveryPoint( |
| strmData_t *pStrmData, |
| seiRecoveryPoint_t *pRecoveryPoint); |
| |
| static u32 DecodeDecRefPicMarkingRepetition( |
| strmData_t *pStrmData, |
| seiDecRefPicMarkingRepetition_t *pDecRefPicMarkingRepetition, |
| u32 numRefFrames); |
| |
| static u32 DecodeSparePic( |
| strmData_t *pStrmData, |
| seiSparePic_t *pSparePic, |
| u32 picSizeInMapUnits); |
| |
| static u32 DecodeSceneInfo( |
| strmData_t *pStrmData, |
| seiSceneInfo_t *pSceneInfo); |
| |
| static u32 DecodeSubSeqInfo( |
| strmData_t *pStrmData, |
| seiSubSeqInfo_t *pSubSeqInfo); |
| |
| static u32 DecodeSubSeqLayerCharacteristics( |
| strmData_t *pStrmData, |
| seiSubSeqLayerCharacteristics_t *pSubSeqLayerCharacteristics); |
| |
| static u32 DecodeSubSeqCharacteristics( |
| strmData_t *pStrmData, |
| seiSubSeqCharacteristics_t *pSubSeqCharacteristics); |
| |
| static u32 DecodeFullFrameFreeze( |
| strmData_t *pStrmData, |
| seiFullFrameFreeze_t *pFullFrameFreeze); |
| |
| static u32 DecodeFullFrameSnapshot( |
| strmData_t *pStrmData, |
| seiFullFrameSnapshot_t *pFullFrameSnapshot); |
| |
| static u32 DecodeProgressiveRefinementSegmentStart( |
| strmData_t *pStrmData, |
| seiProgressiveRefinementSegmentStart_t *pProgressiveRefinementSegmentStart); |
| |
| static u32 DecodeProgressiveRefinementSegmentEnd( |
| strmData_t *pStrmData, |
| seiProgressiveRefinementSegmentEnd_t *pProgressiveRefinementSegmentEnd); |
| |
| static u32 DecodeMotionConstrainedSliceGroupSet( |
| strmData_t *pStrmData, |
| seiMotionConstrainedSliceGroupSet_t *pMotionConstrainedSliceGroupSet, |
| u32 numSliceGroups); |
| |
| static u32 DecodeReservedSeiMessage( |
| strmData_t *pStrmData, |
| seiReservedSeiMessage_t *pReservedSeiMessage, |
| u32 payloadSize); |
| |
| /*------------------------------------------------------------------------------ |
| |
| Function: h264bsdDecodeSeiMessage |
| |
| Functional description: |
| <++> |
| Inputs: |
| <++> |
| Outputs: |
| <++> |
| |
| ------------------------------------------------------------------------------*/ |
| |
| u32 h264bsdDecodeSeiMessage( |
| strmData_t *pStrmData, |
| seqParamSet_t *pSeqParamSet, |
| seiMessage_t *pSeiMessage, |
| u32 numSliceGroups) |
| { |
| |
| /* Variables */ |
| |
| u32 tmp, payloadType, payloadSize, status; |
| |
| /* Code */ |
| |
| ASSERT(pStrmData); |
| ASSERT(pSeiMessage); |
| |
| |
| H264SwDecMemset(pSeiMessage, 0, sizeof(seiMessage_t)); |
| |
| do |
| { |
| payloadType = 0; |
| while((tmp = h264bsdGetBits(pStrmData, 8)) == 0xFF) |
| { |
| payloadType += 255; |
| } |
| if (tmp == END_OF_STREAM) |
| return(HANTRO_NOK); |
| payloadType += tmp; |
| |
| payloadSize = 0; |
| while((tmp = h264bsdGetBits(pStrmData, 8)) == 0xFF) |
| { |
| payloadSize += 255; |
| } |
| if (tmp == END_OF_STREAM) |
| return(HANTRO_NOK); |
| payloadSize += tmp; |
| |
| pSeiMessage->payloadType = payloadType; |
| |
| switch (payloadType) |
| { |
| case 0: |
| ASSERT(pSeqParamSet); |
| status = DecodeBufferingPeriod( |
| pStrmData, |
| &pSeiMessage->bufferingPeriod, |
| pSeqParamSet->vuiParameters->vclHrdParameters.cpbCnt, |
| pSeqParamSet->vuiParameters->vclHrdParameters. |
| initialCpbRemovalDelayLength, |
| pSeqParamSet->vuiParameters->nalHrdParametersPresentFlag, |
| pSeqParamSet->vuiParameters->vclHrdParametersPresentFlag); |
| break; |
| |
| case 1: |
| ASSERT(pSeqParamSet->vuiParametersPresentFlag); |
| status = DecodePictureTiming( |
| pStrmData, |
| &pSeiMessage->picTiming, |
| pSeqParamSet->vuiParameters->vclHrdParameters. |
| cpbRemovalDelayLength, |
| pSeqParamSet->vuiParameters->vclHrdParameters. |
| dpbOutputDelayLength, |
| pSeqParamSet->vuiParameters->vclHrdParameters. |
| timeOffsetLength, |
| pSeqParamSet->vuiParameters->nalHrdParametersPresentFlag || |
| pSeqParamSet->vuiParameters->vclHrdParametersPresentFlag ? |
| HANTRO_TRUE : HANTRO_FALSE, |
| pSeqParamSet->vuiParameters->picStructPresentFlag); |
| break; |
| |
| case 2: |
| status = DecodePanScanRectangle( |
| pStrmData, |
| &pSeiMessage->panScanRect); |
| break; |
| |
| case 3: |
| status = DecodeFillerPayload(pStrmData, payloadSize); |
| break; |
| |
| case 4: |
| status = DecodeUserDataRegisteredITuTT35( |
| pStrmData, |
| &pSeiMessage->userDataRegisteredItuTT35, |
| payloadSize); |
| break; |
| |
| case 5: |
| status = DecodeUserDataUnregistered( |
| pStrmData, |
| &pSeiMessage->userDataUnregistered, |
| payloadSize); |
| break; |
| |
| case 6: |
| status = DecodeRecoveryPoint( |
| pStrmData, |
| &pSeiMessage->recoveryPoint); |
| break; |
| |
| case 7: |
| status = DecodeDecRefPicMarkingRepetition( |
| pStrmData, |
| &pSeiMessage->decRefPicMarkingRepetition, |
| pSeqParamSet->numRefFrames); |
| break; |
| |
| case 8: |
| ASSERT(pSeqParamSet); |
| status = DecodeSparePic( |
| pStrmData, |
| &pSeiMessage->sparePic, |
| pSeqParamSet->picWidthInMbs * pSeqParamSet->picHeightInMbs); |
| break; |
| |
| case 9: |
| status = DecodeSceneInfo( |
| pStrmData, |
| &pSeiMessage->sceneInfo); |
| break; |
| |
| case 10: |
| status = DecodeSubSeqInfo( |
| pStrmData, |
| &pSeiMessage->subSeqInfo); |
| break; |
| |
| case 11: |
| status = DecodeSubSeqLayerCharacteristics( |
| pStrmData, |
| &pSeiMessage->subSeqLayerCharacteristics); |
| break; |
| |
| case 12: |
| status = DecodeSubSeqCharacteristics( |
| pStrmData, |
| &pSeiMessage->subSeqCharacteristics); |
| break; |
| |
| case 13: |
| status = DecodeFullFrameFreeze( |
| pStrmData, |
| &pSeiMessage->fullFrameFreeze); |
| break; |
| |
| case 14: /* This SEI does not contain data, what to do ??? */ |
| status = HANTRO_OK; |
| break; |
| |
| case 15: |
| status = DecodeFullFrameSnapshot( |
| pStrmData, |
| &pSeiMessage->fullFrameSnapshot); |
| break; |
| |
| case 16: |
| status = DecodeProgressiveRefinementSegmentStart( |
| pStrmData, |
| &pSeiMessage->progressiveRefinementSegmentStart); |
| break; |
| |
| case 17: |
| status = DecodeProgressiveRefinementSegmentEnd( |
| pStrmData, |
| &pSeiMessage->progressiveRefinementSegmentEnd); |
| break; |
| |
| case 18: |
| ASSERT(numSliceGroups); |
| status = DecodeMotionConstrainedSliceGroupSet( |
| pStrmData, |
| &pSeiMessage->motionConstrainedSliceGroupSet, |
| numSliceGroups); |
| break; |
| |
| default: |
| status = DecodeReservedSeiMessage( |
| pStrmData, |
| &pSeiMessage->reservedSeiMessage, |
| payloadSize); |
| break; |
| } |
| |
| if (status != HANTRO_OK) |
| return(status); |
| |
| while (!h264bsdIsByteAligned(pStrmData)) |
| { |
| if (h264bsdGetBits(pStrmData, 1) != 1) |
| return(HANTRO_NOK); |
| while (!h264bsdIsByteAligned(pStrmData)) |
| { |
| if (h264bsdGetBits(pStrmData, 1) != 0) |
| return(HANTRO_NOK); |
| } |
| } |
| } while (h264bsdMoreRbspData(pStrmData)); |
| |
| return(h264bsdRbspTrailingBits(pStrmData)); |
| |
| } |
| |
| /*------------------------------------------------------------------------------ |
| |
| Function: DecodeBufferingPeriod |
| |
| Functional description: |
| <++> |
| Inputs: |
| <++> |
| Outputs: |
| <++> |
| |
| ------------------------------------------------------------------------------*/ |
| |
| static u32 DecodeBufferingPeriod( |
| strmData_t *pStrmData, |
| seiBufferingPeriod_t *pBufferingPeriod, |
| u32 cpbCnt, |
| u32 initialCpbRemovalDelayLength, |
| u32 nalHrdBpPresentFlag, |
| u32 vclHrdBpPresentFlag) |
| { |
| |
| /* Variables */ |
| |
| u32 tmp, i; |
| |
| /* Code */ |
| |
| ASSERT(pStrmData); |
| ASSERT(pBufferingPeriod); |
| ASSERT(cpbCnt); |
| ASSERT(initialCpbRemovalDelayLength); |
| |
| |
| tmp = h264bsdDecodeExpGolombUnsigned(pStrmData, |
| &pBufferingPeriod->seqParameterSetId); |
| if (tmp != HANTRO_OK) |
| return(tmp); |
| if (pBufferingPeriod->seqParameterSetId > 31) |
| return(HANTRO_NOK); |
| |
| if (nalHrdBpPresentFlag) |
| { |
| for (i = 0; i < cpbCnt; i++) |
| { |
| tmp = h264bsdGetBits(pStrmData, initialCpbRemovalDelayLength); |
| if (tmp == END_OF_STREAM) |
| return(HANTRO_NOK); |
| if (tmp == 0) |
| return(HANTRO_NOK); |
| pBufferingPeriod->initialCpbRemovalDelay[i] = tmp; |
| |
| tmp = h264bsdGetBits(pStrmData, initialCpbRemovalDelayLength); |
| if (tmp == END_OF_STREAM) |
| return(HANTRO_NOK); |
| pBufferingPeriod->initialCpbRemovalDelayOffset[i] = tmp; |
| } |
| } |
| |
| if (vclHrdBpPresentFlag) |
| { |
| for (i = 0; i < cpbCnt; i++) |
| { |
| tmp = h264bsdGetBits(pStrmData, initialCpbRemovalDelayLength); |
| if (tmp == END_OF_STREAM) |
| return(HANTRO_NOK); |
| pBufferingPeriod->initialCpbRemovalDelay[i] = tmp; |
| |
| tmp = h264bsdGetBits(pStrmData, initialCpbRemovalDelayLength); |
| if (tmp == END_OF_STREAM) |
| return(HANTRO_NOK); |
| pBufferingPeriod->initialCpbRemovalDelayOffset[i] = tmp; |
| } |
| } |
| |
| return(HANTRO_OK); |
| |
| } |
| |
| /*------------------------------------------------------------------------------ |
| |
| Function: DecodePictureTiming |
| |
| Functional description: |
| <++> |
| Inputs: |
| <++> |
| Outputs: |
| <++> |
| |
| ------------------------------------------------------------------------------*/ |
| |
| static u32 DecodePictureTiming( |
| strmData_t *pStrmData, |
| seiPicTiming_t *pPicTiming, |
| u32 cpbRemovalDelayLength, |
| u32 dpbOutputDelayLength, |
| u32 timeOffsetLength, |
| u32 cpbDpbDelaysPresentFlag, |
| u32 picStructPresentFlag) |
| { |
| |
| /* Variables */ |
| |
| u32 tmp, i; |
| i32 itmp; |
| |
| /* Code */ |
| |
| ASSERT(pStrmData); |
| ASSERT(pPicTiming); |
| |
| |
| if (cpbDpbDelaysPresentFlag) |
| { |
| tmp = h264bsdGetBits(pStrmData, cpbRemovalDelayLength); |
| if (tmp == END_OF_STREAM) |
| return(HANTRO_NOK); |
| pPicTiming->cpbRemovalDelay = tmp; |
| |
| tmp = h264bsdGetBits(pStrmData, dpbOutputDelayLength); |
| if (tmp == END_OF_STREAM) |
| return(HANTRO_NOK); |
| pPicTiming->dpbOutputDelay = tmp; |
| } |
| |
| if (picStructPresentFlag) |
| { |
| tmp = h264bsdGetBits(pStrmData, 4); |
| if (tmp == END_OF_STREAM) |
| return(HANTRO_NOK); |
| if (tmp > 8) |
| return(HANTRO_NOK); |
| pPicTiming->picStruct = tmp; |
| |
| for (i = 0; i < numClockTS[pPicTiming->picStruct]; i++) |
| { |
| tmp = h264bsdGetBits(pStrmData, 1); |
| if (tmp == END_OF_STREAM) |
| return(HANTRO_NOK); |
| pPicTiming->clockTimeStampFlag[i] = tmp == 1 ? |
| HANTRO_TRUE : HANTRO_FALSE; |
| |
| if (pPicTiming->clockTimeStampFlag[i]) |
| { |
| tmp = h264bsdGetBits(pStrmData, 2); |
| if (tmp == END_OF_STREAM) |
| return(HANTRO_NOK); |
| pPicTiming->ctType[i] = tmp; |
| |
| tmp = h264bsdGetBits(pStrmData, 1); |
| if (tmp == END_OF_STREAM) |
| return(HANTRO_NOK); |
| pPicTiming->nuitFieldBasedFlag[i] = tmp == 1 ? |
| HANTRO_TRUE : HANTRO_FALSE; |
| |
| tmp = h264bsdGetBits(pStrmData, 5); |
| if (tmp == END_OF_STREAM) |
| return(HANTRO_NOK); |
| if (tmp > 6) |
| return(HANTRO_NOK); |
| pPicTiming->countingType[i] = tmp; |
| |
| tmp = h264bsdGetBits(pStrmData, 1); |
| if (tmp == END_OF_STREAM) |
| return(HANTRO_NOK); |
| pPicTiming->fullTimeStampFlag[i] = tmp == 1 ? |
| HANTRO_TRUE : HANTRO_FALSE; |
| |
| tmp = h264bsdGetBits(pStrmData, 1); |
| if (tmp == END_OF_STREAM) |
| return(HANTRO_NOK); |
| pPicTiming->discontinuityFlag[i] = tmp == 1 ? |
| HANTRO_TRUE : HANTRO_FALSE; |
| |
| tmp = h264bsdGetBits(pStrmData, 1); |
| if (tmp == END_OF_STREAM) |
| return(HANTRO_NOK); |
| pPicTiming->cntDroppedFlag[i] = tmp == 1 ? |
| HANTRO_TRUE : HANTRO_FALSE; |
| |
| tmp = h264bsdGetBits(pStrmData, 8); |
| if (tmp == END_OF_STREAM) |
| return(HANTRO_NOK); |
| pPicTiming->nFrames[i] = tmp; |
| |
| if (pPicTiming->fullTimeStampFlag[i]) |
| { |
| tmp = h264bsdGetBits(pStrmData, 6); |
| if (tmp == END_OF_STREAM) |
| return(HANTRO_NOK); |
| if (tmp > 59) |
| return(HANTRO_NOK); |
| pPicTiming->secondsValue[i] = tmp; |
| |
| tmp = h264bsdGetBits(pStrmData, 6); |
| if (tmp == END_OF_STREAM) |
| return(HANTRO_NOK); |
| if (tmp > 59) |
| return(HANTRO_NOK); |
| pPicTiming->minutesValue[i] = tmp; |
| |
| tmp = h264bsdGetBits(pStrmData, 5); |
| if (tmp == END_OF_STREAM) |
| return(HANTRO_NOK); |
| if (tmp > 23) |
| return(HANTRO_NOK); |
| pPicTiming->hoursValue[i] = tmp; |
| } |
| else |
| { |
| tmp = h264bsdGetBits(pStrmData, 1); |
| if (tmp == END_OF_STREAM) |
| return(HANTRO_NOK); |
| pPicTiming->secondsFlag[i] = tmp == 1 ? |
| HANTRO_TRUE : HANTRO_FALSE; |
| |
| if (pPicTiming->secondsFlag[i]) |
| { |
| tmp = h264bsdGetBits(pStrmData, 6); |
| if (tmp == END_OF_STREAM) |
| return(HANTRO_NOK); |
| if (tmp > 59) |
| return(HANTRO_NOK); |
| pPicTiming->secondsValue[i] = tmp; |
| |
| tmp = h264bsdGetBits(pStrmData, 1); |
| if (tmp == END_OF_STREAM) |
| return(HANTRO_NOK); |
| pPicTiming->minutesFlag[i] = tmp == 1 ? |
| HANTRO_TRUE : HANTRO_FALSE; |
| |
| if (pPicTiming->minutesFlag[i]) |
| { |
| tmp = h264bsdGetBits(pStrmData, 6); |
| if (tmp == END_OF_STREAM) |
| return(HANTRO_NOK); |
| if (tmp > 59) |
| return(HANTRO_NOK); |
| pPicTiming->minutesValue[i] = tmp; |
| |
| tmp = h264bsdGetBits(pStrmData, 1); |
| if (tmp == END_OF_STREAM) |
| return(HANTRO_NOK); |
| pPicTiming->hoursFlag[i] = tmp == 1 ? |
| HANTRO_TRUE : HANTRO_FALSE; |
| |
| if (pPicTiming->hoursFlag[i]) |
| { |
| tmp = h264bsdGetBits(pStrmData, 5); |
| if (tmp == END_OF_STREAM) |
| return(HANTRO_NOK); |
| if (tmp > 23) |
| return(HANTRO_NOK); |
| pPicTiming->hoursValue[i] = tmp; |
| } |
| } |
| } |
| } |
| if (timeOffsetLength) |
| { |
| tmp = h264bsdGetBits(pStrmData, timeOffsetLength); |
| if (tmp == END_OF_STREAM) |
| return(HANTRO_NOK); |
| itmp = (i32)tmp; |
| /* following "converts" timeOffsetLength-bit signed |
| * integer into i32 */ |
| /*lint -save -e701 -e702 */ |
| itmp <<= (32 - timeOffsetLength); |
| itmp >>= (32 - timeOffsetLength); |
| /*lint -restore */ |
| pPicTiming->timeOffset[i] = itmp; |
| } |
| else |
| pPicTiming->timeOffset[i] = 0; |
| } |
| } |
| } |
| |
| return(HANTRO_OK); |
| |
| } |
| |
| /*------------------------------------------------------------------------------ |
| |
| Function: DecodePanScanRectangle |
| |
| Functional description: |
| <++> |
| Inputs: |
| <++> |
| Outputs: |
| <++> |
| |
| ------------------------------------------------------------------------------*/ |
| |
| static u32 DecodePanScanRectangle( |
| strmData_t *pStrmData, |
| seiPanScanRect_t *pPanScanRectangle) |
| { |
| |
| /* Variables */ |
| |
| u32 tmp, i; |
| |
| /* Code */ |
| |
| ASSERT(pStrmData); |
| ASSERT(pPanScanRectangle); |
| |
| |
| tmp = h264bsdDecodeExpGolombUnsigned(pStrmData, |
| &pPanScanRectangle->panScanRectId); |
| if (tmp != HANTRO_OK) |
| return(tmp); |
| |
| tmp = h264bsdGetBits(pStrmData, 1); |
| if (tmp == END_OF_STREAM) |
| return(HANTRO_NOK); |
| pPanScanRectangle->panScanRectCancelFlag = tmp == 1 ? |
| HANTRO_TRUE : HANTRO_FALSE; |
| |
| if (!pPanScanRectangle->panScanRectCancelFlag) |
| { |
| tmp = h264bsdDecodeExpGolombUnsigned(pStrmData, |
| &pPanScanRectangle->panScanCnt); |
| if (tmp != HANTRO_OK) |
| return(tmp); |
| if (pPanScanRectangle->panScanCnt > 2) |
| return(HANTRO_NOK); |
| pPanScanRectangle->panScanCnt++; |
| |
| for (i = 0; i < pPanScanRectangle->panScanCnt; i++) |
| { |
| tmp = h264bsdDecodeExpGolombSigned(pStrmData, |
| &pPanScanRectangle->panScanRectLeftOffset[i]); |
| if (tmp != HANTRO_OK) |
| return(tmp); |
| |
| tmp = h264bsdDecodeExpGolombSigned(pStrmData, |
| &pPanScanRectangle->panScanRectRightOffset[i]); |
| if (tmp != HANTRO_OK) |
| return(tmp); |
| |
| tmp = h264bsdDecodeExpGolombSigned(pStrmData, |
| &pPanScanRectangle->panScanRectTopOffset[i]); |
| if (tmp != HANTRO_OK) |
| return(tmp); |
| |
| tmp = h264bsdDecodeExpGolombSigned(pStrmData, |
| &pPanScanRectangle->panScanRectBottomOffset[i]); |
| if (tmp != HANTRO_OK) |
| return(tmp); |
| } |
| tmp = h264bsdDecodeExpGolombUnsigned(pStrmData, |
| &pPanScanRectangle->panScanRectRepetitionPeriod); |
| if (tmp != HANTRO_OK) |
| return(tmp); |
| if (pPanScanRectangle->panScanRectRepetitionPeriod > 16384) |
| return(HANTRO_NOK); |
| if (pPanScanRectangle->panScanCnt > 1 && |
| pPanScanRectangle->panScanRectRepetitionPeriod > 1) |
| return(HANTRO_NOK); |
| } |
| |
| return(HANTRO_OK); |
| } |
| |
| /*------------------------------------------------------------------------------ |
| |
| Function: DecodeFillerPayload |
| |
| Functional description: |
| <++> |
| Inputs: |
| <++> |
| Outputs: |
| <++> |
| |
| ------------------------------------------------------------------------------*/ |
| |
| static u32 DecodeFillerPayload(strmData_t *pStrmData, u32 payloadSize) |
| { |
| |
| /* Variables */ |
| |
| /* Code */ |
| |
| ASSERT(pStrmData); |
| |
| |
| if (payloadSize) |
| if (h264bsdFlushBits(pStrmData, 8 * payloadSize) == END_OF_STREAM) |
| return(HANTRO_NOK); |
| |
| return(HANTRO_OK); |
| |
| } |
| |
| /*------------------------------------------------------------------------------ |
| |
| Function: DecodeUserDataRegisteredITuTT35 |
| |
| Functional description: |
| <++> |
| Inputs: |
| <++> |
| Outputs: |
| <++> |
| |
| ------------------------------------------------------------------------------*/ |
| |
| static u32 DecodeUserDataRegisteredITuTT35( |
| strmData_t *pStrmData, |
| seiUserDataRegisteredItuTT35_t *pUserDataRegisteredItuTT35, |
| u32 payloadSize) |
| { |
| |
| /* Variables */ |
| |
| u32 tmp, i, j; |
| |
| /* Code */ |
| |
| ASSERT(pStrmData); |
| ASSERT(pUserDataRegisteredItuTT35); |
| ASSERT(payloadSize); |
| |
| tmp = h264bsdGetBits(pStrmData, 8); |
| if (tmp == END_OF_STREAM) |
| return(HANTRO_NOK); |
| pUserDataRegisteredItuTT35->ituTT35CountryCode = tmp; |
| |
| if (pUserDataRegisteredItuTT35->ituTT35CountryCode != 0xFF) |
| i = 1; |
| else |
| { |
| tmp = h264bsdGetBits(pStrmData, 8); |
| if (tmp == END_OF_STREAM) |
| return(HANTRO_NOK); |
| pUserDataRegisteredItuTT35->ituTT35CountryCodeExtensionByte = tmp; |
| i = 2; |
| } |
| |
| /* where corresponding FREE() ??? */ |
| ALLOCATE(pUserDataRegisteredItuTT35->ituTT35PayloadByte,payloadSize-i,u8); |
| pUserDataRegisteredItuTT35->numPayloadBytes = payloadSize - i; |
| if (pUserDataRegisteredItuTT35->ituTT35PayloadByte == NULL) |
| return(MEMORY_ALLOCATION_ERROR); |
| |
| j = 0; |
| do |
| { |
| tmp = h264bsdGetBits(pStrmData, 8); |
| if (tmp == END_OF_STREAM) |
| return(HANTRO_NOK); |
| pUserDataRegisteredItuTT35->ituTT35PayloadByte[j] = (u8)tmp; |
| i++; |
| j++; |
| } while (i < payloadSize); |
| |
| return(HANTRO_OK); |
| |
| } |
| |
| /*------------------------------------------------------------------------------ |
| |
| Function: DecodeUserDataUnregistered |
| |
| Functional description: |
| <++> |
| Inputs: |
| <++> |
| Outputs: |
| <++> |
| |
| ------------------------------------------------------------------------------*/ |
| |
| static u32 DecodeUserDataUnregistered( |
| strmData_t *pStrmData, |
| seiUserDataUnregistered_t *pUserDataUnregistered, |
| u32 payloadSize) |
| { |
| |
| /* Variables */ |
| |
| u32 i, tmp; |
| |
| /* Code */ |
| |
| ASSERT(pStrmData); |
| ASSERT(pUserDataUnregistered); |
| |
| |
| for (i = 0; i < 4; i++) |
| { |
| pUserDataUnregistered->uuidIsoIec11578[i] = h264bsdShowBits32(pStrmData); |
| if (h264bsdFlushBits(pStrmData,32) == END_OF_STREAM) |
| return(HANTRO_NOK); |
| } |
| |
| /* where corresponding FREE() ??? */ |
| ALLOCATE(pUserDataUnregistered->userDataPayloadByte, payloadSize - 16, u8); |
| if (pUserDataUnregistered->userDataPayloadByte == NULL) |
| return(MEMORY_ALLOCATION_ERROR); |
| |
| pUserDataUnregistered->numPayloadBytes = payloadSize - 16; |
| |
| for (i = 0; i < payloadSize - 16; i++) |
| { |
| tmp = h264bsdGetBits(pStrmData, 8); |
| if (tmp == END_OF_STREAM) |
| return(HANTRO_NOK); |
| pUserDataUnregistered->userDataPayloadByte[i] = (u8)tmp; |
| } |
| |
| return(HANTRO_OK); |
| |
| } |
| |
| /*------------------------------------------------------------------------------ |
| |
| Function: DecodeRecoveryPoint |
| |
| Functional description: |
| <++> |
| Inputs: |
| <++> |
| Outputs: |
| <++> |
| |
| ------------------------------------------------------------------------------*/ |
| |
| static u32 DecodeRecoveryPoint( |
| strmData_t *pStrmData, |
| seiRecoveryPoint_t *pRecoveryPoint) |
| { |
| |
| /* Variables */ |
| |
| u32 tmp; |
| |
| /* Code */ |
| |
| ASSERT(pStrmData); |
| ASSERT(pRecoveryPoint); |
| |
| |
| tmp = h264bsdDecodeExpGolombUnsigned(pStrmData, |
| &pRecoveryPoint->recoveryFrameCnt); |
| if (tmp != HANTRO_OK) |
| return(tmp); |
| |
| tmp = h264bsdGetBits(pStrmData, 1); |
| if (tmp == END_OF_STREAM) |
| return(HANTRO_NOK); |
| pRecoveryPoint->exactMatchFlag = tmp == 1 ? HANTRO_TRUE : HANTRO_FALSE; |
| |
| tmp = h264bsdGetBits(pStrmData, 1); |
| if (tmp == END_OF_STREAM) |
| return(HANTRO_NOK); |
| pRecoveryPoint->brokenLinkFlag = tmp == 1 ? HANTRO_TRUE : HANTRO_FALSE; |
| |
| tmp = h264bsdGetBits(pStrmData, 2); |
| if (tmp == END_OF_STREAM) |
| return(HANTRO_NOK); |
| if (tmp > 2) |
| return(HANTRO_NOK); |
| pRecoveryPoint->changingSliceGroupIdc = tmp; |
| |
| return(HANTRO_OK); |
| |
| } |
| |
| /*------------------------------------------------------------------------------ |
| |
| Function: DecodeDecRefPicMarkingRepetition |
| |
| Functional description: |
| <++> |
| Inputs: |
| <++> |
| Outputs: |
| <++> |
| |
| ------------------------------------------------------------------------------*/ |
| |
| static u32 DecodeDecRefPicMarkingRepetition( |
| strmData_t *pStrmData, |
| seiDecRefPicMarkingRepetition_t *pDecRefPicMarkingRepetition, |
| u32 numRefFrames) |
| { |
| |
| /* Variables */ |
| |
| u32 tmp; |
| |
| /* Code */ |
| |
| ASSERT(pStrmData); |
| ASSERT(pDecRefPicMarkingRepetition); |
| |
| |
| tmp = h264bsdGetBits(pStrmData, 1); |
| if (tmp == END_OF_STREAM) |
| return(HANTRO_NOK); |
| pDecRefPicMarkingRepetition->originalIdrFlag = tmp == 1 ? HANTRO_TRUE : HANTRO_FALSE; |
| |
| tmp = h264bsdDecodeExpGolombUnsigned(pStrmData, |
| &pDecRefPicMarkingRepetition->originalFrameNum); |
| if (tmp != HANTRO_OK) |
| return(tmp); |
| |
| /* frame_mbs_only_flag assumed always true so some field related syntax |
| * elements are skipped, see H.264 standard */ |
| tmp = h264bsdDecRefPicMarking(pStrmData, |
| &pDecRefPicMarkingRepetition->decRefPicMarking, NAL_SEI, numRefFrames); |
| |
| return(tmp); |
| |
| } |
| |
| /*------------------------------------------------------------------------------ |
| |
| Function: DecodeSparePic |
| |
| Functional description: |
| <++> |
| Inputs: |
| <++> |
| Outputs: |
| <++> |
| |
| ------------------------------------------------------------------------------*/ |
| |
| static u32 DecodeSparePic( |
| strmData_t *pStrmData, |
| seiSparePic_t *pSparePic, |
| u32 picSizeInMapUnits) |
| { |
| |
| /* Variables */ |
| |
| u32 tmp, i, j, mapUnitCnt; |
| |
| /* Code */ |
| |
| ASSERT(pStrmData); |
| ASSERT(pSparePic); |
| |
| |
| tmp = h264bsdDecodeExpGolombUnsigned(pStrmData, |
| &pSparePic->targetFrameNum); |
| if (tmp != HANTRO_OK) |
| return(tmp); |
| |
| tmp = h264bsdGetBits(pStrmData, 1); |
| if (tmp == END_OF_STREAM) |
| return(HANTRO_NOK); |
| pSparePic->spareFieldFlag = tmp == 1 ? HANTRO_TRUE : HANTRO_FALSE; |
| /* do not accept fields */ |
| if (pSparePic->spareFieldFlag) |
| return(HANTRO_NOK); |
| |
| tmp = h264bsdDecodeExpGolombUnsigned(pStrmData, &pSparePic->numSparePics); |
| if (tmp != HANTRO_OK) |
| return(tmp); |
| pSparePic->numSparePics++; |
| if (pSparePic->numSparePics > MAX_NUM_SPARE_PICS) |
| return(HANTRO_NOK); |
| |
| for (i = 0; i < pSparePic->numSparePics; i++) |
| { |
| tmp = h264bsdDecodeExpGolombUnsigned(pStrmData, |
| &pSparePic->deltaSpareFrameNum[i]); |
| if (tmp != HANTRO_OK) |
| return(tmp); |
| |
| tmp = h264bsdDecodeExpGolombUnsigned(pStrmData, |
| &pSparePic->spareAreaIdc[i]); |
| if (tmp != HANTRO_OK) |
| return(tmp); |
| if (pSparePic->spareAreaIdc[i] > 2) |
| return(HANTRO_NOK); |
| |
| if (pSparePic->spareAreaIdc[i] == 1) |
| { |
| /* where corresponding FREE() ??? */ |
| ALLOCATE(pSparePic->spareUnitFlag[i], picSizeInMapUnits, u32); |
| if (pSparePic->spareUnitFlag[i] == NULL) |
| return(MEMORY_ALLOCATION_ERROR); |
| pSparePic->zeroRunLength[i] = NULL; |
| |
| for (j = 0; j < picSizeInMapUnits; j++) |
| { |
| tmp = h264bsdGetBits(pStrmData, 1); |
| if (tmp == END_OF_STREAM) |
| return(HANTRO_NOK); |
| pSparePic->spareUnitFlag[i][j] = tmp == 1 ? |
| HANTRO_TRUE : HANTRO_FALSE; |
| } |
| } |
| else if (pSparePic->spareAreaIdc[i] == 2) |
| { |
| /* where corresponding FREE() ??? */ |
| ALLOCATE(pSparePic->zeroRunLength[i], picSizeInMapUnits, u32); |
| if (pSparePic->zeroRunLength[i] == NULL) |
| return(MEMORY_ALLOCATION_ERROR); |
| pSparePic->spareUnitFlag[i] = NULL; |
| |
| for (j = 0, mapUnitCnt = 0; mapUnitCnt < picSizeInMapUnits; j++) |
| { |
| tmp = h264bsdDecodeExpGolombUnsigned(pStrmData, |
| &pSparePic->zeroRunLength[i][j]); |
| if (tmp != HANTRO_OK) |
| return(tmp); |
| mapUnitCnt += pSparePic->zeroRunLength[i][j] + 1; |
| } |
| } |
| } |
| |
| /* set rest to null */ |
| for (i = pSparePic->numSparePics; i < MAX_NUM_SPARE_PICS; i++) |
| { |
| pSparePic->spareUnitFlag[i] = NULL; |
| pSparePic->zeroRunLength[i] = NULL; |
| } |
| |
| return(HANTRO_OK); |
| |
| } |
| |
| /*------------------------------------------------------------------------------ |
| |
| Function: DecodeSceneInfo |
| |
| Functional description: |
| <++> |
| Inputs: |
| <++> |
| Outputs: |
| <++> |
| |
| ------------------------------------------------------------------------------*/ |
| |
| static u32 DecodeSceneInfo( |
| strmData_t *pStrmData, |
| seiSceneInfo_t *pSceneInfo) |
| { |
| |
| /* Variables */ |
| |
| u32 tmp; |
| |
| /* Code */ |
| |
| ASSERT(pStrmData); |
| ASSERT(pSceneInfo); |
| |
| |
| tmp = h264bsdGetBits(pStrmData, 1); |
| if (tmp == END_OF_STREAM) |
| return(HANTRO_NOK); |
| pSceneInfo->sceneInfoPresentFlag = tmp == 1 ? HANTRO_TRUE : HANTRO_FALSE; |
| |
| if (pSceneInfo->sceneInfoPresentFlag) |
| { |
| tmp = h264bsdDecodeExpGolombUnsigned(pStrmData, &pSceneInfo->sceneId); |
| if (tmp != HANTRO_OK) |
| return(tmp); |
| |
| tmp = h264bsdDecodeExpGolombUnsigned(pStrmData, |
| &pSceneInfo->sceneTransitionType); |
| if (tmp != HANTRO_OK) |
| return(tmp); |
| if (pSceneInfo->sceneTransitionType > 6) |
| return(HANTRO_NOK); |
| |
| if (pSceneInfo->sceneTransitionType) |
| { |
| tmp = h264bsdDecodeExpGolombUnsigned(pStrmData, |
| &pSceneInfo->secondSceneId); |
| if (tmp != HANTRO_OK) |
| return(tmp); |
| } |
| |
| } |
| |
| return(HANTRO_OK); |
| |
| } |
| |
| /*------------------------------------------------------------------------------ |
| |
| Function: DecodeSubSeqInfo |
| |
| Functional description: |
| <++> |
| Inputs: |
| <++> |
| Outputs: |
| <++> |
| |
| -----------------------------------------------------------------------------*/ |
| |
| static u32 DecodeSubSeqInfo( |
| strmData_t *pStrmData, |
| seiSubSeqInfo_t *pSubSeqInfo) |
| { |
| |
| /* Variables */ |
| |
| u32 tmp; |
| |
| /* Code */ |
| |
| ASSERT(pStrmData); |
| ASSERT(pSubSeqInfo); |
| |
| |
| tmp = h264bsdDecodeExpGolombUnsigned(pStrmData, |
| &pSubSeqInfo->subSeqLayerNum); |
| if (tmp != HANTRO_OK) |
| return(tmp); |
| if (pSubSeqInfo->subSeqLayerNum > 255) |
| return(HANTRO_NOK); |
| |
| tmp = h264bsdDecodeExpGolombUnsigned(pStrmData, &pSubSeqInfo->subSeqId); |
| if (tmp != HANTRO_OK) |
| return(tmp); |
| if (pSubSeqInfo->subSeqId > 65535) |
| return(HANTRO_NOK); |
| |
| tmp = h264bsdGetBits(pStrmData, 1); |
| if (tmp == END_OF_STREAM) |
| return(HANTRO_NOK); |
| pSubSeqInfo->firstRefPicFlag = tmp == 1 ? HANTRO_TRUE : HANTRO_FALSE; |
| |
| tmp = h264bsdGetBits(pStrmData, 1); |
| if (tmp == END_OF_STREAM) |
| return(HANTRO_NOK); |
| pSubSeqInfo->leadingNonRefPicFlag = tmp == 1 ? HANTRO_TRUE : HANTRO_FALSE; |
| |
| tmp = h264bsdGetBits(pStrmData, 1); |
| if (tmp == END_OF_STREAM) |
| return(HANTRO_NOK); |
| pSubSeqInfo->lastPicFlag = tmp == 1 ? HANTRO_TRUE : HANTRO_FALSE; |
| |
| tmp = h264bsdGetBits(pStrmData, 1); |
| if (tmp == END_OF_STREAM) |
| return(HANTRO_NOK); |
| pSubSeqInfo->subSeqFrameNumFlag = tmp == 1 ? HANTRO_TRUE : HANTRO_FALSE; |
| |
| if (pSubSeqInfo->subSeqFrameNumFlag) |
| { |
| tmp = h264bsdDecodeExpGolombUnsigned(pStrmData, |
| &pSubSeqInfo->subSeqFrameNum); |
| if (tmp != HANTRO_OK) |
| return(tmp); |
| } |
| |
| return(HANTRO_OK); |
| |
| } |
| |
| /*------------------------------------------------------------------------------ |
| |
| Function: DecodeSubSeqLayerCharacteristics |
| |
| Functional description: |
| <++> |
| Inputs: |
| <++> |
| Outputs: |
| <++> |
| |
| ------------------------------------------------------------------------------*/ |
| |
| static u32 DecodeSubSeqLayerCharacteristics( |
| strmData_t *pStrmData, |
| seiSubSeqLayerCharacteristics_t *pSubSeqLayerCharacteristics) |
| { |
| |
| /* Variables */ |
| |
| u32 tmp, i; |
| |
| /* Code */ |
| |
| ASSERT(pStrmData); |
| ASSERT(pSubSeqLayerCharacteristics); |
| |
| |
| tmp = h264bsdDecodeExpGolombUnsigned(pStrmData, |
| &pSubSeqLayerCharacteristics->numSubSeqLayers); |
| if (tmp != HANTRO_OK) |
| return(tmp); |
| pSubSeqLayerCharacteristics->numSubSeqLayers++; |
| if (pSubSeqLayerCharacteristics->numSubSeqLayers > MAX_NUM_SUB_SEQ_LAYERS) |
| return(HANTRO_NOK); |
| |
| for (i = 0; i < pSubSeqLayerCharacteristics->numSubSeqLayers; i++) |
| { |
| tmp = h264bsdGetBits(pStrmData, 1); |
| if (tmp == END_OF_STREAM) |
| return(HANTRO_NOK); |
| pSubSeqLayerCharacteristics->accurateStatisticsFlag[i] = |
| tmp == 1 ? HANTRO_TRUE : HANTRO_FALSE; |
| |
| tmp = h264bsdGetBits(pStrmData, 16); |
| if (tmp == END_OF_STREAM) |
| return(HANTRO_NOK); |
| pSubSeqLayerCharacteristics->averageBitRate[i] = tmp; |
| |
| tmp = h264bsdGetBits(pStrmData, 16); |
| if (tmp == END_OF_STREAM) |
| return(HANTRO_NOK); |
| pSubSeqLayerCharacteristics->averageFrameRate[i] = tmp; |
| } |
| |
| return(HANTRO_OK); |
| |
| } |
| |
| /*------------------------------------------------------------------------------ |
| |
| Function: DecodeSubSeqCharacteristics |
| |
| Functional description: |
| <++> |
| Inputs: |
| <++> |
| Outputs: |
| <++> |
| |
| ------------------------------------------------------------------------------*/ |
| |
| static u32 DecodeSubSeqCharacteristics( |
| strmData_t *pStrmData, |
| seiSubSeqCharacteristics_t *pSubSeqCharacteristics) |
| { |
| |
| /* Variables */ |
| |
| u32 tmp, i; |
| |
| /* Code */ |
| |
| ASSERT(pStrmData); |
| ASSERT(pSubSeqCharacteristics); |
| |
| |
| tmp = h264bsdDecodeExpGolombUnsigned(pStrmData, |
| &pSubSeqCharacteristics->subSeqLayerNum); |
| if (tmp != HANTRO_OK) |
| return(tmp); |
| if (pSubSeqCharacteristics->subSeqLayerNum > MAX_NUM_SUB_SEQ_LAYERS-1) |
| return(HANTRO_NOK); |
| |
| tmp = h264bsdDecodeExpGolombUnsigned(pStrmData, |
| &pSubSeqCharacteristics->subSeqId); |
| if (tmp != HANTRO_OK) |
| return(tmp); |
| if (pSubSeqCharacteristics->subSeqId > 65535) |
| return(HANTRO_NOK); |
| |
| tmp = h264bsdGetBits(pStrmData, 1); |
| if (tmp == END_OF_STREAM) |
| return(HANTRO_NOK); |
| pSubSeqCharacteristics->durationFlag = tmp == 1 ? |
| HANTRO_TRUE : HANTRO_FALSE; |
| |
| if (pSubSeqCharacteristics->durationFlag) |
| { |
| pSubSeqCharacteristics->subSeqDuration = h264bsdShowBits32(pStrmData); |
| if (h264bsdFlushBits(pStrmData,32) == END_OF_STREAM) |
| return(HANTRO_NOK); |
| } |
| |
| tmp = h264bsdGetBits(pStrmData, 1); |
| if (tmp == END_OF_STREAM) |
| return(HANTRO_NOK); |
| pSubSeqCharacteristics->averageRateFlag = tmp == 1 ? |
| HANTRO_TRUE : HANTRO_FALSE; |
| |
| if (pSubSeqCharacteristics->averageRateFlag) |
| { |
| tmp = h264bsdGetBits(pStrmData, 1); |
| if (tmp == END_OF_STREAM) |
| return(HANTRO_NOK); |
| pSubSeqCharacteristics->accurateStatisticsFlag = |
| tmp == 1 ? HANTRO_TRUE : HANTRO_FALSE; |
| |
| tmp = h264bsdGetBits(pStrmData, 16); |
| if (tmp == END_OF_STREAM) |
| return(HANTRO_NOK); |
| pSubSeqCharacteristics->averageBitRate = tmp; |
| |
| tmp = h264bsdGetBits(pStrmData, 16); |
| if (tmp == END_OF_STREAM) |
| return(HANTRO_NOK); |
| pSubSeqCharacteristics->averageFrameRate = tmp; |
| } |
| |
| tmp = h264bsdDecodeExpGolombUnsigned(pStrmData, |
| &pSubSeqCharacteristics->numReferencedSubseqs); |
| if (tmp != HANTRO_OK) |
| return(tmp); |
| if (pSubSeqCharacteristics->numReferencedSubseqs > MAX_NUM_SUB_SEQ_LAYERS-1) |
| return(HANTRO_NOK); |
| |
| for (i = 0; i < pSubSeqCharacteristics->numReferencedSubseqs; i++) |
| { |
| tmp = h264bsdDecodeExpGolombUnsigned(pStrmData, |
| &pSubSeqCharacteristics->refSubSeqLayerNum[i]); |
| if (tmp != HANTRO_OK) |
| return(tmp); |
| |
| tmp = h264bsdDecodeExpGolombUnsigned(pStrmData, |
| &pSubSeqCharacteristics->refSubSeqId[i]); |
| if (tmp != HANTRO_OK) |
| return(tmp); |
| |
| tmp = h264bsdGetBits(pStrmData, 1); |
| if (tmp == END_OF_STREAM) |
| return(HANTRO_NOK); |
| pSubSeqCharacteristics->refSubSeqDirection[i] = tmp; |
| } |
| |
| return(HANTRO_OK); |
| |
| } |
| |
| /*------------------------------------------------------------------------------ |
| |
| Function: DecodeFullFrameFreeze |
| |
| Functional description: |
| <++> |
| Inputs: |
| <++> |
| Outputs: |
| <++> |
| |
| ------------------------------------------------------------------------------*/ |
| |
| static u32 DecodeFullFrameFreeze( |
| strmData_t *pStrmData, |
| seiFullFrameFreeze_t *pFullFrameFreeze) |
| { |
| |
| /* Variables */ |
| |
| u32 tmp; |
| |
| /* Code */ |
| |
| ASSERT(pStrmData); |
| ASSERT(pFullFrameFreeze); |
| |
| |
| tmp = h264bsdDecodeExpGolombUnsigned(pStrmData, |
| &pFullFrameFreeze->fullFrameFreezeRepetitionPeriod); |
| if (tmp != HANTRO_OK) |
| return(tmp); |
| if (pFullFrameFreeze->fullFrameFreezeRepetitionPeriod > 16384) |
| return(HANTRO_NOK); |
| |
| return(HANTRO_OK); |
| |
| } |
| |
| /*------------------------------------------------------------------------------ |
| |
| Function: DecodeFullFrameSnapshot |
| |
| Functional description: |
| <++> |
| Inputs: |
| <++> |
| Outputs: |
| <++> |
| |
| ------------------------------------------------------------------------------*/ |
| |
| static u32 DecodeFullFrameSnapshot( |
| strmData_t *pStrmData, |
| seiFullFrameSnapshot_t *pFullFrameSnapshot) |
| { |
| |
| /* Variables */ |
| |
| u32 tmp; |
| |
| /* Code */ |
| |
| ASSERT(pStrmData); |
| ASSERT(pFullFrameSnapshot); |
| |
| |
| tmp = h264bsdDecodeExpGolombUnsigned(pStrmData, |
| &pFullFrameSnapshot->snapShotId); |
| if (tmp != HANTRO_OK) |
| return(tmp); |
| |
| return(HANTRO_OK); |
| |
| } |
| |
| /*------------------------------------------------------------------------------ |
| |
| Function: DecodeProgressiveRefinementSegmentStart |
| |
| Functional description: |
| <++> |
| Inputs: |
| <++> |
| Outputs: |
| <++> |
| |
| ------------------------------------------------------------------------------*/ |
| |
| static u32 DecodeProgressiveRefinementSegmentStart( |
| strmData_t *pStrmData, |
| seiProgressiveRefinementSegmentStart_t *pProgressiveRefinementSegmentStart) |
| { |
| |
| /* Variables */ |
| |
| u32 tmp; |
| |
| /* Code */ |
| |
| ASSERT(pStrmData); |
| ASSERT(pProgressiveRefinementSegmentStart); |
| |
| |
| tmp = h264bsdDecodeExpGolombUnsigned(pStrmData, |
| &pProgressiveRefinementSegmentStart->progressiveRefinementId); |
| if (tmp != HANTRO_OK) |
| return(tmp); |
| |
| tmp = h264bsdDecodeExpGolombUnsigned(pStrmData, |
| &pProgressiveRefinementSegmentStart->numRefinementSteps); |
| if (tmp != HANTRO_OK) |
| return(tmp); |
| pProgressiveRefinementSegmentStart->numRefinementSteps++; |
| |
| return(HANTRO_OK); |
| |
| } |
| |
| /*------------------------------------------------------------------------------ |
| |
| Function: DecodeProgressiveRefinementSegmentEnd |
| |
| Functional description: |
| <++> |
| Inputs: |
| <++> |
| Outputs: |
| <++> |
| |
| ------------------------------------------------------------------------------*/ |
| |
| static u32 DecodeProgressiveRefinementSegmentEnd( |
| strmData_t *pStrmData, |
| seiProgressiveRefinementSegmentEnd_t *pProgressiveRefinementSegmentEnd) |
| { |
| |
| /* Variables */ |
| |
| u32 tmp; |
| |
| /* Code */ |
| |
| ASSERT(pStrmData); |
| ASSERT(pProgressiveRefinementSegmentEnd); |
| |
| |
| tmp = h264bsdDecodeExpGolombUnsigned(pStrmData, |
| &pProgressiveRefinementSegmentEnd->progressiveRefinementId); |
| if (tmp != HANTRO_OK) |
| return(tmp); |
| |
| return(HANTRO_OK); |
| |
| } |
| |
| /*------------------------------------------------------------------------------ |
| |
| Function: DecodeMotionConstrainedSliceGroupSet |
| |
| Functional description: |
| <++> |
| Inputs: |
| <++> |
| Outputs: |
| <++> |
| |
| ------------------------------------------------------------------------------*/ |
| |
| static u32 DecodeMotionConstrainedSliceGroupSet( |
| strmData_t *pStrmData, |
| seiMotionConstrainedSliceGroupSet_t *pMotionConstrainedSliceGroupSet, |
| u32 numSliceGroups) |
| { |
| |
| /* Variables */ |
| |
| u32 tmp,i; |
| |
| /* Code */ |
| |
| ASSERT(pStrmData); |
| ASSERT(pMotionConstrainedSliceGroupSet); |
| ASSERT(numSliceGroups < MAX_NUM_SLICE_GROUPS); |
| |
| |
| tmp = h264bsdDecodeExpGolombUnsigned(pStrmData, |
| &pMotionConstrainedSliceGroupSet->numSliceGroupsInSet); |
| if (tmp != HANTRO_OK) |
| return(tmp); |
| pMotionConstrainedSliceGroupSet->numSliceGroupsInSet++; |
| if (pMotionConstrainedSliceGroupSet->numSliceGroupsInSet > numSliceGroups) |
| return(HANTRO_NOK); |
| |
| for (i = 0; i < pMotionConstrainedSliceGroupSet->numSliceGroupsInSet; i++) |
| { |
| tmp = h264bsdGetBits(pStrmData, |
| ceilLog2NumSliceGroups[numSliceGroups]); |
| if (tmp == END_OF_STREAM) |
| return(HANTRO_NOK); |
| pMotionConstrainedSliceGroupSet->sliceGroupId[i] = tmp; |
| if (pMotionConstrainedSliceGroupSet->sliceGroupId[i] > |
| pMotionConstrainedSliceGroupSet->numSliceGroupsInSet-1) |
| return(HANTRO_NOK); |
| } |
| |
| tmp = h264bsdGetBits(pStrmData, 1); |
| if (tmp == END_OF_STREAM) |
| return(HANTRO_NOK); |
| pMotionConstrainedSliceGroupSet->exactSampleValueMatchFlag = |
| tmp == 1 ? HANTRO_TRUE : HANTRO_FALSE; |
| |
| tmp = h264bsdGetBits(pStrmData, 1); |
| if (tmp == END_OF_STREAM) |
| return(HANTRO_NOK); |
| pMotionConstrainedSliceGroupSet->panScanRectFlag = tmp == 1 ? |
| HANTRO_TRUE : HANTRO_FALSE; |
| |
| if (pMotionConstrainedSliceGroupSet->panScanRectFlag) |
| { |
| tmp = h264bsdDecodeExpGolombUnsigned(pStrmData, |
| &pMotionConstrainedSliceGroupSet->panScanRectId); |
| if (tmp != HANTRO_OK) |
| return(tmp); |
| } |
| |
| return(HANTRO_OK); |
| |
| } |
| |
| /*------------------------------------------------------------------------------ |
| |
| Function: DecodeReservedSeiMessage |
| |
| Functional description: |
| <++> |
| Inputs: |
| <++> |
| Outputs: |
| <++> |
| |
| ------------------------------------------------------------------------------*/ |
| |
| static u32 DecodeReservedSeiMessage( |
| strmData_t *pStrmData, |
| seiReservedSeiMessage_t *pReservedSeiMessage, |
| u32 payloadSize) |
| { |
| |
| /* Variables */ |
| |
| u32 i, tmp; |
| |
| /* Code */ |
| |
| ASSERT(pStrmData); |
| ASSERT(pReservedSeiMessage); |
| |
| |
| /* where corresponding FREE() ??? */ |
| ALLOCATE(pReservedSeiMessage->reservedSeiMessagePayloadByte,payloadSize,u8); |
| if (pReservedSeiMessage->reservedSeiMessagePayloadByte == NULL) |
| return(MEMORY_ALLOCATION_ERROR); |
| |
| pReservedSeiMessage->numPayloadBytes = payloadSize; |
| |
| for (i = 0; i < payloadSize; i++) |
| { |
| tmp = h264bsdGetBits(pStrmData,8); |
| if (tmp == END_OF_STREAM) |
| return(HANTRO_NOK); |
| pReservedSeiMessage->reservedSeiMessagePayloadByte[i] = (u8)tmp; |
| } |
| |
| return(HANTRO_OK); |
| |
| } |
| |
