ref: 947024fb1ce0ab5b51a4464184969c6c06b4c966
dir: /src/h264bsd_seq_param_set.c/
/*
* Copyright (C) 2009 The Android Open Source Project
* Modified for use by h264bsd standalone library
*
* 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
h264bsdDecodeSeqParamSet
GetDpbSize
h264bsdCompareSeqParamSets
------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------
1. Include headers
------------------------------------------------------------------------------*/
#include "h264bsd_seq_param_set.h"
#include "h264bsd_util.h"
#include "h264bsd_vlc.h"
#include "h264bsd_vui.h"
#include "h264bsd_cfg.h"
/*------------------------------------------------------------------------------
2. External compiler flags
--------------------------------------------------------------------------------
--------------------------------------------------------------------------------
3. Module defines
------------------------------------------------------------------------------*/
/* enumeration to indicate invalid return value from the GetDpbSize function */
enum {INVALID_DPB_SIZE = 0x7FFFFFFF};
/*------------------------------------------------------------------------------
4. Local function prototypes
------------------------------------------------------------------------------*/
static u32 GetDpbSize(u32 picSizeInMbs, u32 levelIdc);
/*------------------------------------------------------------------------------
Function name: h264bsdDecodeSeqParamSet
Functional description:
Decode sequence parameter set information from the stream.
Function allocates memory for offsetForRefFrame array if
picture order count type is 1 and numRefFramesInPicOrderCntCycle
is greater than zero.
Inputs:
pStrmData pointer to stream data structure
Outputs:
pSeqParamSet decoded information is stored here
Returns:
HANTRO_OK success
HANTRO_NOK failure, invalid information or end of stream
MEMORY_ALLOCATION_ERROR for memory allocation failure
------------------------------------------------------------------------------*/
u32 h264bsdDecodeSeqParamSet(strmData_t *pStrmData, seqParamSet_t *pSeqParamSet)
{
/* Variables */
u32 tmp, i, value;
/* Code */
ASSERT(pStrmData);
ASSERT(pSeqParamSet);
memset(pSeqParamSet, 0, sizeof(seqParamSet_t));
/* profile_idc */
tmp = h264bsdGetBits(pStrmData, 8);
if (tmp == END_OF_STREAM)
return(HANTRO_NOK);
if (tmp != 66)
{
DEBUG(("NOT BASELINE PROFILE %d\n", tmp));
}
pSeqParamSet->profileIdc = tmp;
/* constrained_set0_flag */
tmp = h264bsdGetBits(pStrmData, 1);
/* constrained_set1_flag */
tmp = h264bsdGetBits(pStrmData, 1);
/* constrained_set2_flag */
tmp = h264bsdGetBits(pStrmData, 1);
if (tmp == END_OF_STREAM)
return(HANTRO_NOK);
/* reserved_zero_5bits, values of these bits shall be ignored */
tmp = h264bsdGetBits(pStrmData, 5);
if (tmp == END_OF_STREAM)
return(HANTRO_NOK);
tmp = h264bsdGetBits(pStrmData, 8);
if (tmp == END_OF_STREAM)
return(HANTRO_NOK);
pSeqParamSet->levelIdc = tmp;
tmp = h264bsdDecodeExpGolombUnsigned(pStrmData,
&pSeqParamSet->seqParameterSetId);
if (tmp != HANTRO_OK)
return(tmp);
if (pSeqParamSet->seqParameterSetId >= MAX_NUM_SEQ_PARAM_SETS)
{
EPRINT("seq_param_set_id");
return(HANTRO_NOK);
}
/* log2_max_frame_num_minus4 */
tmp = h264bsdDecodeExpGolombUnsigned(pStrmData, &value);
if (tmp != HANTRO_OK)
return(tmp);
if (value > 12)
{
EPRINT("log2_max_frame_num_minus4");
return(HANTRO_NOK);
}
/* maxFrameNum = 2^(log2_max_frame_num_minus4 + 4) */
pSeqParamSet->maxFrameNum = 1 << (value+4);
/* valid POC types are 0, 1 and 2 */
tmp = h264bsdDecodeExpGolombUnsigned(pStrmData, &value);
if (tmp != HANTRO_OK)
return(tmp);
if (value > 2)
{
EPRINT("pic_order_cnt_type");
return(HANTRO_NOK);
}
pSeqParamSet->picOrderCntType = value;
if (pSeqParamSet->picOrderCntType == 0)
{
/* log2_max_pic_order_cnt_lsb_minus4 */
tmp = h264bsdDecodeExpGolombUnsigned(pStrmData, &value);
if (tmp != HANTRO_OK)
return(tmp);
if (value > 12)
{
EPRINT("log2_max_pic_order_cnt_lsb_minus4");
return(HANTRO_NOK);
}
/* maxPicOrderCntLsb = 2^(log2_max_pic_order_cnt_lsb_minus4 + 4) */
pSeqParamSet->maxPicOrderCntLsb = 1 << (value+4);
}
else if (pSeqParamSet->picOrderCntType == 1)
{
tmp = h264bsdGetBits(pStrmData, 1);
if (tmp == END_OF_STREAM)
return(HANTRO_NOK);
pSeqParamSet->deltaPicOrderAlwaysZeroFlag = (tmp == 1) ?
HANTRO_TRUE : HANTRO_FALSE;
tmp = h264bsdDecodeExpGolombSigned(pStrmData,
&pSeqParamSet->offsetForNonRefPic);
if (tmp != HANTRO_OK)
return(tmp);
tmp = h264bsdDecodeExpGolombSigned(pStrmData,
&pSeqParamSet->offsetForTopToBottomField);
if (tmp != HANTRO_OK)
return(tmp);
tmp = h264bsdDecodeExpGolombUnsigned(pStrmData,
&pSeqParamSet->numRefFramesInPicOrderCntCycle);
if (tmp != HANTRO_OK)
return(tmp);
if (pSeqParamSet->numRefFramesInPicOrderCntCycle > 255)
{
EPRINT("num_ref_frames_in_pic_order_cnt_cycle");
return(HANTRO_NOK);
}
if (pSeqParamSet->numRefFramesInPicOrderCntCycle)
{
/* NOTE: This has to be freed somewhere! */
ALLOCATE(pSeqParamSet->offsetForRefFrame,
pSeqParamSet->numRefFramesInPicOrderCntCycle, i32);
if (pSeqParamSet->offsetForRefFrame == NULL)
return(MEMORY_ALLOCATION_ERROR);
for (i = 0; i < pSeqParamSet->numRefFramesInPicOrderCntCycle; i++)
{
tmp = h264bsdDecodeExpGolombSigned(pStrmData,
pSeqParamSet->offsetForRefFrame + i);
if (tmp != HANTRO_OK)
return(tmp);
}
}
else
{
pSeqParamSet->offsetForRefFrame = NULL;
}
}
tmp = h264bsdDecodeExpGolombUnsigned(pStrmData,
&pSeqParamSet->numRefFrames);
if (tmp != HANTRO_OK)
return(tmp);
if (pSeqParamSet->numRefFrames > MAX_NUM_REF_PICS)
{
EPRINT("num_ref_frames");
return(HANTRO_NOK);
}
tmp = h264bsdGetBits(pStrmData, 1);
if (tmp == END_OF_STREAM)
return(HANTRO_NOK);
pSeqParamSet->gapsInFrameNumValueAllowedFlag = (tmp == 1) ?
HANTRO_TRUE : HANTRO_FALSE;
tmp = h264bsdDecodeExpGolombUnsigned(pStrmData, &value);
if (tmp != HANTRO_OK)
return(tmp);
pSeqParamSet->picWidthInMbs = value + 1;
tmp = h264bsdDecodeExpGolombUnsigned(pStrmData, &value);
if (tmp != HANTRO_OK)
return(tmp);
pSeqParamSet->picHeightInMbs = value + 1;
/* frame_mbs_only_flag, shall be 1 for baseline profile */
tmp = h264bsdGetBits(pStrmData, 1);
if (tmp == END_OF_STREAM)
return(HANTRO_NOK);
if (!tmp)
{
EPRINT("frame_mbs_only_flag");
return(HANTRO_NOK);
}
/* direct_8x8_inference_flag */
tmp = h264bsdGetBits(pStrmData, 1);
if (tmp == END_OF_STREAM)
return(HANTRO_NOK);
tmp = h264bsdGetBits(pStrmData, 1);
if (tmp == END_OF_STREAM)
return(HANTRO_NOK);
pSeqParamSet->frameCroppingFlag = (tmp == 1) ? HANTRO_TRUE : HANTRO_FALSE;
if (pSeqParamSet->frameCroppingFlag)
{
tmp = h264bsdDecodeExpGolombUnsigned(pStrmData,
&pSeqParamSet->frameCropLeftOffset);
if (tmp != HANTRO_OK)
return(tmp);
tmp = h264bsdDecodeExpGolombUnsigned(pStrmData,
&pSeqParamSet->frameCropRightOffset);
if (tmp != HANTRO_OK)
return(tmp);
tmp = h264bsdDecodeExpGolombUnsigned(pStrmData,
&pSeqParamSet->frameCropTopOffset);
if (tmp != HANTRO_OK)
return(tmp);
tmp = h264bsdDecodeExpGolombUnsigned(pStrmData,
&pSeqParamSet->frameCropBottomOffset);
if (tmp != HANTRO_OK)
return(tmp);
/* check that frame cropping params are valid, parameters shall
* specify non-negative area within the original picture */
if ( ( (i32)pSeqParamSet->frameCropLeftOffset >
( 8 * (i32)pSeqParamSet->picWidthInMbs -
((i32)pSeqParamSet->frameCropRightOffset + 1) ) ) ||
( (i32)pSeqParamSet->frameCropTopOffset >
( 8 * (i32)pSeqParamSet->picHeightInMbs -
((i32)pSeqParamSet->frameCropBottomOffset + 1) ) ) )
{
EPRINT("frame_cropping");
return(HANTRO_NOK);
}
}
/* check that image dimensions and levelIdc match */
tmp = pSeqParamSet->picWidthInMbs * pSeqParamSet->picHeightInMbs;
value = GetDpbSize(tmp, pSeqParamSet->levelIdc);
if (value == INVALID_DPB_SIZE || pSeqParamSet->numRefFrames > value)
{
DEBUG(("WARNING! Invalid DPB size based on SPS Level!\n"));
DEBUG(("WARNING! Using num_ref_frames =%d for DPB size!\n",
pSeqParamSet->numRefFrames));
value = pSeqParamSet->numRefFrames;
}
pSeqParamSet->maxDpbSize = value;
tmp = h264bsdGetBits(pStrmData, 1);
if (tmp == END_OF_STREAM)
return(HANTRO_NOK);
pSeqParamSet->vuiParametersPresentFlag = (tmp == 1) ?
HANTRO_TRUE : HANTRO_FALSE;
/* VUI */
if (pSeqParamSet->vuiParametersPresentFlag)
{
ALLOCATE(pSeqParamSet->vuiParameters, 1, vuiParameters_t);
if (pSeqParamSet->vuiParameters == NULL)
return(MEMORY_ALLOCATION_ERROR);
tmp = h264bsdDecodeVuiParameters(pStrmData,
pSeqParamSet->vuiParameters);
if (tmp != HANTRO_OK)
return(tmp);
/* check numReorderFrames and maxDecFrameBuffering */
if (pSeqParamSet->vuiParameters->bitstreamRestrictionFlag)
{
if (pSeqParamSet->vuiParameters->numReorderFrames >
pSeqParamSet->vuiParameters->maxDecFrameBuffering ||
pSeqParamSet->vuiParameters->maxDecFrameBuffering <
pSeqParamSet->numRefFrames ||
pSeqParamSet->vuiParameters->maxDecFrameBuffering >
pSeqParamSet->maxDpbSize)
{
return(HANTRO_NOK);
}
/* standard says that "the sequence shall not require a DPB with
* size of more than max(1, maxDecFrameBuffering) */
pSeqParamSet->maxDpbSize =
MAX(1, pSeqParamSet->vuiParameters->maxDecFrameBuffering);
}
}
tmp = h264bsdRbspTrailingBits(pStrmData);
/* ignore possible errors in trailing bits of parameters sets */
return(HANTRO_OK);
}
/*------------------------------------------------------------------------------
Function: GetDpbSize
Functional description:
Get size of the DPB in frames. Size is determined based on the
picture size and MaxDPB for the specified level. These determine
how many pictures may fit into to the buffer. However, the size
is also limited to a maximum of 16 frames and therefore function
returns the minimum of the determined size and 16.
Inputs:
picSizeInMbs number of macroblocks in the picture
levelIdc indicates the level
Outputs:
none
Returns:
size of the DPB in frames
INVALID_DPB_SIZE when invalid levelIdc specified or picSizeInMbs
is higher than supported by the level in question
------------------------------------------------------------------------------*/
u32 GetDpbSize(u32 picSizeInMbs, u32 levelIdc)
{
/* Variables */
u32 tmp;
u32 maxPicSizeInMbs;
/* Code */
ASSERT(picSizeInMbs);
/* use tmp as the size of the DPB in bytes, computes as 1024 * MaxDPB
* (from table A-1 in Annex A) */
switch (levelIdc)
{
case 10:
tmp = 152064;
maxPicSizeInMbs = 99;
break;
case 11:
tmp = 345600;
maxPicSizeInMbs = 396;
break;
case 12:
tmp = 912384;
maxPicSizeInMbs = 396;
break;
case 13:
tmp = 912384;
maxPicSizeInMbs = 396;
break;
case 20:
tmp = 912384;
maxPicSizeInMbs = 396;
break;
case 21:
tmp = 1824768;
maxPicSizeInMbs = 792;
break;
case 22:
tmp = 3110400;
maxPicSizeInMbs = 1620;
break;
case 30:
tmp = 3110400;
maxPicSizeInMbs = 1620;
break;
case 31:
tmp = 6912000;
maxPicSizeInMbs = 3600;
break;
case 32:
tmp = 7864320;
maxPicSizeInMbs = 5120;
break;
case 40:
tmp = 12582912;
maxPicSizeInMbs = 8192;
break;
case 41:
tmp = 12582912;
maxPicSizeInMbs = 8192;
break;
case 42:
tmp = 34816*384;
maxPicSizeInMbs = 8704;
break;
case 50:
/* standard says 42301440 here, but corrigendum "corrects" this to
* 42393600 */
tmp = 42393600;
maxPicSizeInMbs = 22080;
break;
case 51:
tmp = 70778880;
maxPicSizeInMbs = 36864;
break;
default:
return(INVALID_DPB_SIZE);
}
/* this is not "correct" return value! However, it results in error in
* decoding and this was easiest place to check picture size */
if (picSizeInMbs > maxPicSizeInMbs)
return(INVALID_DPB_SIZE);
tmp /= (picSizeInMbs*384);
return(MIN(tmp, 16));
}
/*------------------------------------------------------------------------------
Function name: h264bsdCompareSeqParamSets
Functional description:
Compare two sequence parameter sets.
Inputs:
pSps1 pointer to a sequence parameter set
pSps2 pointer to another sequence parameter set
Outputs:
0 sequence parameter sets are equal
1 otherwise
------------------------------------------------------------------------------*/
u32 h264bsdCompareSeqParamSets(seqParamSet_t *pSps1, seqParamSet_t *pSps2)
{
/* Variables */
u32 i;
/* Code */
ASSERT(pSps1);
ASSERT(pSps2);
/* first compare parameters whose existence does not depend on other
* parameters and only compare the rest of the params if these are equal */
if (pSps1->profileIdc == pSps2->profileIdc &&
pSps1->levelIdc == pSps2->levelIdc &&
pSps1->maxFrameNum == pSps2->maxFrameNum &&
pSps1->picOrderCntType == pSps2->picOrderCntType &&
pSps1->numRefFrames == pSps2->numRefFrames &&
pSps1->gapsInFrameNumValueAllowedFlag ==
pSps2->gapsInFrameNumValueAllowedFlag &&
pSps1->picWidthInMbs == pSps2->picWidthInMbs &&
pSps1->picHeightInMbs == pSps2->picHeightInMbs &&
pSps1->frameCroppingFlag == pSps2->frameCroppingFlag &&
pSps1->vuiParametersPresentFlag == pSps2->vuiParametersPresentFlag)
{
if (pSps1->picOrderCntType == 0)
{
if (pSps1->maxPicOrderCntLsb != pSps2->maxPicOrderCntLsb)
return 1;
}
else if (pSps1->picOrderCntType == 1)
{
if (pSps1->deltaPicOrderAlwaysZeroFlag !=
pSps2->deltaPicOrderAlwaysZeroFlag ||
pSps1->offsetForNonRefPic != pSps2->offsetForNonRefPic ||
pSps1->offsetForTopToBottomField !=
pSps2->offsetForTopToBottomField ||
pSps1->numRefFramesInPicOrderCntCycle !=
pSps2->numRefFramesInPicOrderCntCycle)
{
return 1;
}
else
{
for (i = 0; i < pSps1->numRefFramesInPicOrderCntCycle; i++)
if (pSps1->offsetForRefFrame[i] !=
pSps2->offsetForRefFrame[i])
{
return 1;
}
}
}
if (pSps1->frameCroppingFlag)
{
if (pSps1->frameCropLeftOffset != pSps2->frameCropLeftOffset ||
pSps1->frameCropRightOffset != pSps2->frameCropRightOffset ||
pSps1->frameCropTopOffset != pSps2->frameCropTopOffset ||
pSps1->frameCropBottomOffset != pSps2->frameCropBottomOffset)
{
return 1;
}
}
return 0;
}
return 1;
}