diff options
Diffstat (limited to 'media/libstagefright/codecs/on2/h264dec/source/h264bsd_sei.c')
| -rwxr-xr-x | media/libstagefright/codecs/on2/h264dec/source/h264bsd_sei.c | 1692 |
1 files changed, 1692 insertions, 0 deletions
diff --git a/media/libstagefright/codecs/on2/h264dec/source/h264bsd_sei.c b/media/libstagefright/codecs/on2/h264dec/source/h264bsd_sei.c new file mode 100755 index 0000000..0756c47 --- /dev/null +++ b/media/libstagefright/codecs/on2/h264dec/source/h264bsd_sei.c @@ -0,0 +1,1692 @@ +/* + * 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); + +} + |