Home | History | Annotate | Download | only in source
      1 /*
      2  * Copyright (C) 2009 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 /*------------------------------------------------------------------------------
     18 
     19     Table of contents
     20 
     21      1. Include headers
     22      2. External compiler flags
     23      3. Module defines
     24      4. Local function prototypes
     25      5. Functions
     26           h264bsdDecodeSeiMessage
     27           DecodeBufferingPeriod
     28           DecodePictureTiming
     29           DecodePanScanRectangle
     30           DecodeFillerPayload
     31           DecodeUserDataRegisteredITuTT35
     32           DecodeUserDataUnregistered
     33           DecodeRecoveryPoint
     34           DecodeDecRefPicMarkingRepetition
     35           DecodeSparePic
     36           DecodeSceneInfo
     37           DecodeSubSeqInfo
     38           DecodeSubSeqLayerCharacteristics
     39           DecodeSubSeqCharacteristics
     40           DecodeFullFrameFreeze
     41           DecodeFullFrameSnapshot
     42           DecodeProgressiveRefinementSegmentStart
     43           DecodeProgressiveRefinementSegmentEnd
     44           DecodeMotionConstrainedSliceGroupSet
     45           DecodeReservedSeiMessage
     46 
     47 ------------------------------------------------------------------------------*/
     48 
     49 /*------------------------------------------------------------------------------
     50     1. Include headers
     51 ------------------------------------------------------------------------------*/
     52 
     53 #include "h264bsd_sei.h"
     54 #include "basetype.h"
     55 #include "h264bsd_util.h"
     56 #include "h264bsd_stream.h"
     57 #include "h264bsd_vlc.h"
     58 #include "h264bsd_seq_param_set.h"
     59 #include "h264bsd_slice_header.h"
     60 
     61 /*------------------------------------------------------------------------------
     62     2. External compiler flags
     63 --------------------------------------------------------------------------------
     64 
     65 --------------------------------------------------------------------------------
     66     3. Module defines
     67 ------------------------------------------------------------------------------*/
     68 
     69 static const u32 numClockTS[9] = {1,1,1,2,2,3,3,2,3};
     70 static const u32 ceilLog2NumSliceGroups[9] = {0,1,1,2,2,3,3,3,3};
     71 
     72 /*------------------------------------------------------------------------------
     73     4. Local function prototypes
     74 ------------------------------------------------------------------------------*/
     75 
     76 static u32 DecodeBufferingPeriod(
     77   strmData_t *pStrmData,
     78   seiBufferingPeriod_t *pBufferingPeriod,
     79   u32 cpbCnt,
     80   u32 initialCpbRemovalDelayLength,
     81   u32 nalHrdBpPresentFlag,
     82   u32 vclHrdBpPresentFlag);
     83 
     84 static u32 DecodePictureTiming(
     85   strmData_t *pStrmData,
     86   seiPicTiming_t *pPicTiming,
     87   u32 cpbRemovalDelayLength,
     88   u32 dpbOutputDelayLength,
     89   u32 timeOffsetLength,
     90   u32 cpbDpbDelaysPresentFlag,
     91   u32 picStructPresentFlag);
     92 
     93 static u32 DecodePanScanRectangle(
     94   strmData_t *pStrmData,
     95   seiPanScanRect_t *pPanScanRectangle);
     96 
     97 static u32 DecodeFillerPayload(strmData_t *pStrmData, u32 payloadSize);
     98 
     99 static u32 DecodeUserDataRegisteredITuTT35(
    100   strmData_t *pStrmData,
    101   seiUserDataRegisteredItuTT35_t *pUserDataRegisteredItuTT35,
    102   u32 payloadSize);
    103 
    104 static u32 DecodeUserDataUnregistered(
    105   strmData_t *pStrmData,
    106   seiUserDataUnregistered_t *pUserDataUnregistered,
    107   u32 payloadSize);
    108 
    109 static u32 DecodeRecoveryPoint(
    110   strmData_t *pStrmData,
    111   seiRecoveryPoint_t *pRecoveryPoint);
    112 
    113 static u32 DecodeDecRefPicMarkingRepetition(
    114   strmData_t *pStrmData,
    115   seiDecRefPicMarkingRepetition_t *pDecRefPicMarkingRepetition,
    116   u32 numRefFrames);
    117 
    118 static u32 DecodeSparePic(
    119   strmData_t *pStrmData,
    120   seiSparePic_t *pSparePic,
    121   u32 picSizeInMapUnits);
    122 
    123 static u32 DecodeSceneInfo(
    124   strmData_t *pStrmData,
    125   seiSceneInfo_t *pSceneInfo);
    126 
    127 static u32 DecodeSubSeqInfo(
    128   strmData_t *pStrmData,
    129   seiSubSeqInfo_t *pSubSeqInfo);
    130 
    131 static u32 DecodeSubSeqLayerCharacteristics(
    132   strmData_t *pStrmData,
    133   seiSubSeqLayerCharacteristics_t *pSubSeqLayerCharacteristics);
    134 
    135 static u32 DecodeSubSeqCharacteristics(
    136   strmData_t *pStrmData,
    137   seiSubSeqCharacteristics_t *pSubSeqCharacteristics);
    138 
    139 static u32 DecodeFullFrameFreeze(
    140   strmData_t *pStrmData,
    141   seiFullFrameFreeze_t *pFullFrameFreeze);
    142 
    143 static u32 DecodeFullFrameSnapshot(
    144   strmData_t *pStrmData,
    145   seiFullFrameSnapshot_t *pFullFrameSnapshot);
    146 
    147 static u32 DecodeProgressiveRefinementSegmentStart(
    148   strmData_t *pStrmData,
    149   seiProgressiveRefinementSegmentStart_t *pProgressiveRefinementSegmentStart);
    150 
    151 static u32 DecodeProgressiveRefinementSegmentEnd(
    152   strmData_t *pStrmData,
    153   seiProgressiveRefinementSegmentEnd_t *pProgressiveRefinementSegmentEnd);
    154 
    155 static u32 DecodeMotionConstrainedSliceGroupSet(
    156   strmData_t *pStrmData,
    157   seiMotionConstrainedSliceGroupSet_t *pMotionConstrainedSliceGroupSet,
    158   u32 numSliceGroups);
    159 
    160 static u32 DecodeReservedSeiMessage(
    161   strmData_t *pStrmData,
    162   seiReservedSeiMessage_t *pReservedSeiMessage,
    163   u32 payloadSize);
    164 
    165 /*------------------------------------------------------------------------------
    166 
    167     Function: h264bsdDecodeSeiMessage
    168 
    169         Functional description:
    170           <++>
    171         Inputs:
    172           <++>
    173         Outputs:
    174           <++>
    175 
    176 ------------------------------------------------------------------------------*/
    177 
    178 u32 h264bsdDecodeSeiMessage(
    179   strmData_t *pStrmData,
    180   seqParamSet_t *pSeqParamSet,
    181   seiMessage_t *pSeiMessage,
    182   u32 numSliceGroups)
    183 {
    184 
    185 /* Variables */
    186 
    187     u32 tmp, payloadType, payloadSize, status;
    188 
    189 /* Code */
    190 
    191     ASSERT(pStrmData);
    192     ASSERT(pSeiMessage);
    193 
    194 
    195     H264SwDecMemset(pSeiMessage, 0, sizeof(seiMessage_t));
    196 
    197     do
    198     {
    199         payloadType = 0;
    200         while((tmp = h264bsdGetBits(pStrmData, 8)) == 0xFF)
    201         {
    202             payloadType += 255;
    203                     }
    204         if (tmp == END_OF_STREAM)
    205             return(HANTRO_NOK);
    206         payloadType += tmp;
    207 
    208         payloadSize = 0;
    209         while((tmp = h264bsdGetBits(pStrmData, 8)) == 0xFF)
    210         {
    211             payloadSize += 255;
    212         }
    213         if (tmp == END_OF_STREAM)
    214             return(HANTRO_NOK);
    215         payloadSize += tmp;
    216 
    217         pSeiMessage->payloadType = payloadType;
    218 
    219         switch (payloadType)
    220         {
    221             case 0:
    222                 ASSERT(pSeqParamSet);
    223                 status = DecodeBufferingPeriod(
    224                   pStrmData,
    225                   &pSeiMessage->bufferingPeriod,
    226                   pSeqParamSet->vuiParameters->vclHrdParameters.cpbCnt,
    227                   pSeqParamSet->vuiParameters->vclHrdParameters.
    228                   initialCpbRemovalDelayLength,
    229                   pSeqParamSet->vuiParameters->nalHrdParametersPresentFlag,
    230                   pSeqParamSet->vuiParameters->vclHrdParametersPresentFlag);
    231                 break;
    232 
    233             case 1:
    234                 ASSERT(pSeqParamSet->vuiParametersPresentFlag);
    235                 status = DecodePictureTiming(
    236                   pStrmData,
    237                   &pSeiMessage->picTiming,
    238                   pSeqParamSet->vuiParameters->vclHrdParameters.
    239                       cpbRemovalDelayLength,
    240                   pSeqParamSet->vuiParameters->vclHrdParameters.
    241                       dpbOutputDelayLength,
    242                   pSeqParamSet->vuiParameters->vclHrdParameters.
    243                     timeOffsetLength,
    244                   pSeqParamSet->vuiParameters->nalHrdParametersPresentFlag ||
    245                   pSeqParamSet->vuiParameters->vclHrdParametersPresentFlag ?
    246                   HANTRO_TRUE : HANTRO_FALSE,
    247                   pSeqParamSet->vuiParameters->picStructPresentFlag);
    248                 break;
    249 
    250             case 2:
    251                 status = DecodePanScanRectangle(
    252                   pStrmData,
    253                   &pSeiMessage->panScanRect);
    254                 break;
    255 
    256             case 3:
    257                 status = DecodeFillerPayload(pStrmData, payloadSize);
    258                 break;
    259 
    260             case 4:
    261                 status = DecodeUserDataRegisteredITuTT35(
    262                   pStrmData,
    263                   &pSeiMessage->userDataRegisteredItuTT35,
    264                   payloadSize);
    265                 break;
    266 
    267             case 5:
    268                 status = DecodeUserDataUnregistered(
    269                   pStrmData,
    270                   &pSeiMessage->userDataUnregistered,
    271                   payloadSize);
    272                 break;
    273 
    274             case 6:
    275                 status = DecodeRecoveryPoint(
    276                   pStrmData,
    277                   &pSeiMessage->recoveryPoint);
    278                 break;
    279 
    280             case 7:
    281                 status = DecodeDecRefPicMarkingRepetition(
    282                   pStrmData,
    283                   &pSeiMessage->decRefPicMarkingRepetition,
    284                   pSeqParamSet->numRefFrames);
    285                 break;
    286 
    287             case 8:
    288                 ASSERT(pSeqParamSet);
    289                 status = DecodeSparePic(
    290                   pStrmData,
    291                   &pSeiMessage->sparePic,
    292                   pSeqParamSet->picWidthInMbs * pSeqParamSet->picHeightInMbs);
    293                 break;
    294 
    295             case 9:
    296                 status = DecodeSceneInfo(
    297                   pStrmData,
    298                   &pSeiMessage->sceneInfo);
    299                 break;
    300 
    301             case 10:
    302                 status = DecodeSubSeqInfo(
    303                   pStrmData,
    304                   &pSeiMessage->subSeqInfo);
    305                 break;
    306 
    307             case 11:
    308                 status = DecodeSubSeqLayerCharacteristics(
    309                   pStrmData,
    310                   &pSeiMessage->subSeqLayerCharacteristics);
    311                 break;
    312 
    313             case 12:
    314                 status = DecodeSubSeqCharacteristics(
    315                   pStrmData,
    316                   &pSeiMessage->subSeqCharacteristics);
    317                 break;
    318 
    319             case 13:
    320                 status = DecodeFullFrameFreeze(
    321                   pStrmData,
    322                   &pSeiMessage->fullFrameFreeze);
    323                 break;
    324 
    325             case 14: /* This SEI does not contain data, what to do ??? */
    326                 status = HANTRO_OK;
    327                 break;
    328 
    329             case 15:
    330                 status = DecodeFullFrameSnapshot(
    331                   pStrmData,
    332                   &pSeiMessage->fullFrameSnapshot);
    333                 break;
    334 
    335             case 16:
    336                 status = DecodeProgressiveRefinementSegmentStart(
    337                   pStrmData,
    338                   &pSeiMessage->progressiveRefinementSegmentStart);
    339                 break;
    340 
    341             case 17:
    342                 status = DecodeProgressiveRefinementSegmentEnd(
    343                   pStrmData,
    344                   &pSeiMessage->progressiveRefinementSegmentEnd);
    345                 break;
    346 
    347             case 18:
    348                 ASSERT(numSliceGroups);
    349                 status = DecodeMotionConstrainedSliceGroupSet(
    350                   pStrmData,
    351                   &pSeiMessage->motionConstrainedSliceGroupSet,
    352                   numSliceGroups);
    353                 break;
    354 
    355             default:
    356                 status = DecodeReservedSeiMessage(
    357                   pStrmData,
    358                   &pSeiMessage->reservedSeiMessage,
    359                   payloadSize);
    360                 break;
    361         }
    362 
    363         if (status != HANTRO_OK)
    364             return(status);
    365 
    366         while (!h264bsdIsByteAligned(pStrmData))
    367         {
    368             if (h264bsdGetBits(pStrmData, 1) != 1)
    369                 return(HANTRO_NOK);
    370             while (!h264bsdIsByteAligned(pStrmData))
    371             {
    372                 if (h264bsdGetBits(pStrmData, 1) != 0)
    373                     return(HANTRO_NOK);
    374             }
    375         }
    376     } while (h264bsdMoreRbspData(pStrmData));
    377 
    378     return(h264bsdRbspTrailingBits(pStrmData));
    379 
    380 }
    381 
    382 /*------------------------------------------------------------------------------
    383 
    384     Function: DecodeBufferingPeriod
    385 
    386         Functional description:
    387           <++>
    388         Inputs:
    389           <++>
    390         Outputs:
    391           <++>
    392 
    393 ------------------------------------------------------------------------------*/
    394 
    395 static u32 DecodeBufferingPeriod(
    396   strmData_t *pStrmData,
    397   seiBufferingPeriod_t *pBufferingPeriod,
    398   u32 cpbCnt,
    399   u32 initialCpbRemovalDelayLength,
    400   u32 nalHrdBpPresentFlag,
    401   u32 vclHrdBpPresentFlag)
    402 {
    403 
    404 /* Variables */
    405 
    406     u32 tmp, i;
    407 
    408 /* Code */
    409 
    410     ASSERT(pStrmData);
    411     ASSERT(pBufferingPeriod);
    412     ASSERT(cpbCnt);
    413     ASSERT(initialCpbRemovalDelayLength);
    414 
    415 
    416     tmp = h264bsdDecodeExpGolombUnsigned(pStrmData,
    417       &pBufferingPeriod->seqParameterSetId);
    418     if (tmp != HANTRO_OK)
    419         return(tmp);
    420     if (pBufferingPeriod->seqParameterSetId > 31)
    421         return(HANTRO_NOK);
    422 
    423     if (nalHrdBpPresentFlag)
    424     {
    425         for (i = 0; i < cpbCnt; i++)
    426         {
    427             tmp = h264bsdGetBits(pStrmData, initialCpbRemovalDelayLength);
    428             if (tmp == END_OF_STREAM)
    429                 return(HANTRO_NOK);
    430             if (tmp == 0)
    431                 return(HANTRO_NOK);
    432             pBufferingPeriod->initialCpbRemovalDelay[i] = tmp;
    433 
    434             tmp = h264bsdGetBits(pStrmData, initialCpbRemovalDelayLength);
    435             if (tmp == END_OF_STREAM)
    436                 return(HANTRO_NOK);
    437             pBufferingPeriod->initialCpbRemovalDelayOffset[i] = tmp;
    438         }
    439     }
    440 
    441     if (vclHrdBpPresentFlag)
    442     {
    443         for (i = 0; i < cpbCnt; i++)
    444         {
    445             tmp = h264bsdGetBits(pStrmData, initialCpbRemovalDelayLength);
    446             if (tmp == END_OF_STREAM)
    447                 return(HANTRO_NOK);
    448             pBufferingPeriod->initialCpbRemovalDelay[i] = tmp;
    449 
    450             tmp = h264bsdGetBits(pStrmData, initialCpbRemovalDelayLength);
    451             if (tmp == END_OF_STREAM)
    452                 return(HANTRO_NOK);
    453             pBufferingPeriod->initialCpbRemovalDelayOffset[i] = tmp;
    454         }
    455     }
    456 
    457     return(HANTRO_OK);
    458 
    459 }
    460 
    461 /*------------------------------------------------------------------------------
    462 
    463     Function: DecodePictureTiming
    464 
    465         Functional description:
    466           <++>
    467         Inputs:
    468           <++>
    469         Outputs:
    470           <++>
    471 
    472 ------------------------------------------------------------------------------*/
    473 
    474 static u32 DecodePictureTiming(
    475   strmData_t *pStrmData,
    476   seiPicTiming_t *pPicTiming,
    477   u32 cpbRemovalDelayLength,
    478   u32 dpbOutputDelayLength,
    479   u32 timeOffsetLength,
    480   u32 cpbDpbDelaysPresentFlag,
    481   u32 picStructPresentFlag)
    482 {
    483 
    484 /* Variables */
    485 
    486     u32 tmp, i;
    487     i32 itmp;
    488 
    489 /* Code */
    490 
    491     ASSERT(pStrmData);
    492     ASSERT(pPicTiming);
    493 
    494 
    495     if (cpbDpbDelaysPresentFlag)
    496     {
    497         tmp = h264bsdGetBits(pStrmData, cpbRemovalDelayLength);
    498         if (tmp == END_OF_STREAM)
    499             return(HANTRO_NOK);
    500         pPicTiming->cpbRemovalDelay = tmp;
    501 
    502         tmp = h264bsdGetBits(pStrmData, dpbOutputDelayLength);
    503         if (tmp == END_OF_STREAM)
    504             return(HANTRO_NOK);
    505         pPicTiming->dpbOutputDelay = tmp;
    506     }
    507 
    508     if (picStructPresentFlag)
    509     {
    510         tmp = h264bsdGetBits(pStrmData, 4);
    511         if (tmp == END_OF_STREAM)
    512             return(HANTRO_NOK);
    513         if (tmp > 8)
    514             return(HANTRO_NOK);
    515         pPicTiming->picStruct = tmp;
    516 
    517         for (i = 0; i < numClockTS[pPicTiming->picStruct]; i++)
    518         {
    519             tmp = h264bsdGetBits(pStrmData, 1);
    520             if (tmp == END_OF_STREAM)
    521                 return(HANTRO_NOK);
    522             pPicTiming->clockTimeStampFlag[i] = tmp == 1 ?
    523                                     HANTRO_TRUE : HANTRO_FALSE;
    524 
    525             if (pPicTiming->clockTimeStampFlag[i])
    526             {
    527                 tmp = h264bsdGetBits(pStrmData, 2);
    528                 if (tmp == END_OF_STREAM)
    529                     return(HANTRO_NOK);
    530                 pPicTiming->ctType[i] = tmp;
    531 
    532                 tmp = h264bsdGetBits(pStrmData, 1);
    533                 if (tmp == END_OF_STREAM)
    534                     return(HANTRO_NOK);
    535                 pPicTiming->nuitFieldBasedFlag[i] = tmp == 1 ?
    536                                     HANTRO_TRUE : HANTRO_FALSE;
    537 
    538                 tmp = h264bsdGetBits(pStrmData, 5);
    539                 if (tmp == END_OF_STREAM)
    540                     return(HANTRO_NOK);
    541                 if (tmp > 6)
    542                     return(HANTRO_NOK);
    543                 pPicTiming->countingType[i] = tmp;
    544 
    545                 tmp = h264bsdGetBits(pStrmData, 1);
    546                 if (tmp == END_OF_STREAM)
    547                     return(HANTRO_NOK);
    548                 pPicTiming->fullTimeStampFlag[i] = tmp == 1 ?
    549                                     HANTRO_TRUE : HANTRO_FALSE;
    550 
    551                 tmp = h264bsdGetBits(pStrmData, 1);
    552                 if (tmp == END_OF_STREAM)
    553                     return(HANTRO_NOK);
    554                 pPicTiming->discontinuityFlag[i] = tmp == 1 ?
    555                                     HANTRO_TRUE : HANTRO_FALSE;
    556 
    557                 tmp = h264bsdGetBits(pStrmData, 1);
    558                 if (tmp == END_OF_STREAM)
    559                     return(HANTRO_NOK);
    560                 pPicTiming->cntDroppedFlag[i] = tmp == 1 ?
    561                                     HANTRO_TRUE : HANTRO_FALSE;
    562 
    563                 tmp = h264bsdGetBits(pStrmData, 8);
    564                 if (tmp == END_OF_STREAM)
    565                     return(HANTRO_NOK);
    566                 pPicTiming->nFrames[i] = tmp;
    567 
    568                 if (pPicTiming->fullTimeStampFlag[i])
    569                 {
    570                     tmp = h264bsdGetBits(pStrmData, 6);
    571                     if (tmp == END_OF_STREAM)
    572                         return(HANTRO_NOK);
    573                     if (tmp > 59)
    574                         return(HANTRO_NOK);
    575                     pPicTiming->secondsValue[i] = tmp;
    576 
    577                     tmp = h264bsdGetBits(pStrmData, 6);
    578                     if (tmp == END_OF_STREAM)
    579                         return(HANTRO_NOK);
    580                     if (tmp > 59)
    581                         return(HANTRO_NOK);
    582                     pPicTiming->minutesValue[i] = tmp;
    583 
    584                     tmp = h264bsdGetBits(pStrmData, 5);
    585                     if (tmp == END_OF_STREAM)
    586                         return(HANTRO_NOK);
    587                     if (tmp > 23)
    588                         return(HANTRO_NOK);
    589                     pPicTiming->hoursValue[i] = tmp;
    590                 }
    591                 else
    592                 {
    593                     tmp = h264bsdGetBits(pStrmData, 1);
    594                     if (tmp == END_OF_STREAM)
    595                         return(HANTRO_NOK);
    596                     pPicTiming->secondsFlag[i] = tmp == 1 ?
    597                                     HANTRO_TRUE : HANTRO_FALSE;
    598 
    599                     if (pPicTiming->secondsFlag[i])
    600                     {
    601                         tmp = h264bsdGetBits(pStrmData, 6);
    602                         if (tmp == END_OF_STREAM)
    603                             return(HANTRO_NOK);
    604                         if (tmp > 59)
    605                             return(HANTRO_NOK);
    606                         pPicTiming->secondsValue[i] = tmp;
    607 
    608                         tmp = h264bsdGetBits(pStrmData, 1);
    609                         if (tmp == END_OF_STREAM)
    610                             return(HANTRO_NOK);
    611                         pPicTiming->minutesFlag[i] = tmp == 1 ?
    612                                     HANTRO_TRUE : HANTRO_FALSE;
    613 
    614                         if (pPicTiming->minutesFlag[i])
    615                         {
    616                             tmp = h264bsdGetBits(pStrmData, 6);
    617                             if (tmp == END_OF_STREAM)
    618                                 return(HANTRO_NOK);
    619                             if (tmp > 59)
    620                                 return(HANTRO_NOK);
    621                             pPicTiming->minutesValue[i] = tmp;
    622 
    623                             tmp = h264bsdGetBits(pStrmData, 1);
    624                             if (tmp == END_OF_STREAM)
    625                                 return(HANTRO_NOK);
    626                             pPicTiming->hoursFlag[i] = tmp == 1 ?
    627                                     HANTRO_TRUE : HANTRO_FALSE;
    628 
    629                             if (pPicTiming->hoursFlag[i])
    630                             {
    631                                 tmp = h264bsdGetBits(pStrmData, 5);
    632                                 if (tmp == END_OF_STREAM)
    633                                     return(HANTRO_NOK);
    634                                 if (tmp > 23)
    635                                     return(HANTRO_NOK);
    636                                 pPicTiming->hoursValue[i] = tmp;
    637                             }
    638                         }
    639                     }
    640                 }
    641                 if (timeOffsetLength)
    642                 {
    643                     tmp = h264bsdGetBits(pStrmData, timeOffsetLength);
    644                     if (tmp == END_OF_STREAM)
    645                         return(HANTRO_NOK);
    646                     itmp = (i32)tmp;
    647                     /* following "converts" timeOffsetLength-bit signed
    648                      * integer into i32 */
    649                     /*lint -save -e701 -e702 */
    650                     itmp <<= (32 - timeOffsetLength);
    651                     itmp >>= (32 - timeOffsetLength);
    652                     /*lint -restore */
    653                     pPicTiming->timeOffset[i] = itmp;
    654                                     }
    655                 else
    656                     pPicTiming->timeOffset[i] = 0;
    657             }
    658         }
    659     }
    660 
    661     return(HANTRO_OK);
    662 
    663 }
    664 
    665 /*------------------------------------------------------------------------------
    666 
    667     Function: DecodePanScanRectangle
    668 
    669         Functional description:
    670           <++>
    671         Inputs:
    672           <++>
    673         Outputs:
    674           <++>
    675 
    676 ------------------------------------------------------------------------------*/
    677 
    678 static u32 DecodePanScanRectangle(
    679   strmData_t *pStrmData,
    680   seiPanScanRect_t *pPanScanRectangle)
    681 {
    682 
    683 /* Variables */
    684 
    685     u32 tmp, i;
    686 
    687 /* Code */
    688 
    689     ASSERT(pStrmData);
    690     ASSERT(pPanScanRectangle);
    691 
    692 
    693     tmp = h264bsdDecodeExpGolombUnsigned(pStrmData,
    694       &pPanScanRectangle->panScanRectId);
    695     if (tmp != HANTRO_OK)
    696         return(tmp);
    697 
    698     tmp = h264bsdGetBits(pStrmData, 1);
    699     if (tmp == END_OF_STREAM)
    700         return(HANTRO_NOK);
    701     pPanScanRectangle->panScanRectCancelFlag = tmp == 1 ?
    702                                 HANTRO_TRUE : HANTRO_FALSE;
    703 
    704     if (!pPanScanRectangle->panScanRectCancelFlag)
    705     {
    706         tmp = h264bsdDecodeExpGolombUnsigned(pStrmData,
    707           &pPanScanRectangle->panScanCnt);
    708         if (tmp != HANTRO_OK)
    709             return(tmp);
    710         if (pPanScanRectangle->panScanCnt > 2)
    711             return(HANTRO_NOK);
    712         pPanScanRectangle->panScanCnt++;
    713 
    714         for (i = 0; i < pPanScanRectangle->panScanCnt; i++)
    715         {
    716             tmp = h264bsdDecodeExpGolombSigned(pStrmData,
    717               &pPanScanRectangle->panScanRectLeftOffset[i]);
    718             if (tmp != HANTRO_OK)
    719                 return(tmp);
    720 
    721             tmp = h264bsdDecodeExpGolombSigned(pStrmData,
    722               &pPanScanRectangle->panScanRectRightOffset[i]);
    723             if (tmp != HANTRO_OK)
    724                 return(tmp);
    725 
    726             tmp = h264bsdDecodeExpGolombSigned(pStrmData,
    727               &pPanScanRectangle->panScanRectTopOffset[i]);
    728             if (tmp != HANTRO_OK)
    729                 return(tmp);
    730 
    731             tmp = h264bsdDecodeExpGolombSigned(pStrmData,
    732               &pPanScanRectangle->panScanRectBottomOffset[i]);
    733             if (tmp != HANTRO_OK)
    734                 return(tmp);
    735         }
    736         tmp = h264bsdDecodeExpGolombUnsigned(pStrmData,
    737           &pPanScanRectangle->panScanRectRepetitionPeriod);
    738         if (tmp != HANTRO_OK)
    739             return(tmp);
    740         if (pPanScanRectangle->panScanRectRepetitionPeriod > 16384)
    741             return(HANTRO_NOK);
    742         if (pPanScanRectangle->panScanCnt > 1 &&
    743           pPanScanRectangle->panScanRectRepetitionPeriod > 1)
    744             return(HANTRO_NOK);
    745     }
    746 
    747     return(HANTRO_OK);
    748 }
    749 
    750 /*------------------------------------------------------------------------------
    751 
    752     Function: DecodeFillerPayload
    753 
    754         Functional description:
    755           <++>
    756         Inputs:
    757           <++>
    758         Outputs:
    759           <++>
    760 
    761 ------------------------------------------------------------------------------*/
    762 
    763 static u32 DecodeFillerPayload(strmData_t *pStrmData, u32 payloadSize)
    764 {
    765 
    766 /* Variables */
    767 
    768 /* Code */
    769 
    770     ASSERT(pStrmData);
    771 
    772 
    773     if (payloadSize)
    774         if (h264bsdFlushBits(pStrmData, 8 * payloadSize) == END_OF_STREAM)
    775             return(HANTRO_NOK);
    776 
    777     return(HANTRO_OK);
    778 
    779 }
    780 
    781 /*------------------------------------------------------------------------------
    782 
    783     Function: DecodeUserDataRegisteredITuTT35
    784 
    785         Functional description:
    786           <++>
    787         Inputs:
    788           <++>
    789         Outputs:
    790           <++>
    791 
    792 ------------------------------------------------------------------------------*/
    793 
    794 static u32 DecodeUserDataRegisteredITuTT35(
    795   strmData_t *pStrmData,
    796   seiUserDataRegisteredItuTT35_t *pUserDataRegisteredItuTT35,
    797   u32 payloadSize)
    798 {
    799 
    800 /* Variables */
    801 
    802     u32 tmp, i, j;
    803 
    804 /* Code */
    805 
    806     ASSERT(pStrmData);
    807     ASSERT(pUserDataRegisteredItuTT35);
    808     ASSERT(payloadSize);
    809 
    810         tmp = h264bsdGetBits(pStrmData, 8);
    811     if (tmp == END_OF_STREAM)
    812         return(HANTRO_NOK);
    813     pUserDataRegisteredItuTT35->ituTT35CountryCode = tmp;
    814 
    815     if (pUserDataRegisteredItuTT35->ituTT35CountryCode != 0xFF)
    816         i = 1;
    817     else
    818     {
    819         tmp = h264bsdGetBits(pStrmData, 8);
    820         if (tmp == END_OF_STREAM)
    821             return(HANTRO_NOK);
    822         pUserDataRegisteredItuTT35->ituTT35CountryCodeExtensionByte = tmp;
    823         i = 2;
    824     }
    825 
    826     /* where corresponding FREE() ??? */
    827     ALLOCATE(pUserDataRegisteredItuTT35->ituTT35PayloadByte,payloadSize-i,u8);
    828     pUserDataRegisteredItuTT35->numPayloadBytes = payloadSize - i;
    829     if (pUserDataRegisteredItuTT35->ituTT35PayloadByte == NULL)
    830         return(MEMORY_ALLOCATION_ERROR);
    831 
    832     j = 0;
    833     do
    834     {
    835         tmp = h264bsdGetBits(pStrmData, 8);
    836         if (tmp == END_OF_STREAM)
    837             return(HANTRO_NOK);
    838         pUserDataRegisteredItuTT35->ituTT35PayloadByte[j] = (u8)tmp;
    839         i++;
    840         j++;
    841     } while (i < payloadSize);
    842 
    843     return(HANTRO_OK);
    844 
    845 }
    846 
    847 /*------------------------------------------------------------------------------
    848 
    849     Function: DecodeUserDataUnregistered
    850 
    851         Functional description:
    852           <++>
    853         Inputs:
    854           <++>
    855         Outputs:
    856           <++>
    857 
    858 ------------------------------------------------------------------------------*/
    859 
    860 static u32 DecodeUserDataUnregistered(
    861   strmData_t *pStrmData,
    862   seiUserDataUnregistered_t *pUserDataUnregistered,
    863   u32 payloadSize)
    864 {
    865 
    866 /* Variables */
    867 
    868     u32 i, tmp;
    869 
    870 /* Code */
    871 
    872     ASSERT(pStrmData);
    873     ASSERT(pUserDataUnregistered);
    874 
    875 
    876     for (i = 0; i < 4; i++)
    877     {
    878         pUserDataUnregistered->uuidIsoIec11578[i] = h264bsdShowBits32(pStrmData);
    879         if (h264bsdFlushBits(pStrmData,32) == END_OF_STREAM)
    880             return(HANTRO_NOK);
    881     }
    882 
    883     /* where corresponding FREE() ??? */
    884     ALLOCATE(pUserDataUnregistered->userDataPayloadByte, payloadSize - 16, u8);
    885     if (pUserDataUnregistered->userDataPayloadByte == NULL)
    886         return(MEMORY_ALLOCATION_ERROR);
    887 
    888     pUserDataUnregistered->numPayloadBytes = payloadSize - 16;
    889 
    890     for (i = 0; i < payloadSize - 16; i++)
    891     {
    892         tmp = h264bsdGetBits(pStrmData, 8);
    893         if (tmp == END_OF_STREAM)
    894             return(HANTRO_NOK);
    895         pUserDataUnregistered->userDataPayloadByte[i] = (u8)tmp;
    896     }
    897 
    898     return(HANTRO_OK);
    899 
    900 }
    901 
    902 /*------------------------------------------------------------------------------
    903 
    904     Function: DecodeRecoveryPoint
    905 
    906         Functional description:
    907           <++>
    908         Inputs:
    909           <++>
    910         Outputs:
    911           <++>
    912 
    913 ------------------------------------------------------------------------------*/
    914 
    915 static u32 DecodeRecoveryPoint(
    916   strmData_t *pStrmData,
    917   seiRecoveryPoint_t *pRecoveryPoint)
    918 {
    919 
    920 /* Variables */
    921 
    922     u32 tmp;
    923 
    924 /* Code */
    925 
    926     ASSERT(pStrmData);
    927     ASSERT(pRecoveryPoint);
    928 
    929 
    930     tmp = h264bsdDecodeExpGolombUnsigned(pStrmData,
    931         &pRecoveryPoint->recoveryFrameCnt);
    932     if (tmp != HANTRO_OK)
    933         return(tmp);
    934 
    935     tmp = h264bsdGetBits(pStrmData, 1);
    936     if (tmp == END_OF_STREAM)
    937         return(HANTRO_NOK);
    938     pRecoveryPoint->exactMatchFlag = tmp == 1 ? HANTRO_TRUE : HANTRO_FALSE;
    939 
    940     tmp = h264bsdGetBits(pStrmData, 1);
    941     if (tmp == END_OF_STREAM)
    942         return(HANTRO_NOK);
    943     pRecoveryPoint->brokenLinkFlag = tmp == 1 ? HANTRO_TRUE : HANTRO_FALSE;
    944 
    945     tmp = h264bsdGetBits(pStrmData, 2);
    946     if (tmp == END_OF_STREAM)
    947         return(HANTRO_NOK);
    948     if (tmp > 2)
    949         return(HANTRO_NOK);
    950     pRecoveryPoint->changingSliceGroupIdc = tmp;
    951 
    952     return(HANTRO_OK);
    953 
    954 }
    955 
    956 /*------------------------------------------------------------------------------
    957 
    958     Function: DecodeDecRefPicMarkingRepetition
    959 
    960         Functional description:
    961           <++>
    962         Inputs:
    963           <++>
    964         Outputs:
    965           <++>
    966 
    967 ------------------------------------------------------------------------------*/
    968 
    969 static u32 DecodeDecRefPicMarkingRepetition(
    970   strmData_t *pStrmData,
    971   seiDecRefPicMarkingRepetition_t *pDecRefPicMarkingRepetition,
    972   u32 numRefFrames)
    973 {
    974 
    975 /* Variables */
    976 
    977     u32 tmp;
    978 
    979 /* Code */
    980 
    981     ASSERT(pStrmData);
    982     ASSERT(pDecRefPicMarkingRepetition);
    983 
    984 
    985     tmp = h264bsdGetBits(pStrmData, 1);
    986     if (tmp == END_OF_STREAM)
    987         return(HANTRO_NOK);
    988     pDecRefPicMarkingRepetition->originalIdrFlag = tmp == 1 ? HANTRO_TRUE : HANTRO_FALSE;
    989 
    990     tmp = h264bsdDecodeExpGolombUnsigned(pStrmData,
    991       &pDecRefPicMarkingRepetition->originalFrameNum);
    992     if (tmp != HANTRO_OK)
    993         return(tmp);
    994 
    995     /* frame_mbs_only_flag assumed always true so some field related syntax
    996      * elements are skipped, see H.264 standard */
    997     tmp = h264bsdDecRefPicMarking(pStrmData,
    998       &pDecRefPicMarkingRepetition->decRefPicMarking, NAL_SEI, numRefFrames);
    999 
   1000     return(tmp);
   1001 
   1002 }
   1003 
   1004 /*------------------------------------------------------------------------------
   1005 
   1006     Function: DecodeSparePic
   1007 
   1008         Functional description:
   1009           <++>
   1010         Inputs:
   1011           <++>
   1012         Outputs:
   1013           <++>
   1014 
   1015 ------------------------------------------------------------------------------*/
   1016 
   1017 static u32 DecodeSparePic(
   1018   strmData_t *pStrmData,
   1019   seiSparePic_t *pSparePic,
   1020   u32 picSizeInMapUnits)
   1021 {
   1022 
   1023 /* Variables */
   1024 
   1025     u32 tmp, i, j, mapUnitCnt;
   1026 
   1027 /* Code */
   1028 
   1029     ASSERT(pStrmData);
   1030     ASSERT(pSparePic);
   1031 
   1032 
   1033     tmp = h264bsdDecodeExpGolombUnsigned(pStrmData,
   1034         &pSparePic->targetFrameNum);
   1035     if (tmp != HANTRO_OK)
   1036         return(tmp);
   1037 
   1038     tmp = h264bsdGetBits(pStrmData, 1);
   1039     if (tmp == END_OF_STREAM)
   1040         return(HANTRO_NOK);
   1041     pSparePic->spareFieldFlag = tmp == 1 ? HANTRO_TRUE : HANTRO_FALSE;
   1042     /* do not accept fields */
   1043     if (pSparePic->spareFieldFlag)
   1044         return(HANTRO_NOK);
   1045 
   1046     tmp = h264bsdDecodeExpGolombUnsigned(pStrmData, &pSparePic->numSparePics);
   1047     if (tmp != HANTRO_OK)
   1048         return(tmp);
   1049     pSparePic->numSparePics++;
   1050     if (pSparePic->numSparePics > MAX_NUM_SPARE_PICS)
   1051         return(HANTRO_NOK);
   1052 
   1053     for (i = 0; i < pSparePic->numSparePics; i++)
   1054     {
   1055         tmp = h264bsdDecodeExpGolombUnsigned(pStrmData,
   1056           &pSparePic->deltaSpareFrameNum[i]);
   1057         if (tmp != HANTRO_OK)
   1058             return(tmp);
   1059 
   1060         tmp = h264bsdDecodeExpGolombUnsigned(pStrmData,
   1061             &pSparePic->spareAreaIdc[i]);
   1062         if (tmp != HANTRO_OK)
   1063             return(tmp);
   1064         if (pSparePic->spareAreaIdc[i] > 2)
   1065             return(HANTRO_NOK);
   1066 
   1067         if (pSparePic->spareAreaIdc[i] == 1)
   1068         {
   1069             /* where corresponding FREE() ??? */
   1070             ALLOCATE(pSparePic->spareUnitFlag[i], picSizeInMapUnits, u32);
   1071             if (pSparePic->spareUnitFlag[i] == NULL)
   1072                 return(MEMORY_ALLOCATION_ERROR);
   1073             pSparePic->zeroRunLength[i] = NULL;
   1074 
   1075             for (j = 0; j < picSizeInMapUnits; j++)
   1076             {
   1077                 tmp = h264bsdGetBits(pStrmData, 1);
   1078                 if (tmp == END_OF_STREAM)
   1079                     return(HANTRO_NOK);
   1080                 pSparePic->spareUnitFlag[i][j] = tmp == 1 ?
   1081                                     HANTRO_TRUE : HANTRO_FALSE;
   1082             }
   1083         }
   1084         else if (pSparePic->spareAreaIdc[i] == 2)
   1085         {
   1086             /* where corresponding FREE() ??? */
   1087             ALLOCATE(pSparePic->zeroRunLength[i], picSizeInMapUnits, u32);
   1088             if (pSparePic->zeroRunLength[i] == NULL)
   1089                 return(MEMORY_ALLOCATION_ERROR);
   1090             pSparePic->spareUnitFlag[i] = NULL;
   1091 
   1092             for (j = 0, mapUnitCnt = 0; mapUnitCnt < picSizeInMapUnits; j++)
   1093             {
   1094                 tmp = h264bsdDecodeExpGolombUnsigned(pStrmData,
   1095                   &pSparePic->zeroRunLength[i][j]);
   1096                 if (tmp != HANTRO_OK)
   1097                     return(tmp);
   1098                 mapUnitCnt += pSparePic->zeroRunLength[i][j] + 1;
   1099             }
   1100         }
   1101     }
   1102 
   1103     /* set rest to null */
   1104     for (i = pSparePic->numSparePics; i < MAX_NUM_SPARE_PICS; i++)
   1105     {
   1106         pSparePic->spareUnitFlag[i] = NULL;
   1107         pSparePic->zeroRunLength[i] = NULL;
   1108     }
   1109 
   1110     return(HANTRO_OK);
   1111 
   1112 }
   1113 
   1114 /*------------------------------------------------------------------------------
   1115 
   1116     Function: DecodeSceneInfo
   1117 
   1118         Functional description:
   1119           <++>
   1120         Inputs:
   1121           <++>
   1122         Outputs:
   1123           <++>
   1124 
   1125 ------------------------------------------------------------------------------*/
   1126 
   1127 static u32 DecodeSceneInfo(
   1128   strmData_t *pStrmData,
   1129   seiSceneInfo_t *pSceneInfo)
   1130 {
   1131 
   1132 /* Variables */
   1133 
   1134     u32 tmp;
   1135 
   1136 /* Code */
   1137 
   1138     ASSERT(pStrmData);
   1139     ASSERT(pSceneInfo);
   1140 
   1141 
   1142     tmp = h264bsdGetBits(pStrmData, 1);
   1143     if (tmp == END_OF_STREAM)
   1144         return(HANTRO_NOK);
   1145     pSceneInfo->sceneInfoPresentFlag = tmp == 1 ? HANTRO_TRUE : HANTRO_FALSE;
   1146 
   1147     if (pSceneInfo->sceneInfoPresentFlag)
   1148     {
   1149         tmp = h264bsdDecodeExpGolombUnsigned(pStrmData, &pSceneInfo->sceneId);
   1150         if (tmp != HANTRO_OK)
   1151             return(tmp);
   1152 
   1153         tmp = h264bsdDecodeExpGolombUnsigned(pStrmData,
   1154           &pSceneInfo->sceneTransitionType);
   1155         if (tmp != HANTRO_OK)
   1156             return(tmp);
   1157         if (pSceneInfo->sceneTransitionType > 6)
   1158             return(HANTRO_NOK);
   1159 
   1160         if (pSceneInfo->sceneTransitionType)
   1161         {
   1162             tmp = h264bsdDecodeExpGolombUnsigned(pStrmData,
   1163               &pSceneInfo->secondSceneId);
   1164             if (tmp != HANTRO_OK)
   1165                 return(tmp);
   1166         }
   1167 
   1168     }
   1169 
   1170     return(HANTRO_OK);
   1171 
   1172 }
   1173 
   1174 /*------------------------------------------------------------------------------
   1175 
   1176     Function: DecodeSubSeqInfo
   1177 
   1178         Functional description:
   1179           <++>
   1180         Inputs:
   1181           <++>
   1182         Outputs:
   1183           <++>
   1184 
   1185 -----------------------------------------------------------------------------*/
   1186 
   1187 static u32 DecodeSubSeqInfo(
   1188   strmData_t *pStrmData,
   1189   seiSubSeqInfo_t *pSubSeqInfo)
   1190 {
   1191 
   1192 /* Variables */
   1193 
   1194     u32 tmp;
   1195 
   1196 /* Code */
   1197 
   1198     ASSERT(pStrmData);
   1199     ASSERT(pSubSeqInfo);
   1200 
   1201 
   1202     tmp = h264bsdDecodeExpGolombUnsigned(pStrmData,
   1203         &pSubSeqInfo->subSeqLayerNum);
   1204     if (tmp != HANTRO_OK)
   1205         return(tmp);
   1206     if (pSubSeqInfo->subSeqLayerNum > 255)
   1207         return(HANTRO_NOK);
   1208 
   1209     tmp = h264bsdDecodeExpGolombUnsigned(pStrmData, &pSubSeqInfo->subSeqId);
   1210     if (tmp != HANTRO_OK)
   1211         return(tmp);
   1212     if (pSubSeqInfo->subSeqId > 65535)
   1213         return(HANTRO_NOK);
   1214 
   1215     tmp = h264bsdGetBits(pStrmData, 1);
   1216     if (tmp == END_OF_STREAM)
   1217         return(HANTRO_NOK);
   1218     pSubSeqInfo->firstRefPicFlag = tmp == 1 ? HANTRO_TRUE : HANTRO_FALSE;
   1219 
   1220     tmp = h264bsdGetBits(pStrmData, 1);
   1221     if (tmp == END_OF_STREAM)
   1222         return(HANTRO_NOK);
   1223     pSubSeqInfo->leadingNonRefPicFlag = tmp == 1 ? HANTRO_TRUE : HANTRO_FALSE;
   1224 
   1225     tmp = h264bsdGetBits(pStrmData, 1);
   1226     if (tmp == END_OF_STREAM)
   1227         return(HANTRO_NOK);
   1228     pSubSeqInfo->lastPicFlag = tmp == 1 ? HANTRO_TRUE : HANTRO_FALSE;
   1229 
   1230     tmp = h264bsdGetBits(pStrmData, 1);
   1231     if (tmp == END_OF_STREAM)
   1232         return(HANTRO_NOK);
   1233     pSubSeqInfo->subSeqFrameNumFlag = tmp == 1 ? HANTRO_TRUE : HANTRO_FALSE;
   1234 
   1235     if (pSubSeqInfo->subSeqFrameNumFlag)
   1236     {
   1237         tmp = h264bsdDecodeExpGolombUnsigned(pStrmData,
   1238             &pSubSeqInfo->subSeqFrameNum);
   1239         if (tmp != HANTRO_OK)
   1240             return(tmp);
   1241     }
   1242 
   1243     return(HANTRO_OK);
   1244 
   1245 }
   1246 
   1247 /*------------------------------------------------------------------------------
   1248 
   1249     Function: DecodeSubSeqLayerCharacteristics
   1250 
   1251         Functional description:
   1252           <++>
   1253         Inputs:
   1254           <++>
   1255         Outputs:
   1256           <++>
   1257 
   1258 ------------------------------------------------------------------------------*/
   1259 
   1260 static u32 DecodeSubSeqLayerCharacteristics(
   1261   strmData_t *pStrmData,
   1262   seiSubSeqLayerCharacteristics_t *pSubSeqLayerCharacteristics)
   1263 {
   1264 
   1265 /* Variables */
   1266 
   1267     u32 tmp, i;
   1268 
   1269 /* Code */
   1270 
   1271     ASSERT(pStrmData);
   1272     ASSERT(pSubSeqLayerCharacteristics);
   1273 
   1274 
   1275     tmp = h264bsdDecodeExpGolombUnsigned(pStrmData,
   1276       &pSubSeqLayerCharacteristics->numSubSeqLayers);
   1277     if (tmp != HANTRO_OK)
   1278         return(tmp);
   1279     pSubSeqLayerCharacteristics->numSubSeqLayers++;
   1280     if (pSubSeqLayerCharacteristics->numSubSeqLayers > MAX_NUM_SUB_SEQ_LAYERS)
   1281         return(HANTRO_NOK);
   1282 
   1283     for (i = 0; i < pSubSeqLayerCharacteristics->numSubSeqLayers; i++)
   1284     {
   1285         tmp = h264bsdGetBits(pStrmData, 1);
   1286         if (tmp == END_OF_STREAM)
   1287             return(HANTRO_NOK);
   1288         pSubSeqLayerCharacteristics->accurateStatisticsFlag[i] =
   1289             tmp == 1 ? HANTRO_TRUE : HANTRO_FALSE;
   1290 
   1291         tmp = h264bsdGetBits(pStrmData, 16);
   1292         if (tmp == END_OF_STREAM)
   1293             return(HANTRO_NOK);
   1294         pSubSeqLayerCharacteristics->averageBitRate[i] = tmp;
   1295 
   1296         tmp = h264bsdGetBits(pStrmData, 16);
   1297         if (tmp == END_OF_STREAM)
   1298             return(HANTRO_NOK);
   1299         pSubSeqLayerCharacteristics->averageFrameRate[i] = tmp;
   1300     }
   1301 
   1302     return(HANTRO_OK);
   1303 
   1304 }
   1305 
   1306 /*------------------------------------------------------------------------------
   1307 
   1308     Function: DecodeSubSeqCharacteristics
   1309 
   1310         Functional description:
   1311           <++>
   1312         Inputs:
   1313           <++>
   1314         Outputs:
   1315           <++>
   1316 
   1317 ------------------------------------------------------------------------------*/
   1318 
   1319 static u32 DecodeSubSeqCharacteristics(
   1320   strmData_t *pStrmData,
   1321   seiSubSeqCharacteristics_t *pSubSeqCharacteristics)
   1322 {
   1323 
   1324 /* Variables */
   1325 
   1326     u32 tmp, i;
   1327 
   1328 /* Code */
   1329 
   1330     ASSERT(pStrmData);
   1331     ASSERT(pSubSeqCharacteristics);
   1332 
   1333 
   1334     tmp = h264bsdDecodeExpGolombUnsigned(pStrmData,
   1335       &pSubSeqCharacteristics->subSeqLayerNum);
   1336     if (tmp != HANTRO_OK)
   1337         return(tmp);
   1338     if (pSubSeqCharacteristics->subSeqLayerNum > MAX_NUM_SUB_SEQ_LAYERS-1)
   1339         return(HANTRO_NOK);
   1340 
   1341     tmp = h264bsdDecodeExpGolombUnsigned(pStrmData,
   1342         &pSubSeqCharacteristics->subSeqId);
   1343     if (tmp != HANTRO_OK)
   1344         return(tmp);
   1345     if (pSubSeqCharacteristics->subSeqId > 65535)
   1346         return(HANTRO_NOK);
   1347 
   1348     tmp = h264bsdGetBits(pStrmData, 1);
   1349     if (tmp == END_OF_STREAM)
   1350         return(HANTRO_NOK);
   1351     pSubSeqCharacteristics->durationFlag = tmp == 1 ?
   1352                             HANTRO_TRUE : HANTRO_FALSE;
   1353 
   1354     if (pSubSeqCharacteristics->durationFlag)
   1355     {
   1356         pSubSeqCharacteristics->subSeqDuration = h264bsdShowBits32(pStrmData);
   1357         if (h264bsdFlushBits(pStrmData,32) == END_OF_STREAM)
   1358             return(HANTRO_NOK);
   1359     }
   1360 
   1361     tmp = h264bsdGetBits(pStrmData, 1);
   1362     if (tmp == END_OF_STREAM)
   1363         return(HANTRO_NOK);
   1364     pSubSeqCharacteristics->averageRateFlag = tmp == 1 ?
   1365                             HANTRO_TRUE : HANTRO_FALSE;
   1366 
   1367     if (pSubSeqCharacteristics->averageRateFlag)
   1368     {
   1369         tmp = h264bsdGetBits(pStrmData, 1);
   1370         if (tmp == END_OF_STREAM)
   1371             return(HANTRO_NOK);
   1372         pSubSeqCharacteristics->accurateStatisticsFlag =
   1373             tmp == 1 ? HANTRO_TRUE : HANTRO_FALSE;
   1374 
   1375         tmp = h264bsdGetBits(pStrmData, 16);
   1376         if (tmp == END_OF_STREAM)
   1377             return(HANTRO_NOK);
   1378         pSubSeqCharacteristics->averageBitRate = tmp;
   1379 
   1380         tmp = h264bsdGetBits(pStrmData, 16);
   1381         if (tmp == END_OF_STREAM)
   1382             return(HANTRO_NOK);
   1383         pSubSeqCharacteristics->averageFrameRate = tmp;
   1384     }
   1385 
   1386     tmp = h264bsdDecodeExpGolombUnsigned(pStrmData,
   1387       &pSubSeqCharacteristics->numReferencedSubseqs);
   1388     if (tmp != HANTRO_OK)
   1389         return(tmp);
   1390     if (pSubSeqCharacteristics->numReferencedSubseqs > MAX_NUM_SUB_SEQ_LAYERS-1)
   1391         return(HANTRO_NOK);
   1392 
   1393     for (i = 0; i < pSubSeqCharacteristics->numReferencedSubseqs; i++)
   1394     {
   1395         tmp = h264bsdDecodeExpGolombUnsigned(pStrmData,
   1396           &pSubSeqCharacteristics->refSubSeqLayerNum[i]);
   1397         if (tmp != HANTRO_OK)
   1398             return(tmp);
   1399 
   1400         tmp = h264bsdDecodeExpGolombUnsigned(pStrmData,
   1401           &pSubSeqCharacteristics->refSubSeqId[i]);
   1402         if (tmp != HANTRO_OK)
   1403             return(tmp);
   1404 
   1405         tmp = h264bsdGetBits(pStrmData, 1);
   1406         if (tmp == END_OF_STREAM)
   1407             return(HANTRO_NOK);
   1408         pSubSeqCharacteristics->refSubSeqDirection[i] = tmp;
   1409     }
   1410 
   1411     return(HANTRO_OK);
   1412 
   1413 }
   1414 
   1415 /*------------------------------------------------------------------------------
   1416 
   1417     Function: DecodeFullFrameFreeze
   1418 
   1419         Functional description:
   1420           <++>
   1421         Inputs:
   1422           <++>
   1423         Outputs:
   1424           <++>
   1425 
   1426 ------------------------------------------------------------------------------*/
   1427 
   1428 static u32 DecodeFullFrameFreeze(
   1429   strmData_t *pStrmData,
   1430   seiFullFrameFreeze_t *pFullFrameFreeze)
   1431 {
   1432 
   1433 /* Variables */
   1434 
   1435     u32 tmp;
   1436 
   1437 /* Code */
   1438 
   1439     ASSERT(pStrmData);
   1440     ASSERT(pFullFrameFreeze);
   1441 
   1442 
   1443     tmp = h264bsdDecodeExpGolombUnsigned(pStrmData,
   1444       &pFullFrameFreeze->fullFrameFreezeRepetitionPeriod);
   1445     if (tmp != HANTRO_OK)
   1446         return(tmp);
   1447     if (pFullFrameFreeze->fullFrameFreezeRepetitionPeriod > 16384)
   1448         return(HANTRO_NOK);
   1449 
   1450     return(HANTRO_OK);
   1451 
   1452 }
   1453 
   1454 /*------------------------------------------------------------------------------
   1455 
   1456     Function: DecodeFullFrameSnapshot
   1457 
   1458         Functional description:
   1459           <++>
   1460         Inputs:
   1461           <++>
   1462         Outputs:
   1463           <++>
   1464 
   1465 ------------------------------------------------------------------------------*/
   1466 
   1467 static u32 DecodeFullFrameSnapshot(
   1468   strmData_t *pStrmData,
   1469   seiFullFrameSnapshot_t *pFullFrameSnapshot)
   1470 {
   1471 
   1472 /* Variables */
   1473 
   1474     u32 tmp;
   1475 
   1476 /* Code */
   1477 
   1478     ASSERT(pStrmData);
   1479     ASSERT(pFullFrameSnapshot);
   1480 
   1481 
   1482     tmp = h264bsdDecodeExpGolombUnsigned(pStrmData,
   1483         &pFullFrameSnapshot->snapShotId);
   1484     if (tmp != HANTRO_OK)
   1485         return(tmp);
   1486 
   1487     return(HANTRO_OK);
   1488 
   1489 }
   1490 
   1491 /*------------------------------------------------------------------------------
   1492 
   1493     Function: DecodeProgressiveRefinementSegmentStart
   1494 
   1495         Functional description:
   1496           <++>
   1497         Inputs:
   1498           <++>
   1499         Outputs:
   1500           <++>
   1501 
   1502 ------------------------------------------------------------------------------*/
   1503 
   1504 static u32 DecodeProgressiveRefinementSegmentStart(
   1505   strmData_t *pStrmData,
   1506   seiProgressiveRefinementSegmentStart_t *pProgressiveRefinementSegmentStart)
   1507 {
   1508 
   1509 /* Variables */
   1510 
   1511     u32 tmp;
   1512 
   1513 /* Code */
   1514 
   1515     ASSERT(pStrmData);
   1516     ASSERT(pProgressiveRefinementSegmentStart);
   1517 
   1518 
   1519     tmp = h264bsdDecodeExpGolombUnsigned(pStrmData,
   1520       &pProgressiveRefinementSegmentStart->progressiveRefinementId);
   1521     if (tmp != HANTRO_OK)
   1522         return(tmp);
   1523 
   1524     tmp = h264bsdDecodeExpGolombUnsigned(pStrmData,
   1525       &pProgressiveRefinementSegmentStart->numRefinementSteps);
   1526     if (tmp != HANTRO_OK)
   1527         return(tmp);
   1528     pProgressiveRefinementSegmentStart->numRefinementSteps++;
   1529 
   1530     return(HANTRO_OK);
   1531 
   1532 }
   1533 
   1534 /*------------------------------------------------------------------------------
   1535 
   1536     Function: DecodeProgressiveRefinementSegmentEnd
   1537 
   1538         Functional description:
   1539           <++>
   1540         Inputs:
   1541           <++>
   1542         Outputs:
   1543           <++>
   1544 
   1545 ------------------------------------------------------------------------------*/
   1546 
   1547 static u32 DecodeProgressiveRefinementSegmentEnd(
   1548   strmData_t *pStrmData,
   1549   seiProgressiveRefinementSegmentEnd_t *pProgressiveRefinementSegmentEnd)
   1550 {
   1551 
   1552 /* Variables */
   1553 
   1554     u32 tmp;
   1555 
   1556 /* Code */
   1557 
   1558     ASSERT(pStrmData);
   1559     ASSERT(pProgressiveRefinementSegmentEnd);
   1560 
   1561 
   1562     tmp = h264bsdDecodeExpGolombUnsigned(pStrmData,
   1563       &pProgressiveRefinementSegmentEnd->progressiveRefinementId);
   1564     if (tmp != HANTRO_OK)
   1565         return(tmp);
   1566 
   1567     return(HANTRO_OK);
   1568 
   1569 }
   1570 
   1571 /*------------------------------------------------------------------------------
   1572 
   1573     Function: DecodeMotionConstrainedSliceGroupSet
   1574 
   1575         Functional description:
   1576           <++>
   1577         Inputs:
   1578           <++>
   1579         Outputs:
   1580           <++>
   1581 
   1582 ------------------------------------------------------------------------------*/
   1583 
   1584 static u32 DecodeMotionConstrainedSliceGroupSet(
   1585   strmData_t *pStrmData,
   1586   seiMotionConstrainedSliceGroupSet_t *pMotionConstrainedSliceGroupSet,
   1587   u32 numSliceGroups)
   1588 {
   1589 
   1590 /* Variables */
   1591 
   1592     u32 tmp,i;
   1593 
   1594 /* Code */
   1595 
   1596     ASSERT(pStrmData);
   1597     ASSERT(pMotionConstrainedSliceGroupSet);
   1598     ASSERT(numSliceGroups < MAX_NUM_SLICE_GROUPS);
   1599 
   1600 
   1601     tmp = h264bsdDecodeExpGolombUnsigned(pStrmData,
   1602       &pMotionConstrainedSliceGroupSet->numSliceGroupsInSet);
   1603     if (tmp != HANTRO_OK)
   1604         return(tmp);
   1605     pMotionConstrainedSliceGroupSet->numSliceGroupsInSet++;
   1606     if (pMotionConstrainedSliceGroupSet->numSliceGroupsInSet > numSliceGroups)
   1607         return(HANTRO_NOK);
   1608 
   1609     for (i = 0; i < pMotionConstrainedSliceGroupSet->numSliceGroupsInSet; i++)
   1610     {
   1611         tmp = h264bsdGetBits(pStrmData,
   1612             ceilLog2NumSliceGroups[numSliceGroups]);
   1613         if (tmp == END_OF_STREAM)
   1614             return(HANTRO_NOK);
   1615         pMotionConstrainedSliceGroupSet->sliceGroupId[i] = tmp;
   1616         if (pMotionConstrainedSliceGroupSet->sliceGroupId[i] >
   1617           pMotionConstrainedSliceGroupSet->numSliceGroupsInSet-1)
   1618             return(HANTRO_NOK);
   1619     }
   1620 
   1621     tmp = h264bsdGetBits(pStrmData, 1);
   1622     if (tmp == END_OF_STREAM)
   1623         return(HANTRO_NOK);
   1624     pMotionConstrainedSliceGroupSet->exactSampleValueMatchFlag =
   1625         tmp == 1 ? HANTRO_TRUE : HANTRO_FALSE;
   1626 
   1627     tmp = h264bsdGetBits(pStrmData, 1);
   1628     if (tmp == END_OF_STREAM)
   1629         return(HANTRO_NOK);
   1630     pMotionConstrainedSliceGroupSet->panScanRectFlag = tmp == 1 ?
   1631                                         HANTRO_TRUE : HANTRO_FALSE;
   1632 
   1633     if (pMotionConstrainedSliceGroupSet->panScanRectFlag)
   1634     {
   1635         tmp = h264bsdDecodeExpGolombUnsigned(pStrmData,
   1636           &pMotionConstrainedSliceGroupSet->panScanRectId);
   1637         if (tmp != HANTRO_OK)
   1638             return(tmp);
   1639     }
   1640 
   1641     return(HANTRO_OK);
   1642 
   1643 }
   1644 
   1645 /*------------------------------------------------------------------------------
   1646 
   1647     Function: DecodeReservedSeiMessage
   1648 
   1649         Functional description:
   1650           <++>
   1651         Inputs:
   1652           <++>
   1653         Outputs:
   1654           <++>
   1655 
   1656 ------------------------------------------------------------------------------*/
   1657 
   1658 static u32 DecodeReservedSeiMessage(
   1659   strmData_t *pStrmData,
   1660   seiReservedSeiMessage_t *pReservedSeiMessage,
   1661   u32 payloadSize)
   1662 {
   1663 
   1664 /* Variables */
   1665 
   1666     u32 i, tmp;
   1667 
   1668 /* Code */
   1669 
   1670     ASSERT(pStrmData);
   1671     ASSERT(pReservedSeiMessage);
   1672 
   1673 
   1674     /* where corresponding FREE() ??? */
   1675     ALLOCATE(pReservedSeiMessage->reservedSeiMessagePayloadByte,payloadSize,u8);
   1676     if (pReservedSeiMessage->reservedSeiMessagePayloadByte == NULL)
   1677         return(MEMORY_ALLOCATION_ERROR);
   1678 
   1679     pReservedSeiMessage->numPayloadBytes = payloadSize;
   1680 
   1681     for (i = 0; i < payloadSize; i++)
   1682     {
   1683         tmp = h264bsdGetBits(pStrmData,8);
   1684         if (tmp == END_OF_STREAM)
   1685             return(HANTRO_NOK);
   1686         pReservedSeiMessage->reservedSeiMessagePayloadByte[i] = (u8)tmp;
   1687     }
   1688 
   1689     return(HANTRO_OK);
   1690 
   1691 }
   1692 
   1693