Skip to content

Z
ZLMediaKit
Commit dd80d6a6 by xiongziliang
Options

Merge branch 'dev' of https://github.com/zqsong/ZLMediaKit into zqsong

parents 1f890198 0d57664f
正在显示 包含 754 行增加 和 631 行删除
src/Extension/H265.cpp
...@@ -32,24 +32,40 @@ namespace mediakit{ ...@@ -32,24 +32,40 @@ namespace mediakit{
bool getAVCH265Info(const string& strSps,int &iVideoWidth, int &iVideoHeight, float &iVideoFps) { bool getAVCH265Info(const string& strVps, const string& strSps,int &iVideoWidth, int &iVideoHeight, float &iVideoFps) {
return getAVC265Info(strSps.data(),strSps.size(),iVideoWidth,iVideoHeight,iVideoFps); return getAVC265Info(strVps.data(),strVps.size(),strSps.data(),strSps.size(),iVideoWidth,iVideoHeight,iVideoFps);
} }
bool getAVC265Info(const char * sps,int sps_len,int &iVideoWidth, int &iVideoHeight, float &iVideoFps){ bool getAVC265Info(const char * vps, int vps_len,const char * sps,int sps_len,int &iVideoWidth, int &iVideoHeight, float &iVideoFps){
T_GetBitContext tGetBitBuf; T_GetBitContext tGetBitBuf;
T_HEVCSPS tH265SpsInfo; T_HEVCSPS tH265SpsInfo;
T_HEVCVPS tH265VpsInfo;
if ( vps_len > 2 ){
memset(&tGetBitBuf,0,sizeof(tGetBitBuf));
memset(&tH265VpsInfo,0,sizeof(tH265VpsInfo));
tGetBitBuf.pu8Buf = (uint8_t*)vps+2;
tGetBitBuf.iBufSize = vps_len-2;
if(0 != h265DecVideoParameterSet((void *) &tGetBitBuf, &tH265VpsInfo)){
return false;
}
}
if ( sps_len > 2 ){
memset(&tGetBitBuf,0,sizeof(tGetBitBuf)); memset(&tGetBitBuf,0,sizeof(tGetBitBuf));
memset(&tH265SpsInfo,0,sizeof(tH265SpsInfo)); memset(&tH265SpsInfo,0,sizeof(tH265SpsInfo));
tGetBitBuf.pu8Buf = (uint8_t*)sps ; tGetBitBuf.pu8Buf = (uint8_t*)sps+2;
tGetBitBuf.iBufSize = sps_len ; tGetBitBuf.iBufSize = sps_len-2;
if(0 != h265DecSeqParameterSet((void *) &tGetBitBuf, &tH265SpsInfo)){ if(0 != h265DecSeqParameterSet((void *) &tGetBitBuf, &tH265SpsInfo)){
return false; return false;
} }
}
else
return false;
h265GetWidthHeight(&tH265SpsInfo, &iVideoWidth, &iVideoHeight); h265GetWidthHeight(&tH265SpsInfo, &iVideoWidth, &iVideoHeight);
h265GeFramerate(&tH265SpsInfo, &iVideoFps); iVideoFps = 0;
//ErrorL << iVideoWidth << " " << iVideoHeight << " " << iVideoFps; h265GeFramerate(&tH265VpsInfo, &tH265SpsInfo, &iVideoFps);
// ErrorL << iVideoWidth << " " << iVideoHeight << " " << iVideoFps;
return true; return true;
} }
......
src/Extension/H265.h
...@@ -36,8 +36,8 @@ using namespace toolkit; ...@@ -36,8 +36,8 @@ using namespace toolkit;
namespace mediakit { namespace mediakit {
bool getAVCH265Info(const string& strSps,int &iVideoWidth, int &iVideoHeight, float &iVideoFps); bool getAVCH265Info(const string& strVps,const string& strSps,int &iVideoWidth, int &iVideoHeight, float &iVideoFps);
bool getAVC265Info(const char * sps,int sps_len,int &iVideoWidth, int &iVideoHeight, float &iVideoFps); bool getAVC265Info(const char * vps, int vps_len,const char * sps,int sps_len,int &iVideoWidth, int &iVideoHeight, float &iVideoFps);
/** /**
* 265帧类 * 265帧类
...@@ -336,7 +336,7 @@ private: ...@@ -336,7 +336,7 @@ private:
* 解析sps获取宽高fps * 解析sps获取宽高fps
*/ */
void onReady(){ void onReady(){
getAVCH265Info(_sps,_width,_height,_fps); getAVCH265Info(_vps,_sps,_width,_height,_fps);
} }
Track::Ptr clone() override { Track::Ptr clone() override {
return std::make_shared<std::remove_reference<decltype(*this)>::type>(*this); return std::make_shared<std::remove_reference<decltype(*this)>::type>(*this);
......
src/Extension/SPSParser.c
...@@ -129,15 +129,15 @@ const uint8_t g_au8FfZigzagDirect[64] = { ...@@ -129,15 +129,15 @@ const uint8_t g_au8FfZigzagDirect[64] = {
}; };
static const uint8_t hevc_sub_width_c[] = { static const uint8_t sg_au8HevcSubWidthC[] = {
1, 2, 2, 1 1, 2, 2, 1
}; };
static const uint8_t hevc_sub_height_c[] = { static const uint8_t sg_au8HevcSubHeightC[] = {
1, 2, 1, 1 1, 2, 1, 1
}; };
static const uint8_t default_scaling_list_intra[] = { static const uint8_t sg_au8DefaultScalingListIntra[] = {
16, 16, 16, 16, 17, 18, 21, 24, 16, 16, 16, 16, 17, 18, 21, 24,
16, 16, 16, 16, 17, 19, 22, 25, 16, 16, 16, 16, 17, 19, 22, 25,
16, 16, 17, 18, 20, 22, 25, 29, 16, 16, 17, 18, 20, 22, 25, 29,
...@@ -148,7 +148,7 @@ static const uint8_t default_scaling_list_intra[] = { ...@@ -148,7 +148,7 @@ static const uint8_t default_scaling_list_intra[] = {
24, 25, 29, 36, 47, 65, 88, 115 24, 25, 29, 36, 47, 65, 88, 115
}; };
static const uint8_t default_scaling_list_inter[] = { static const uint8_t sg_au8DefaultScalingListInter[] = {
16, 16, 16, 16, 17, 18, 20, 24, 16, 16, 16, 16, 17, 18, 20, 24,
16, 16, 16, 17, 18, 20, 24, 25, 16, 16, 16, 17, 18, 20, 24, 25,
16, 16, 17, 18, 20, 24, 25, 28, 16, 16, 17, 18, 20, 24, 25, 28,
...@@ -160,21 +160,21 @@ static const uint8_t default_scaling_list_inter[] = { ...@@ -160,21 +160,21 @@ static const uint8_t default_scaling_list_inter[] = {
}; };
const uint8_t ff_hevc_diag_scan4x4_x[16] = { const uint8_t g_au8HevcDiagScan4x4X[16] = {
0, 0, 1, 0, 0, 0, 1, 0,
1, 2, 0, 1, 1, 2, 0, 1,
2, 3, 1, 2, 2, 3, 1, 2,
3, 2, 3, 3, 3, 2, 3, 3,
}; };
const uint8_t ff_hevc_diag_scan4x4_y[16] = { const uint8_t g_au8HevcDiagScan4x4Y[16] = {
0, 1, 0, 2, 0, 1, 0, 2,
1, 0, 3, 2, 1, 0, 3, 2,
1, 0, 3, 2, 1, 0, 3, 2,
1, 3, 2, 3, 1, 3, 2, 3,
}; };
const uint8_t ff_hevc_diag_scan8x8_x[64] = { const uint8_t g_au8HevcDiagScan8x8X[64] = {
0, 0, 1, 0, 0, 0, 1, 0,
1, 2, 0, 1, 1, 2, 0, 1,
2, 3, 0, 1, 2, 3, 0, 1,
...@@ -193,7 +193,7 @@ const uint8_t ff_hevc_diag_scan8x8_x[64] = { ...@@ -193,7 +193,7 @@ const uint8_t ff_hevc_diag_scan8x8_x[64] = {
7, 6, 7, 7, 7, 6, 7, 7,
}; };
const uint8_t ff_hevc_diag_scan8x8_y[64] = { const uint8_t g_au8HevcDiagScan8x8Y[64] = {
0, 1, 0, 2, 0, 1, 0, 2,
1, 0, 3, 2, 1, 0, 3, 2,
1, 0, 4, 3, 1, 0, 4, 3,
...@@ -212,7 +212,7 @@ const uint8_t ff_hevc_diag_scan8x8_y[64] = { ...@@ -212,7 +212,7 @@ const uint8_t ff_hevc_diag_scan8x8_y[64] = {
5, 7, 6, 7, 5, 7, 6, 7,
}; };
static const T_AVRational vui_sar[] = { static const T_AVRational sg_atVuiSar[] = {
{ 0, 1 }, { 0, 1 },
{ 1, 1 }, { 1, 1 },
{ 12, 11 }, { 12, 11 },
...@@ -733,17 +733,17 @@ static inline int decodeVuiParameters(void *pvBuf, T_SPS *ptSps) ...@@ -733,17 +733,17 @@ static inline int decodeVuiParameters(void *pvBuf, T_SPS *ptSps)
ptSps->tSar.den = 0; ptSps->tSar.den = 0;
} }
if (getOneBit(pvBuf)) /* overscan_info_present_flag */ if (getOneBit(pvBuf)) /* iOverscanInfoPresentFlag */
getOneBit(pvBuf); /* overscan_appropriate_flag */ getOneBit(pvBuf); /* iOverscanAppropriateFlag */
ptSps->iVideoSignalTypePresentFlag = getOneBit(pvBuf); ptSps->iVideoSignalTypePresentFlag = getOneBit(pvBuf);
if (ptSps->iVideoSignalTypePresentFlag) { if (ptSps->iVideoSignalTypePresentFlag) {
getBits(pvBuf, 3); /* video_format */ getBits(pvBuf, 3); /* video_format */
ptSps->iFullRange = getOneBit(pvBuf); /* video_full_range_flag */ ptSps->iFullRange = getOneBit(pvBuf); /* iVideoFullRangeFlag */
ptSps->iColourDescriptionPresentFlag = getOneBit(pvBuf); ptSps->iColourDescriptionPresentFlag = getOneBit(pvBuf);
if (ptSps->iColourDescriptionPresentFlag) { if (ptSps->iColourDescriptionPresentFlag) {
ptSps->tColorPrimaries = getBits(pvBuf, 8); /* colour_primaries */ ptSps->tColorPrimaries = getBits(pvBuf, 8); /* u8ColourPrimaries */
ptSps->tColorTrc = getBits(pvBuf, 8); /* transfer_characteristics */ ptSps->tColorTrc = getBits(pvBuf, 8); /* transfer_characteristics */
ptSps->tColorspace = getBits(pvBuf, 8); /* matrix_coefficients */ ptSps->tColorspace = getBits(pvBuf, 8); /* matrix_coefficients */
if (ptSps->tColorPrimaries >= AVCOL_PRI_NB) if (ptSps->tColorPrimaries >= AVCOL_PRI_NB)
...@@ -1035,8 +1035,8 @@ int h264DecSeqParameterSet(void *pvBufSrc, T_SPS *ptSps) ...@@ -1035,8 +1035,8 @@ int h264DecSeqParameterSet(void *pvBufSrc, T_SPS *ptSps)
unsigned int uiCropRight = parseUe(pvBuf); unsigned int uiCropRight = parseUe(pvBuf);
unsigned int uiCropTop = parseUe(pvBuf); unsigned int uiCropTop = parseUe(pvBuf);
unsigned int uiCropBottom = parseUe(pvBuf); unsigned int uiCropBottom = parseUe(pvBuf);
int width = 16 * ptSps->iMbWidth; int iWidth = 16 * ptSps->iMbWidth;
int height = 16 * ptSps->iMbHeight * (2 - ptSps->iFrameMbsOnlyFlag); int iHeight = 16 * ptSps->iMbHeight * (2 - ptSps->iFrameMbsOnlyFlag);
if(1) if(1)
{ {
...@@ -1055,11 +1055,11 @@ int h264DecSeqParameterSet(void *pvBufSrc, T_SPS *ptSps) ...@@ -1055,11 +1055,11 @@ int h264DecSeqParameterSet(void *pvBufSrc, T_SPS *ptSps)
uiCropRight > (unsigned)INT_MAX / 4 / step_x || uiCropRight > (unsigned)INT_MAX / 4 / step_x ||
uiCropTop > (unsigned)INT_MAX / 4 / step_y || uiCropTop > (unsigned)INT_MAX / 4 / step_y ||
uiCropBottom> (unsigned)INT_MAX / 4 / step_y || uiCropBottom> (unsigned)INT_MAX / 4 / step_y ||
(uiCropLeft + uiCropRight ) * step_x >= width || (uiCropLeft + uiCropRight ) * step_x >= iWidth ||
(uiCropTop + uiCropBottom) * step_y >= height (uiCropTop + uiCropBottom) * step_y >= iHeight
) )
{ {
RPT(RPT_ERR, "crop values invalid %d %d %d %d / %d %d\n", uiCropLeft, uiCropRight, uiCropTop, uiCropBottom, width, height); RPT(RPT_ERR, "crop values invalid %d %d %d %d / %d %d\n", uiCropLeft, uiCropRight, uiCropTop, uiCropBottom, iWidth, iHeight);
iRet = -1; iRet = -1;
goto exit; goto exit;
} }
...@@ -1129,37 +1129,37 @@ exit: ...@@ -1129,37 +1129,37 @@ exit:
} }
static int decodeProfileTierLevel(T_GetBitContext *pvBuf, T_PTLCommon *ptl) static int decodeProfileTierLevel(T_GetBitContext *pvBuf, T_PTLCommon *tPtl)
{ {
int i; int i;
if (getBitsLeft(pvBuf) < 2+1+5 + 32 + 4 + 16 + 16 + 12) if (getBitsLeft(pvBuf) < 2+1+5 + 32 + 4 + 16 + 16 + 12)
return -1; return -1;
ptl->profile_space = getBits(pvBuf, 2); tPtl->u8ProfileSpace = getBits(pvBuf, 2);
ptl->tier_flag = getOneBit(pvBuf); tPtl->u8TierFlag = getOneBit(pvBuf);
ptl->profile_idc = getBits(pvBuf, 5); tPtl->u8ProfileIdc = getBits(pvBuf, 5);
if (ptl->profile_idc == T_PROFILE_HEVC_MAIN) if (tPtl->u8ProfileIdc == T_PROFILE_HEVC_MAIN)
RPT(RPT_DBG, "Main profile bitstream\n"); RPT(RPT_DBG, "Main profile bitstream\n");
else if (ptl->profile_idc == T_PROFILE_HEVC_MAIN_10) else if (tPtl->u8ProfileIdc == T_PROFILE_HEVC_MAIN_10)
RPT(RPT_DBG, "Main 10 profile bitstream\n"); RPT(RPT_DBG, "Main 10 profile bitstream\n");
else if (ptl->profile_idc == T_PROFILE_HEVC_MAIN_STILL_PICTURE) else if (tPtl->u8ProfileIdc == T_PROFILE_HEVC_MAIN_STILL_PICTURE)
RPT(RPT_DBG, "Main Still Picture profile bitstream\n"); RPT(RPT_DBG, "Main Still Picture profile bitstream\n");
else if (ptl->profile_idc == T_PROFILE_HEVC_REXT) else if (tPtl->u8ProfileIdc == T_PROFILE_HEVC_REXT)
RPT(RPT_DBG, "Range Extension profile bitstream\n"); RPT(RPT_DBG, "Range Extension profile bitstream\n");
else else
RPT(RPT_WRN, "Unknown HEVC profile: %d\n", ptl->profile_idc); RPT(RPT_WRN, "Unknown HEVC profile: %d\n", tPtl->u8ProfileIdc);
for (i = 0; i < 32; i++) { for (i = 0; i < 32; i++) {
ptl->profile_compatibility_flag[i] = getOneBit(pvBuf); tPtl->au8ProfileCompatibilityFlag[i] = getOneBit(pvBuf);
if (ptl->profile_idc == 0 && i > 0 && ptl->profile_compatibility_flag[i]) if (tPtl->u8ProfileIdc == 0 && i > 0 && tPtl->au8ProfileCompatibilityFlag[i])
ptl->profile_idc = i; tPtl->u8ProfileIdc = i;
} }
ptl->progressive_source_flag = getOneBit(pvBuf); tPtl->u8ProgressiveSourceFlag = getOneBit(pvBuf);
ptl->interlaced_source_flag = getOneBit(pvBuf); tPtl->u8InterlacedSourceFlag = getOneBit(pvBuf);
ptl->non_packed_constraint_flag = getOneBit(pvBuf); tPtl->u8NonPackedConstraintFlag = getOneBit(pvBuf);
ptl->frame_only_constraint_flag = getOneBit(pvBuf); tPtl->u8FrameOnlyConstraintFlag = getOneBit(pvBuf);
getBits(pvBuf, 16); // XXX_reserved_zero_44bits[0..15] getBits(pvBuf, 16); // XXX_reserved_zero_44bits[0..15]
getBits(pvBuf, 16); // XXX_reserved_zero_44bits[16..31] getBits(pvBuf, 16); // XXX_reserved_zero_44bits[16..31]
...@@ -1169,39 +1169,39 @@ static int decodeProfileTierLevel(T_GetBitContext *pvBuf, T_PTLCommon *ptl) ...@@ -1169,39 +1169,39 @@ static int decodeProfileTierLevel(T_GetBitContext *pvBuf, T_PTLCommon *ptl)
} }
static int parsePtl(T_GetBitContext *pvBuf, T_PTL *ptl, int max_num_sub_layers) static int parsePtl(T_GetBitContext *pvBuf, T_PTL *tPtl, int max_num_sub_layers)
{ {
int i; int i;
if (decodeProfileTierLevel(pvBuf, &ptl->general_ptl) < 0 || if (decodeProfileTierLevel(pvBuf, &tPtl->tGeneralPtl) < 0 ||
getBitsLeft(pvBuf) < 8 + (8*2 * (max_num_sub_layers - 1 > 0))) { getBitsLeft(pvBuf) < 8 + (8*2 * (max_num_sub_layers - 1 > 0))) {
RPT(RPT_ERR, "PTL information too short\n"); RPT(RPT_ERR, "PTL information too short\n");
return -1; return -1;
} }
ptl->general_ptl.level_idc = getBits(pvBuf, 8); tPtl->tGeneralPtl.u8LevelIdc = getBits(pvBuf, 8);
for (i = 0; i < max_num_sub_layers - 1; i++) { for (i = 0; i < max_num_sub_layers - 1; i++) {
ptl->sub_layer_profile_present_flag[i] = getOneBit(pvBuf); tPtl->au8SubLayerProfilePresentFlag[i] = getOneBit(pvBuf);
ptl->sub_layer_level_present_flag[i] = getOneBit(pvBuf); tPtl->au8SubLayerLevelPresentFlag[i] = getOneBit(pvBuf);
} }
if (max_num_sub_layers - 1> 0) if (max_num_sub_layers - 1> 0)
for (i = max_num_sub_layers - 1; i < 8; i++) for (i = max_num_sub_layers - 1; i < 8; i++)
getBits(pvBuf, 2); // reserved_zero_2bits[i] getBits(pvBuf, 2); // reserved_zero_2bits[i]
for (i = 0; i < max_num_sub_layers - 1; i++) { for (i = 0; i < max_num_sub_layers - 1; i++) {
if (ptl->sub_layer_profile_present_flag[i] && if (tPtl->au8SubLayerProfilePresentFlag[i] &&
decodeProfileTierLevel(pvBuf, &ptl->sub_layer_ptl[i]) < 0) { decodeProfileTierLevel(pvBuf, &tPtl->atSubLayerPtl[i]) < 0) {
RPT(RPT_ERR, RPT(RPT_ERR,
"PTL information for sublayer %i too short\n", i); "PTL information for sublayer %i too short\n", i);
return -1; return -1;
} }
if (ptl->sub_layer_level_present_flag[i]) { if (tPtl->au8SubLayerLevelPresentFlag[i]) {
if (getBitsLeft(pvBuf) < 8) { if (getBitsLeft(pvBuf) < 8) {
RPT(RPT_ERR, RPT(RPT_ERR,
"Not enough data for sublayer %i level_idc\n", i); "Not enough data for sublayer %i level_idc\n", i);
return -1; return -1;
} else } else
ptl->sub_layer_ptl[i].level_idc = getBits(pvBuf, 8); tPtl->atSubLayerPtl[i].u8LevelIdc = getBits(pvBuf, 8);
} }
} }
...@@ -1215,31 +1215,31 @@ static void setDefaultScalingListData(T_ScalingList *sl) ...@@ -1215,31 +1215,31 @@ static void setDefaultScalingListData(T_ScalingList *sl)
for (matrixId = 0; matrixId < 6; matrixId++) { for (matrixId = 0; matrixId < 6; matrixId++) {
// 4x4 default is 16 // 4x4 default is 16
memset(sl->sl[0][matrixId], 16, 16); memset(sl->aaau8Sl[0][matrixId], 16, 16);
sl->sl_dc[0][matrixId] = 16; // default for 16x16 sl->aau8SlDc[0][matrixId] = 16; // default for 16x16
sl->sl_dc[1][matrixId] = 16; // default for 32x32 sl->aau8SlDc[1][matrixId] = 16; // default for 32x32
} }
memcpy(sl->sl[1][0], default_scaling_list_intra, 64); memcpy(sl->aaau8Sl[1][0], sg_au8DefaultScalingListIntra, 64);
memcpy(sl->sl[1][1], default_scaling_list_intra, 64); memcpy(sl->aaau8Sl[1][1], sg_au8DefaultScalingListIntra, 64);
memcpy(sl->sl[1][2], default_scaling_list_intra, 64); memcpy(sl->aaau8Sl[1][2], sg_au8DefaultScalingListIntra, 64);
memcpy(sl->sl[1][3], default_scaling_list_inter, 64); memcpy(sl->aaau8Sl[1][3], sg_au8DefaultScalingListInter, 64);
memcpy(sl->sl[1][4], default_scaling_list_inter, 64); memcpy(sl->aaau8Sl[1][4], sg_au8DefaultScalingListInter, 64);
memcpy(sl->sl[1][5], default_scaling_list_inter, 64); memcpy(sl->aaau8Sl[1][5], sg_au8DefaultScalingListInter, 64);
memcpy(sl->sl[2][0], default_scaling_list_intra, 64); memcpy(sl->aaau8Sl[2][0], sg_au8DefaultScalingListIntra, 64);
memcpy(sl->sl[2][1], default_scaling_list_intra, 64); memcpy(sl->aaau8Sl[2][1], sg_au8DefaultScalingListIntra, 64);
memcpy(sl->sl[2][2], default_scaling_list_intra, 64); memcpy(sl->aaau8Sl[2][2], sg_au8DefaultScalingListIntra, 64);
memcpy(sl->sl[2][3], default_scaling_list_inter, 64); memcpy(sl->aaau8Sl[2][3], sg_au8DefaultScalingListInter, 64);
memcpy(sl->sl[2][4], default_scaling_list_inter, 64); memcpy(sl->aaau8Sl[2][4], sg_au8DefaultScalingListInter, 64);
memcpy(sl->sl[2][5], default_scaling_list_inter, 64); memcpy(sl->aaau8Sl[2][5], sg_au8DefaultScalingListInter, 64);
memcpy(sl->sl[3][0], default_scaling_list_intra, 64); memcpy(sl->aaau8Sl[3][0], sg_au8DefaultScalingListIntra, 64);
memcpy(sl->sl[3][1], default_scaling_list_intra, 64); memcpy(sl->aaau8Sl[3][1], sg_au8DefaultScalingListIntra, 64);
memcpy(sl->sl[3][2], default_scaling_list_intra, 64); memcpy(sl->aaau8Sl[3][2], sg_au8DefaultScalingListIntra, 64);
memcpy(sl->sl[3][3], default_scaling_list_inter, 64); memcpy(sl->aaau8Sl[3][3], sg_au8DefaultScalingListInter, 64);
memcpy(sl->sl[3][4], default_scaling_list_inter, 64); memcpy(sl->aaau8Sl[3][4], sg_au8DefaultScalingListInter, 64);
memcpy(sl->sl[3][5], default_scaling_list_inter, 64); memcpy(sl->aaau8Sl[3][5], sg_au8DefaultScalingListInter, 64);
} }
static int scalingListData(T_GetBitContext *pvBuf, T_ScalingList *sl, T_HEVCSPS *sps) static int scalingListData(T_GetBitContext *pvBuf, T_ScalingList *sl, T_HEVCSPS *ptSps)
{ {
uint8_t scaling_list_pred_mode_flag; uint8_t scaling_list_pred_mode_flag;
int32_t scaling_list_dc_coef[2][6]; int32_t scaling_list_dc_coef[2][6];
...@@ -1262,11 +1262,11 @@ static int scalingListData(T_GetBitContext *pvBuf, T_ScalingList *sl, T_HEVCSPS ...@@ -1262,11 +1262,11 @@ static int scalingListData(T_GetBitContext *pvBuf, T_ScalingList *sl, T_HEVCSPS
return -1; return -1;
} }
memcpy(sl->sl[size_id][matrix_id], memcpy(sl->aaau8Sl[size_id][matrix_id],
sl->sl[size_id][matrix_id - delta], sl->aaau8Sl[size_id][matrix_id - delta],
size_id > 0 ? 64 : 16); size_id > 0 ? 64 : 16);
if (size_id > 1) if (size_id > 1)
sl->sl_dc[size_id - 2][matrix_id] = sl->sl_dc[size_id - 2][matrix_id - delta]; sl->aau8SlDc[size_id - 2][matrix_id] = sl->aau8SlDc[size_id - 2][matrix_id - delta];
} }
} else { } else {
int next_coef, coef_num; int next_coef, coef_num;
...@@ -1277,34 +1277,34 @@ static int scalingListData(T_GetBitContext *pvBuf, T_ScalingList *sl, T_HEVCSPS ...@@ -1277,34 +1277,34 @@ static int scalingListData(T_GetBitContext *pvBuf, T_ScalingList *sl, T_HEVCSPS
if (size_id > 1) { if (size_id > 1) {
scaling_list_dc_coef[size_id - 2][matrix_id] = parseSe(pvBuf) + 8; scaling_list_dc_coef[size_id - 2][matrix_id] = parseSe(pvBuf) + 8;
next_coef = scaling_list_dc_coef[size_id - 2][matrix_id]; next_coef = scaling_list_dc_coef[size_id - 2][matrix_id];
sl->sl_dc[size_id - 2][matrix_id] = next_coef; sl->aau8SlDc[size_id - 2][matrix_id] = next_coef;
} }
for (i = 0; i < coef_num; i++) { for (i = 0; i < coef_num; i++) {
if (size_id == 0) if (size_id == 0)
pos = 4 * ff_hevc_diag_scan4x4_y[i] + pos = 4 * g_au8HevcDiagScan4x4Y[i] +
ff_hevc_diag_scan4x4_x[i]; g_au8HevcDiagScan4x4X[i];
else else
pos = 8 * ff_hevc_diag_scan8x8_y[i] + pos = 8 * g_au8HevcDiagScan8x8Y[i] +
ff_hevc_diag_scan8x8_x[i]; g_au8HevcDiagScan8x8X[i];
scaling_list_delta_coef = parseSe(pvBuf); scaling_list_delta_coef = parseSe(pvBuf);
next_coef = (next_coef + 256U + scaling_list_delta_coef) % 256; next_coef = (next_coef + 256U + scaling_list_delta_coef) % 256;
sl->sl[size_id][matrix_id][pos] = next_coef; sl->aaau8Sl[size_id][matrix_id][pos] = next_coef;
} }
} }
} }
if (sps->chroma_format_idc == 3) { if (ptSps->iChromaFormatIdc == 3) {
for (i = 0; i < 64; i++) { for (i = 0; i < 64; i++) {
sl->sl[3][1][i] = sl->sl[2][1][i]; sl->aaau8Sl[3][1][i] = sl->aaau8Sl[2][1][i];
sl->sl[3][2][i] = sl->sl[2][2][i]; sl->aaau8Sl[3][2][i] = sl->aaau8Sl[2][2][i];
sl->sl[3][4][i] = sl->sl[2][4][i]; sl->aaau8Sl[3][4][i] = sl->aaau8Sl[2][4][i];
sl->sl[3][5][i] = sl->sl[2][5][i]; sl->aaau8Sl[3][5][i] = sl->aaau8Sl[2][5][i];
} }
sl->sl_dc[1][1] = sl->sl_dc[0][1]; sl->aau8SlDc[1][1] = sl->aau8SlDc[0][1];
sl->sl_dc[1][2] = sl->sl_dc[0][2]; sl->aau8SlDc[1][2] = sl->aau8SlDc[0][2];
sl->sl_dc[1][4] = sl->sl_dc[0][4]; sl->aau8SlDc[1][4] = sl->aau8SlDc[0][4];
sl->sl_dc[1][5] = sl->sl_dc[0][5]; sl->aau8SlDc[1][5] = sl->aau8SlDc[0][5];
} }
...@@ -1312,60 +1312,60 @@ static int scalingListData(T_GetBitContext *pvBuf, T_ScalingList *sl, T_HEVCSPS ...@@ -1312,60 +1312,60 @@ static int scalingListData(T_GetBitContext *pvBuf, T_ScalingList *sl, T_HEVCSPS
} }
int hevcDecodeShortTermRps(T_GetBitContext *pvBuf, int hevcDecodeShortTermRps(T_GetBitContext *pvBuf,
T_ShortTermRPS *rps, const T_HEVCSPS *sps, int is_slice_header) T_ShortTermRPS *rps, const T_HEVCSPS *ptSps, int is_slice_header)
{ {
uint8_t rps_predict = 0; uint8_t rps_predict = 0;
int delta_poc; int au32DeltaPoc;
int k0 = 0; int k0 = 0;
int k1 = 0; int k1 = 0;
int k = 0; int k = 0;
int i; int i;
if (rps != sps->st_rps && sps->nb_st_rps) if (rps != ptSps->atStRps && ptSps->uiNbStRps)
rps_predict = getOneBit(pvBuf); rps_predict = getOneBit(pvBuf);
if (rps_predict) { if (rps_predict) {
const T_ShortTermRPS *rps_ridx; const T_ShortTermRPS *ptRpsRidx;
int delta_rps; int iDeltaRps;
unsigned abs_delta_rps; unsigned int uiAbsDeltaRps;
uint8_t use_delta_flag = 0; uint8_t u8UseDeltaFlag = 0;
uint8_t delta_rps_sign; uint8_t u8DeltaRpsSign;
if (is_slice_header) { if (is_slice_header) {
unsigned int delta_idx = parseUe(pvBuf) + 1; unsigned int uiDeltaIdx = parseUe(pvBuf) + 1;
if (delta_idx > sps->nb_st_rps) { if (u8DeltaRpsSign > ptSps->uiNbStRps) {
RPT(RPT_ERR, RPT(RPT_ERR,
"Invalid value of delta_idx in slice header RPS: %d > %d.\n", "Invalid value of delta_idx in slice header RPS: %d > %d.\n",
delta_idx, sps->nb_st_rps); u8DeltaRpsSign, ptSps->uiNbStRps);
return -1; return -1;
} }
rps_ridx = &sps->st_rps[sps->nb_st_rps - delta_idx]; ptRpsRidx = &ptSps->atStRps[ptSps->uiNbStRps - u8DeltaRpsSign];
rps->rps_idx_num_delta_pocs = rps_ridx->num_delta_pocs; rps->iRpsIdxNumDeltaPocs = ptRpsRidx->iNumDeltaPocs;
} else } else
rps_ridx = &sps->st_rps[rps - sps->st_rps - 1]; ptRpsRidx = &ptSps->atStRps[rps - ptSps->atStRps - 1];
delta_rps_sign = getOneBit(pvBuf); u8DeltaRpsSign = getOneBit(pvBuf);
abs_delta_rps = parseUe(pvBuf) + 1; uiAbsDeltaRps = parseUe(pvBuf) + 1;
if (abs_delta_rps < 1 || abs_delta_rps > 32768) { if (uiAbsDeltaRps < 1 || uiAbsDeltaRps > 32768) {
RPT(RPT_ERR, RPT(RPT_ERR,
"Invalid value of abs_delta_rps: %d\n", "Invalid value of uiAbsDeltaRps: %d\n",
abs_delta_rps); uiAbsDeltaRps);
return -1; return -1;
} }
delta_rps = (1 - (delta_rps_sign << 1)) * abs_delta_rps; iDeltaRps = (1 - (u8DeltaRpsSign << 1)) * uiAbsDeltaRps;
for (i = 0; i <= rps_ridx->num_delta_pocs; i++) { for (i = 0; i <= ptRpsRidx->iNumDeltaPocs; i++) {
int used = rps->used[k] = getOneBit(pvBuf); int used = rps->au8Used[k] = getOneBit(pvBuf);
if (!used) if (!used)
use_delta_flag = getOneBit(pvBuf); u8UseDeltaFlag = getOneBit(pvBuf);
if (used || use_delta_flag) { if (used || u8UseDeltaFlag) {
if (i < rps_ridx->num_delta_pocs) if (i < ptRpsRidx->iNumDeltaPocs)
delta_poc = delta_rps + rps_ridx->delta_poc[i]; au32DeltaPoc = iDeltaRps + ptRpsRidx->au32DeltaPoc[i];
else else
delta_poc = delta_rps; au32DeltaPoc = iDeltaRps;
rps->delta_poc[k] = delta_poc; rps->au32DeltaPoc[k] = au32DeltaPoc;
if (delta_poc < 0) if (au32DeltaPoc < 0)
k0++; k0++;
else else
k1++; k1++;
...@@ -1373,83 +1373,83 @@ int hevcDecodeShortTermRps(T_GetBitContext *pvBuf, ...@@ -1373,83 +1373,83 @@ int hevcDecodeShortTermRps(T_GetBitContext *pvBuf,
} }
} }
if (k >= FF_ARRAY_ELEMS(rps->used)) { if (k >= FF_ARRAY_ELEMS(rps->au8Used)) {
RPT(RPT_ERR, RPT(RPT_ERR,
"Invalid num_delta_pocs: %d\n", k); "Invalid iNumDeltaPocs: %d\n", k);
return -1; return -1;
} }
rps->num_delta_pocs = k; rps->iNumDeltaPocs = k;
rps->num_negative_pics = k0; rps->uiNumNegativePics = k0;
// sort in increasing order (smallest first) // sort in increasing order (smallest first)
if (rps->num_delta_pocs != 0) { if (rps->iNumDeltaPocs != 0) {
int used, tmp; int used, tmp;
for (i = 1; i < rps->num_delta_pocs; i++) { for (i = 1; i < rps->iNumDeltaPocs; i++) {
delta_poc = rps->delta_poc[i]; au32DeltaPoc = rps->au32DeltaPoc[i];
used = rps->used[i]; used = rps->au8Used[i];
for (k = i - 1; k >= 0; k--) { for (k = i - 1; k >= 0; k--) {
tmp = rps->delta_poc[k]; tmp = rps->au32DeltaPoc[k];
if (delta_poc < tmp) { if (au32DeltaPoc < tmp) {
rps->delta_poc[k + 1] = tmp; rps->au32DeltaPoc[k + 1] = tmp;
rps->used[k + 1] = rps->used[k]; rps->au8Used[k + 1] = rps->au8Used[k];
rps->delta_poc[k] = delta_poc; rps->au32DeltaPoc[k] = au32DeltaPoc;
rps->used[k] = used; rps->au8Used[k] = used;
} }
} }
} }
} }
if ((rps->num_negative_pics >> 1) != 0) { if ((rps->uiNumNegativePics >> 1) != 0) {
int used; int used;
k = rps->num_negative_pics - 1; k = rps->uiNumNegativePics - 1;
// flip the negative values to largest first // flip the negative values to largest first
for (i = 0; i < rps->num_negative_pics >> 1; i++) { for (i = 0; i < rps->uiNumNegativePics >> 1; i++) {
delta_poc = rps->delta_poc[i]; au32DeltaPoc = rps->au32DeltaPoc[i];
used = rps->used[i]; used = rps->au8Used[i];
rps->delta_poc[i] = rps->delta_poc[k]; rps->au32DeltaPoc[i] = rps->au32DeltaPoc[k];
rps->used[i] = rps->used[k]; rps->au8Used[i] = rps->au8Used[k];
rps->delta_poc[k] = delta_poc; rps->au32DeltaPoc[k] = au32DeltaPoc;
rps->used[k] = used; rps->au8Used[k] = used;
k--; k--;
} }
} }
} else { } else {
unsigned int prev, nb_positive_pics; unsigned int uiPrev, uiNbPositivePics;
rps->num_negative_pics = parseUe(pvBuf); rps->uiNumNegativePics = parseUe(pvBuf);
nb_positive_pics = parseUe(pvBuf); uiNbPositivePics = parseUe(pvBuf);
if (rps->num_negative_pics >= HEVC_MAX_REFS || if (rps->uiNumNegativePics >= HEVC_MAX_REFS ||
nb_positive_pics >= HEVC_MAX_REFS) { uiNbPositivePics >= HEVC_MAX_REFS) {
RPT(RPT_ERR, "Too many refs in a short term RPS.\n"); RPT(RPT_ERR, "Too many refs in a short term RPS.\n");
return -1; return -1;
} }
rps->num_delta_pocs = rps->num_negative_pics + nb_positive_pics; rps->iNumDeltaPocs = rps->uiNumNegativePics + uiNbPositivePics;
if (rps->num_delta_pocs) { if (rps->iNumDeltaPocs) {
prev = 0; uiPrev = 0;
for (i = 0; i < rps->num_negative_pics; i++) { for (i = 0; i < rps->uiNumNegativePics; i++) {
delta_poc = parseUe(pvBuf) + 1; au32DeltaPoc = parseUe(pvBuf) + 1;
if (delta_poc < 1 || delta_poc > 32768) { if (au32DeltaPoc < 1 || au32DeltaPoc > 32768) {
RPT(RPT_ERR, RPT(RPT_ERR,
"Invalid value of delta_poc: %d\n", "Invalid value of au32DeltaPoc: %d\n",
delta_poc); au32DeltaPoc);
return -1; return -1;
} }
prev -= delta_poc; uiPrev -= au32DeltaPoc;
rps->delta_poc[i] = prev; rps->au32DeltaPoc[i] = uiPrev;
rps->used[i] = getOneBit(pvBuf); rps->au8Used[i] = getOneBit(pvBuf);
} }
prev = 0; uiPrev = 0;
for (i = 0; i < nb_positive_pics; i++) { for (i = 0; i < uiNbPositivePics; i++) {
delta_poc = parseUe(pvBuf) + 1; au32DeltaPoc = parseUe(pvBuf) + 1;
if (delta_poc < 1 || delta_poc > 32768) { if (au32DeltaPoc < 1 || au32DeltaPoc > 32768) {
RPT(RPT_ERR, RPT(RPT_ERR,
"Invalid value of delta_poc: %d\n", "Invalid value of au32DeltaPoc: %d\n",
delta_poc); au32DeltaPoc);
return -1; return -1;
} }
prev += delta_poc; uiPrev += au32DeltaPoc;
rps->delta_poc[rps->num_negative_pics + i] = prev; rps->au32DeltaPoc[rps->uiNumNegativePics + i] = uiPrev;
rps->used[rps->num_negative_pics + i] = getOneBit(pvBuf); rps->au8Used[rps->uiNumNegativePics + i] = getOneBit(pvBuf);
} }
} }
} }
...@@ -1457,7 +1457,7 @@ int hevcDecodeShortTermRps(T_GetBitContext *pvBuf, ...@@ -1457,7 +1457,7 @@ int hevcDecodeShortTermRps(T_GetBitContext *pvBuf,
} }
static void decodeSublayerHrd(T_GetBitContext *pvBuf, unsigned int nb_cpb, static void decodeSublayerHrd(T_GetBitContext *pvBuf, unsigned int nb_cpb,
int subpic_params_present) int iSubpicParamsPresent)
{ {
int i; int i;
...@@ -1465,7 +1465,7 @@ static void decodeSublayerHrd(T_GetBitContext *pvBuf, unsigned int nb_cpb, ...@@ -1465,7 +1465,7 @@ static void decodeSublayerHrd(T_GetBitContext *pvBuf, unsigned int nb_cpb,
parseUe(pvBuf); // bit_rate_value_minus1 parseUe(pvBuf); // bit_rate_value_minus1
parseUe(pvBuf); // cpb_size_value_minus1 parseUe(pvBuf); // cpb_size_value_minus1
if (subpic_params_present) { if (iSubpicParamsPresent) {
parseUe(pvBuf); // cpb_size_du_value_minus1 parseUe(pvBuf); // cpb_size_du_value_minus1
parseUe(pvBuf); // bit_rate_du_value_minus1 parseUe(pvBuf); // bit_rate_du_value_minus1
} }
...@@ -1476,18 +1476,18 @@ static void decodeSublayerHrd(T_GetBitContext *pvBuf, unsigned int nb_cpb, ...@@ -1476,18 +1476,18 @@ static void decodeSublayerHrd(T_GetBitContext *pvBuf, unsigned int nb_cpb,
static int decodeHrd(T_GetBitContext *pvBuf, int common_inf_present, static int decodeHrd(T_GetBitContext *pvBuf, int common_inf_present,
int max_sublayers) int max_sublayers)
{ {
int nal_params_present = 0, vcl_params_present = 0; int iNalParamsPresent = 0, iVclParamsPresent = 0;
int subpic_params_present = 0; int iSubpicParamsPresent = 0;
int i; int i;
if (common_inf_present) { if (common_inf_present) {
nal_params_present = getOneBit(pvBuf); iNalParamsPresent = getOneBit(pvBuf);
vcl_params_present = getOneBit(pvBuf); iVclParamsPresent = getOneBit(pvBuf);
if (nal_params_present || vcl_params_present) { if (iNalParamsPresent || iVclParamsPresent) {
subpic_params_present = getOneBit(pvBuf); iSubpicParamsPresent = getOneBit(pvBuf);
if (subpic_params_present) { if (iSubpicParamsPresent) {
getBits(pvBuf, 8); // tick_divisor_minus2 getBits(pvBuf, 8); // tick_divisor_minus2
getBits(pvBuf, 5); // du_cpb_removal_delay_increment_length_minus1 getBits(pvBuf, 5); // du_cpb_removal_delay_increment_length_minus1
getBits(pvBuf, 1); // sub_pic_cpb_params_in_pic_timing_sei_flag getBits(pvBuf, 1); // sub_pic_cpb_params_in_pic_timing_sei_flag
...@@ -1497,7 +1497,7 @@ static int decodeHrd(T_GetBitContext *pvBuf, int common_inf_present, ...@@ -1497,7 +1497,7 @@ static int decodeHrd(T_GetBitContext *pvBuf, int common_inf_present,
getBits(pvBuf, 4); // bit_rate_scale getBits(pvBuf, 4); // bit_rate_scale
getBits(pvBuf, 4); // cpb_size_scale getBits(pvBuf, 4); // cpb_size_scale
if (subpic_params_present) if (iSubpicParamsPresent)
getBits(pvBuf, 4); // cpb_size_du_scale getBits(pvBuf, 4); // cpb_size_du_scale
getBits(pvBuf, 5); // initial_cpb_removal_delay_length_minus1 getBits(pvBuf, 5); // initial_cpb_removal_delay_length_minus1
...@@ -1509,12 +1509,12 @@ static int decodeHrd(T_GetBitContext *pvBuf, int common_inf_present, ...@@ -1509,12 +1509,12 @@ static int decodeHrd(T_GetBitContext *pvBuf, int common_inf_present,
for (i = 0; i < max_sublayers; i++) { for (i = 0; i < max_sublayers; i++) {
int low_delay = 0; int low_delay = 0;
unsigned int nb_cpb = 1; unsigned int nb_cpb = 1;
int fixed_rate = getOneBit(pvBuf); int iFixedRate = getOneBit(pvBuf);
if (!fixed_rate) if (!iFixedRate)
fixed_rate = getOneBit(pvBuf); iFixedRate = getOneBit(pvBuf);
if (fixed_rate) if (iFixedRate)
parseUe(pvBuf); // elemental_duration_in_tc_minus1 parseUe(pvBuf); // elemental_duration_in_tc_minus1
else else
low_delay = getOneBit(pvBuf); low_delay = getOneBit(pvBuf);
...@@ -1527,20 +1527,20 @@ static int decodeHrd(T_GetBitContext *pvBuf, int common_inf_present, ...@@ -1527,20 +1527,20 @@ static int decodeHrd(T_GetBitContext *pvBuf, int common_inf_present,
} }
} }
if (nal_params_present) if (iNalParamsPresent)
decodeSublayerHrd(pvBuf, nb_cpb, subpic_params_present); decodeSublayerHrd(pvBuf, nb_cpb, iSubpicParamsPresent);
if (vcl_params_present) if (iVclParamsPresent)
decodeSublayerHrd(pvBuf, nb_cpb, subpic_params_present); decodeSublayerHrd(pvBuf, nb_cpb, iSubpicParamsPresent);
} }
return 0; return 0;
} }
static void decodeVui(T_GetBitContext *pvBuf, T_HEVCSPS *sps) static void decodeVui(T_GetBitContext *pvBuf, T_HEVCSPS *ptSps)
{ {
T_VUI backup_vui, *vui = &sps->vui; T_VUI tBackupVui, *tVui = &ptSps->tVui;
T_GetBitContext backup; T_GetBitContext tBackup;
int sar_present, alt = 0; int sar_present, alt = 0;
RPT(RPT_DBG, "Decoding VUI\n"); RPT(RPT_DBG, "Decoding VUI\n");
...@@ -1548,166 +1548,145 @@ static void decodeVui(T_GetBitContext *pvBuf, T_HEVCSPS *sps) ...@@ -1548,166 +1548,145 @@ static void decodeVui(T_GetBitContext *pvBuf, T_HEVCSPS *sps)
sar_present = getOneBit(pvBuf); sar_present = getOneBit(pvBuf);
if (sar_present) { if (sar_present) {
uint8_t sar_idx = getBits(pvBuf, 8); uint8_t sar_idx = getBits(pvBuf, 8);
if (sar_idx < FF_ARRAY_ELEMS(vui_sar)) if (sar_idx < FF_ARRAY_ELEMS(sg_atVuiSar))
vui->sar = vui_sar[sar_idx]; tVui->tSar = sg_atVuiSar[sar_idx];
else if (sar_idx == 255) { else if (sar_idx == 255) {
vui->sar.num = getBits(pvBuf, 16); tVui->tSar.num = getBits(pvBuf, 16);
vui->sar.den = getBits(pvBuf, 16); tVui->tSar.den = getBits(pvBuf, 16);
} else } else
RPT(RPT_WRN, RPT(RPT_WRN,
"Unknown SAR index: %u.\n", sar_idx); "Unknown SAR index: %u.\n", sar_idx);
} }
vui->overscan_info_present_flag = getOneBit(pvBuf); tVui->iOverscanInfoPresentFlag = getOneBit(pvBuf);
if (vui->overscan_info_present_flag) if (tVui->iOverscanInfoPresentFlag)
vui->overscan_appropriate_flag = getOneBit(pvBuf); tVui->iOverscanAppropriateFlag = getOneBit(pvBuf);
vui->video_signal_type_present_flag = getOneBit(pvBuf); tVui->iVideoSignalTypePresentFlag = getOneBit(pvBuf);
if (vui->video_signal_type_present_flag) { if (tVui->iVideoSignalTypePresentFlag) {
vui->video_format = getBits(pvBuf, 3); tVui->iVideoFormat = getBits(pvBuf, 3);
vui->video_full_range_flag = getOneBit(pvBuf); tVui->iVideoFullRangeFlag = getOneBit(pvBuf);
vui->colour_description_present_flag = getOneBit(pvBuf); tVui->iColourDescriptionPresentFlag = getOneBit(pvBuf);
// if (vui->video_full_range_flag && sps->pix_fmt == AV_PIX_FMT_YUV420P) // if (tVui->iVideoFullRangeFlag && ptSps->pix_fmt == AV_PIX_FMT_YUV420P)
// sps->pix_fmt = AV_PIX_FMT_YUVJ420P; // ptSps->pix_fmt = AV_PIX_FMT_YUVJ420P;
if (vui->colour_description_present_flag) { if (tVui->iColourDescriptionPresentFlag) {
vui->colour_primaries = getBits(pvBuf, 8); tVui->u8ColourPrimaries = getBits(pvBuf, 8);
vui->transfer_characteristic = getBits(pvBuf, 8); tVui->u8TransferCharacteristic = getBits(pvBuf, 8);
vui->matrix_coeffs = getBits(pvBuf, 8); tVui->u8MatrixCoeffs = getBits(pvBuf, 8);
#if 0
// Set invalid values to "unspecified"
if (!av_color_primaries_name(vui->colour_primaries))
vui->colour_primaries = AVCOL_PRI_UNSPECIFIED;
if (!av_color_transfer_name(vui->transfer_characteristic))
vui->transfer_characteristic = AVCOL_TRC_UNSPECIFIED;
if (!av_color_space_name(vui->matrix_coeffs))
vui->matrix_coeffs = AVCOL_SPC_UNSPECIFIED;
if (vui->matrix_coeffs == AVCOL_SPC_RGB) {
switch (sps->pix_fmt) {
case AV_PIX_FMT_YUV444P:
sps->pix_fmt = AV_PIX_FMT_GBRP;
break;
case AV_PIX_FMT_YUV444P10:
sps->pix_fmt = AV_PIX_FMT_GBRP10;
break;
case AV_PIX_FMT_YUV444P12:
sps->pix_fmt = AV_PIX_FMT_GBRP12;
break;
}
}
#endif
} }
} }
vui->chroma_loc_info_present_flag = getOneBit(pvBuf); tVui->iChromaLocInfoPresentFlag = getOneBit(pvBuf);
if (vui->chroma_loc_info_present_flag) { if (tVui->iChromaLocInfoPresentFlag) {
vui->chroma_sample_loc_type_top_field = parseUe(pvBuf); tVui->iChromaSampleLocTypeTopField = parseUe(pvBuf);
vui->chroma_sample_loc_type_bottom_field = parseUe(pvBuf); tVui->iChromaSampleLocTypeBottomField = parseUe(pvBuf);
} }
vui->neutra_chroma_indication_flag = getOneBit(pvBuf); tVui->iNeutraChromaIndicationFlag = getOneBit(pvBuf);
vui->field_seq_flag = getOneBit(pvBuf); tVui->iFieldSeqFlag = getOneBit(pvBuf);
vui->frame_field_info_present_flag = getOneBit(pvBuf); tVui->iFrameFieldInfoPresentFlag = getOneBit(pvBuf);
// Backup context in case an alternate header is detected // Backup context in case an alternate header is detected
memcpy(&backup, pvBuf, sizeof(backup)); memcpy(&tBackup, pvBuf, sizeof(tBackup));
memcpy(&backup_vui, vui, sizeof(backup_vui)); memcpy(&tBackupVui, tVui, sizeof(tBackupVui));
if (getBitsLeft(pvBuf) >= 68 && showBitsLong(pvBuf, 21) == 0x100000) { if (getBitsLeft(pvBuf) >= 68 && showBitsLong(pvBuf, 21) == 0x100000) {
vui->default_display_window_flag = 0; tVui->iDefaultDisplayWindowFlag = 0;
RPT(RPT_WRN, "Invalid default display window\n"); RPT(RPT_WRN, "Invalid default display window\n");
} else } else
vui->default_display_window_flag = getOneBit(pvBuf); tVui->iDefaultDisplayWindowFlag = getOneBit(pvBuf);
if (vui->default_display_window_flag) { if (tVui->iDefaultDisplayWindowFlag) {
int vert_mult = hevc_sub_height_c[sps->chroma_format_idc]; int vert_mult = sg_au8HevcSubHeightC[ptSps->iChromaFormatIdc];
int horiz_mult = hevc_sub_width_c[sps->chroma_format_idc]; int horiz_mult = sg_au8HevcSubWidthC[ptSps->iChromaFormatIdc];
vui->def_disp_win.left_offset = parseUe(pvBuf) * horiz_mult; tVui->tDefDispWin.uiLeftOffset = parseUe(pvBuf) * horiz_mult;
vui->def_disp_win.right_offset = parseUe(pvBuf) * horiz_mult; tVui->tDefDispWin.uiRightOffset = parseUe(pvBuf) * horiz_mult;
vui->def_disp_win.top_offset = parseUe(pvBuf) * vert_mult; tVui->tDefDispWin.uiTopOffset = parseUe(pvBuf) * vert_mult;
vui->def_disp_win.bottom_offset = parseUe(pvBuf) * vert_mult; tVui->tDefDispWin.uiBottomOffset = parseUe(pvBuf) * vert_mult;
} }
timing_info: timing_info:
vui->vui_timing_info_present_flag = getOneBit(pvBuf); tVui->iVuiTimingInfoPresentFlag = getOneBit(pvBuf);
if (vui->vui_timing_info_present_flag) { if (tVui->iVuiTimingInfoPresentFlag) {
if( getBitsLeft(pvBuf) < 66 && !alt) { if( getBitsLeft(pvBuf) < 66 && !alt) {
// The alternate syntax seem to have timing info located // The alternate syntax seem to have timing info located
// at where def_disp_win is normally located // at where tDefDispWin is normally located
RPT(RPT_WRN, RPT(RPT_WRN,
"Strange VUI timing information, retrying...\n"); "Strange VUI timing information, retrying...\n");
memcpy(vui, &backup_vui, sizeof(backup_vui)); memcpy(tVui, &tBackupVui, sizeof(tBackupVui));
memcpy(pvBuf, &backup, sizeof(backup)); memcpy(pvBuf, &tBackup, sizeof(tBackup));
alt = 1; alt = 1;
goto timing_info; goto timing_info;
} }
vui->vui_num_units_in_tick = getBits(pvBuf, 32); tVui->u32VuiNumUnitsInTick = getBits(pvBuf, 32);
vui->vui_time_scale = getBits(pvBuf, 32); tVui->u32VuiTimeScale = getBits(pvBuf, 32);
if (alt) { if (alt) {
RPT(RPT_INF, "Retry got %u/%u fps\n", RPT(RPT_INF, "Retry got %u/%u fps\n",
vui->vui_time_scale, vui->vui_num_units_in_tick); tVui->u32VuiTimeScale, tVui->u32VuiNumUnitsInTick);
} }
vui->vui_poc_proportional_to_timing_flag = getOneBit(pvBuf); tVui->iVuiPocProportionalToTimingFlag = getOneBit(pvBuf);
if (vui->vui_poc_proportional_to_timing_flag) if (tVui->iVuiPocProportionalToTimingFlag)
vui->vui_num_ticks_poc_diff_one_minus1 = parseUe(pvBuf); tVui->iVuiNumTicksPocDiffOneMinus1 = parseUe(pvBuf);
vui->vui_hrd_parameters_present_flag = getOneBit(pvBuf); tVui->iVuiHrdParametersPresentFlag = getOneBit(pvBuf);
if (vui->vui_hrd_parameters_present_flag) if (tVui->iVuiHrdParametersPresentFlag)
decodeHrd(pvBuf, 1, sps->max_sub_layers); decodeHrd(pvBuf, 1, ptSps->iMaxSubLayers);
} }
vui->bitstream_restriction_flag = getOneBit(pvBuf); tVui->iBitstreamRestrictionFlag = getOneBit(pvBuf);
if (vui->bitstream_restriction_flag) { if (tVui->iBitstreamRestrictionFlag) {
if (getBitsLeft(pvBuf) < 8 && !alt) { if (getBitsLeft(pvBuf) < 8 && !alt) {
RPT(RPT_WRN, RPT(RPT_WRN,
"Strange VUI bitstream restriction information, retrying" "Strange VUI bitstream restriction information, retrying"
" from timing information...\n"); " from timing information...\n");
memcpy(vui, &backup_vui, sizeof(backup_vui)); memcpy(tVui, &tBackupVui, sizeof(tBackupVui));
memcpy(pvBuf, &backup, sizeof(backup)); memcpy(pvBuf, &tBackup, sizeof(tBackup));
alt = 1; alt = 1;
goto timing_info; goto timing_info;
} }
vui->tiles_fixed_structure_flag = getOneBit(pvBuf); tVui->iTilesFixedStructureFlag = getOneBit(pvBuf);
vui->motion_vectors_over_pic_boundaries_flag = getOneBit(pvBuf); tVui->iMotionVectorsOverPicBoundariesFlag = getOneBit(pvBuf);
vui->restricted_ref_pic_lists_flag = getOneBit(pvBuf); tVui->iRestrictedRefPicListsFlag = getOneBit(pvBuf);
vui->min_spatial_segmentation_idc = parseUe(pvBuf); tVui->iMinSpatialSegmentationIdc = parseUe(pvBuf);
vui->max_bytes_per_pic_denom = parseUe(pvBuf); tVui->iMaxBytesPerPicDenom = parseUe(pvBuf);
vui->max_bits_per_min_cu_denom = parseUe(pvBuf); tVui->iMaxBitsPerMinCuDenom = parseUe(pvBuf);
vui->log2_max_mv_length_horizontal = parseUe(pvBuf); tVui->iLog2MaxMvLengthHorizontal = parseUe(pvBuf);
vui->log2_max_mv_length_vertical = parseUe(pvBuf); tVui->iLog2MaxMvLengthVertical = parseUe(pvBuf);
} }
if (getBitsLeft(pvBuf) < 1 && !alt) { if (getBitsLeft(pvBuf) < 1 && !alt) {
// XXX: Alternate syntax when sps_range_extension_flag != 0? // XXX: Alternate syntax when iSpsRangeExtensionFlag != 0?
RPT(RPT_WRN, RPT(RPT_WRN,
"Overread in VUI, retrying from timing information...\n"); "Overread in VUI, retrying from timing information...\n");
memcpy(vui, &backup_vui, sizeof(backup_vui)); memcpy(tVui, &tBackupVui, sizeof(tBackupVui));
memcpy(pvBuf, &backup, sizeof(backup)); memcpy(pvBuf, &tBackup, sizeof(tBackup));
alt = 1; alt = 1;
goto timing_info; goto timing_info;
} }
} }
static unsigned avModUintp2c(unsigned a, unsigned p)
{
return a & ((1 << p) - 1);
}
int h265DecSeqParameterSet( void *pvBufSrc, T_HEVCSPS *sps ) int h265DecSeqParameterSet( void *pvBufSrc, T_HEVCSPS *ptSps )
{ {
T_HEVCWindow *ow; T_HEVCWindow *ow;
// int ret = 0; int iLog2DiffMaxMinTransformBlockSize;
int log2_diff_max_min_transform_block_size; int iBitDepthChroma, iStart, iVuiPresent, iSublayerOrderingInfo;
int bit_depth_chroma, start, vui_present, sublayer_ordering_info;
int i; int i;
int iRet = 0; int iRet = 0;
void *pvBuf = NULL; void *pvBuf = NULL;
if(NULL == pvBufSrc || NULL == sps) if(NULL == pvBufSrc || NULL == ptSps)
{ {
RPT(RPT_ERR,"ERR null pointer\n"); RPT(RPT_ERR,"ERR null pointer\n");
iRet = -1; iRet = -1;
goto exit; goto exit;
} }
memset((void *)sps, 0, sizeof(T_HEVCSPS)); memset((void *)ptSps, 0, sizeof(T_HEVCSPS));
pvBuf = deEmulationPrevention(pvBufSrc); pvBuf = deEmulationPrevention(pvBufSrc);
if(NULL == pvBuf) if(NULL == pvBuf)
...@@ -1717,34 +1696,25 @@ int h265DecSeqParameterSet( void *pvBufSrc, T_HEVCSPS *sps ) ...@@ -1717,34 +1696,25 @@ int h265DecSeqParameterSet( void *pvBufSrc, T_HEVCSPS *sps )
goto exit; goto exit;
} }
// Coded parameters // Coded parameters
sps->vps_id = getBits(pvBuf, 4); ptSps->uiVpsId = getBits(pvBuf, 4);
if (sps->vps_id >= HEVC_MAX_VPS_COUNT) { if (ptSps->uiVpsId >= HEVC_MAX_VPS_COUNT) {
RPT(RPT_ERR, "VPS id out of range: %d\n", sps->vps_id); RPT(RPT_ERR, "VPS id out of range: %d\n", ptSps->uiVpsId);
iRet = -1; iRet = -1;
goto exit; goto exit;
} }
#if 0 ptSps->iMaxSubLayers = getBits(pvBuf, 3) + 1;
if (vps_list && !vps_list[sps->vps_id]) { if (ptSps->iMaxSubLayers > HEVC_MAX_SUB_LAYERS) {
RPT(RPT_ERR, "VPS %d does not exist\n",
sps->vps_id);
return AVERROR_INVALIDDATA;
}
#endif
sps->max_sub_layers = getBits(pvBuf, 3) + 1;
if (sps->max_sub_layers > HEVC_MAX_SUB_LAYERS) {
RPT(RPT_ERR, "sps_max_sub_layers out of range: %d\n", RPT(RPT_ERR, "sps_max_sub_layers out of range: %d\n",
sps->max_sub_layers); ptSps->iMaxSubLayers);
iRet = -1; iRet = -1;
goto exit; goto exit;
} }
sps->temporal_id_nesting_flag = getBits(pvBuf, 1); ptSps->u8temporalIdNestingFlag = getBits(pvBuf, 1);
if ((iRet = parsePtl(pvBuf, &sps->ptl, sps->max_sub_layers)) < 0) if ((iRet = parsePtl(pvBuf, &ptSps->tPtl, ptSps->iMaxSubLayers)) < 0)
goto exit; goto exit;
int sps_id = parseUe(pvBuf); int sps_id = parseUe(pvBuf);
...@@ -1754,320 +1724,290 @@ int h265DecSeqParameterSet( void *pvBufSrc, T_HEVCSPS *sps ) ...@@ -1754,320 +1724,290 @@ int h265DecSeqParameterSet( void *pvBufSrc, T_HEVCSPS *sps )
goto exit; goto exit;
} }
sps->chroma_format_idc = parseUe(pvBuf); ptSps->iChromaFormatIdc = parseUe(pvBuf);
if (sps->chroma_format_idc > 3U) { if (ptSps->iChromaFormatIdc > 3U) {
RPT(RPT_ERR, "chroma_format_idc %d is invalid\n", sps->chroma_format_idc); RPT(RPT_ERR, "iChromaFormatIdc %d is invalid\n", ptSps->iChromaFormatIdc);
iRet = -1; iRet = -1;
goto exit; goto exit;
} }
if (sps->chroma_format_idc == 3) if (ptSps->iChromaFormatIdc == 3)
sps->separate_colour_plane_flag = getOneBit(pvBuf); ptSps->u8SeparateColourPlaneFlag = getOneBit(pvBuf);
if (sps->separate_colour_plane_flag)
sps->chroma_format_idc = 0;
sps->width = parseUe(pvBuf); if (ptSps->u8SeparateColourPlaneFlag)
sps->height = parseUe(pvBuf); ptSps->iChromaFormatIdc = 0;
// if ((iRet = av_image_check_size(sps->width, ptSps->iWidth = parseUe(pvBuf);
// sps->height, 0, avctx)) < 0) ptSps->iHeight = parseUe(pvBuf);
// goto exit;
if (getOneBit(pvBuf)) { // pic_conformance_flag if (getOneBit(pvBuf)) { // pic_conformance_flag
int vert_mult = hevc_sub_height_c[sps->chroma_format_idc]; int vert_mult = sg_au8HevcSubHeightC[ptSps->iChromaFormatIdc];
int horiz_mult = hevc_sub_width_c[sps->chroma_format_idc]; int horiz_mult = sg_au8HevcSubWidthC[ptSps->iChromaFormatIdc];
sps->pic_conf_win.left_offset = parseUe(pvBuf) * horiz_mult; ptSps->tPicConfWin.uiLeftOffset = parseUe(pvBuf) * horiz_mult;
sps->pic_conf_win.right_offset = parseUe(pvBuf) * horiz_mult; ptSps->tPicConfWin.uiRightOffset = parseUe(pvBuf) * horiz_mult;
sps->pic_conf_win.top_offset = parseUe(pvBuf) * vert_mult; ptSps->tPicConfWin.uiTopOffset = parseUe(pvBuf) * vert_mult;
sps->pic_conf_win.bottom_offset = parseUe(pvBuf) * vert_mult; ptSps->tPicConfWin.uiBottomOffset = parseUe(pvBuf) * vert_mult;
sps->output_window = sps->pic_conf_win; ptSps->tOutputWindow = ptSps->tPicConfWin;
} }
sps->bit_depth = parseUe(pvBuf) + 8; ptSps->iBitDepth = parseUe(pvBuf) + 8;
bit_depth_chroma = parseUe(pvBuf) + 8; iBitDepthChroma = parseUe(pvBuf) + 8;
if (sps->chroma_format_idc && bit_depth_chroma != sps->bit_depth) { if (ptSps->iChromaFormatIdc && iBitDepthChroma != ptSps->iBitDepth) {
RPT(RPT_ERR, RPT(RPT_ERR,
"Luma bit depth (%d) is different from chroma bit depth (%d), " "Luma bit depth (%d) is different from chroma bit depth (%d), "
"this is unsupported.\n", "this is unsupported.\n",
sps->bit_depth, bit_depth_chroma); ptSps->iBitDepth, iBitDepthChroma);
iRet = -1; iRet = -1;
goto exit; goto exit;
} }
sps->bit_depth_chroma = bit_depth_chroma; ptSps->iBitDepthChroma = iBitDepthChroma;
#if 0
iRet = map_pixel_format(avctx, sps);
if (iRet < 0)
goto exit;
#endif
#if 0
sps->log2_max_poc_lsb = parseUe(pvBuf) + 4; ptSps->uiLog2MaxPocLsb = parseUe(pvBuf) + 4;
if (sps->log2_max_poc_lsb > 16) { if (ptSps->uiLog2MaxPocLsb > 16) {
RPT(RPT_ERR, "log2_max_pic_order_cnt_lsb_minus4 out range: %d\n", RPT(RPT_ERR, "log2_max_pic_order_cnt_lsb_minus4 out range: %d\n",
sps->log2_max_poc_lsb - 4); ptSps->uiLog2MaxPocLsb - 4);
iRet = -1; iRet = -1;
goto exit; goto exit;
} }
sublayer_ordering_info = getOneBit(pvBuf); iSublayerOrderingInfo = getOneBit(pvBuf);
start = sublayer_ordering_info ? 0 : sps->max_sub_layers - 1; iStart = iSublayerOrderingInfo ? 0 : ptSps->iMaxSubLayers - 1;
for (i = start; i < sps->max_sub_layers; i++) { for (i = iStart; i < ptSps->iMaxSubLayers; i++) {
sps->temporal_layer[i].max_dec_pic_buffering = parseUe(pvBuf) + 1; ptSps->stTemporalLayer[i].iMaxDecPicBuffering = parseUe(pvBuf) + 1;
sps->temporal_layer[i].num_reorder_pics = parseUe(pvBuf); ptSps->stTemporalLayer[i].iNumReorderPics = parseUe(pvBuf);
sps->temporal_layer[i].max_latency_increase = parseUe(pvBuf) - 1; ptSps->stTemporalLayer[i].iMaxLatencyIncrease = parseUe(pvBuf) - 1;
if (sps->temporal_layer[i].max_dec_pic_buffering > (unsigned)HEVC_MAX_DPB_SIZE) { if (ptSps->stTemporalLayer[i].iMaxDecPicBuffering > (unsigned)HEVC_MAX_DPB_SIZE) {
RPT(RPT_ERR, "sps_max_dec_pic_buffering_minus1 out of range: %d\n", RPT(RPT_ERR, "sps_max_dec_pic_buffering_minus1 out of range: %d\n",
sps->temporal_layer[i].max_dec_pic_buffering - 1U); ptSps->stTemporalLayer[i].iMaxDecPicBuffering - 1U);
iRet = -1; iRet = -1;
goto exit; goto exit;
} }
if (sps->temporal_layer[i].num_reorder_pics > sps->temporal_layer[i].max_dec_pic_buffering - 1) { if (ptSps->stTemporalLayer[i].iNumReorderPics > ptSps->stTemporalLayer[i].iMaxDecPicBuffering - 1) {
RPT(RPT_WRN, "sps_max_num_reorder_pics out of range: %d\n", RPT(RPT_WRN, "sps_max_num_reorder_pics out of range: %d\n",
sps->temporal_layer[i].num_reorder_pics); ptSps->stTemporalLayer[i].iNumReorderPics);
if (sps->temporal_layer[i].num_reorder_pics > HEVC_MAX_DPB_SIZE - 1) { if (ptSps->stTemporalLayer[i].iNumReorderPics > HEVC_MAX_DPB_SIZE - 1) {
iRet = -1; iRet = -1;
goto exit; goto exit;
} }
sps->temporal_layer[i].max_dec_pic_buffering = sps->temporal_layer[i].num_reorder_pics + 1; ptSps->stTemporalLayer[i].iMaxDecPicBuffering = ptSps->stTemporalLayer[i].iNumReorderPics + 1;
} }
} }
if (!sublayer_ordering_info) { if (!iSublayerOrderingInfo) {
for (i = 0; i < start; i++) { for (i = 0; i < iStart; i++) {
sps->temporal_layer[i].max_dec_pic_buffering = sps->temporal_layer[start].max_dec_pic_buffering; ptSps->stTemporalLayer[i].iMaxDecPicBuffering = ptSps->stTemporalLayer[iStart].iMaxDecPicBuffering;
sps->temporal_layer[i].num_reorder_pics = sps->temporal_layer[start].num_reorder_pics; ptSps->stTemporalLayer[i].iNumReorderPics = ptSps->stTemporalLayer[iStart].iNumReorderPics;
sps->temporal_layer[i].max_latency_increase = sps->temporal_layer[start].max_latency_increase; ptSps->stTemporalLayer[i].iMaxLatencyIncrease = ptSps->stTemporalLayer[iStart].iMaxLatencyIncrease;
} }
} }
sps->log2_min_cb_size = parseUe(pvBuf) + 3; ptSps->uiLog2MinCbSize = parseUe(pvBuf) + 3;
sps->log2_diff_max_min_coding_block_size = parseUe(pvBuf); ptSps->uiLog2DiffMaxMinCodingBlockSize = parseUe(pvBuf);
sps->log2_min_tb_size = parseUe(pvBuf) + 2; ptSps->uiLog2MinTbSize = parseUe(pvBuf) + 2;
log2_diff_max_min_transform_block_size = parseUe(pvBuf); iLog2DiffMaxMinTransformBlockSize = parseUe(pvBuf);
sps->log2_max_trafo_size = log2_diff_max_min_transform_block_size + ptSps->uiLog2MaxTrafoSize = iLog2DiffMaxMinTransformBlockSize +
sps->log2_min_tb_size; ptSps->uiLog2MinTbSize;
if (sps->log2_min_cb_size < 3 || sps->log2_min_cb_size > 30) { if (ptSps->uiLog2MinCbSize < 3 || ptSps->uiLog2MinCbSize > 30) {
RPT(RPT_ERR, "Invalid value %d for log2_min_cb_size", sps->log2_min_cb_size); RPT(RPT_ERR, "Invalid value %d for uiLog2MinCbSize", ptSps->uiLog2MinCbSize);
iRet = -1; iRet = -1;
goto exit; goto exit;
} }
if (sps->log2_diff_max_min_coding_block_size > 30) { if (ptSps->uiLog2DiffMaxMinCodingBlockSize > 30) {
RPT(RPT_ERR, "Invalid value %d for log2_diff_max_min_coding_block_size", sps->log2_diff_max_min_coding_block_size); RPT(RPT_ERR, "Invalid value %d for uiLog2DiffMaxMinCodingBlockSize", ptSps->uiLog2DiffMaxMinCodingBlockSize);
iRet = -1; iRet = -1;
goto exit; goto exit;
} }
if (sps->log2_min_tb_size >= sps->log2_min_cb_size || sps->log2_min_tb_size < 2) { if (ptSps->uiLog2MinTbSize >= ptSps->uiLog2MinCbSize || ptSps->uiLog2MinTbSize < 2) {
RPT(RPT_ERR, "Invalid value for log2_min_tb_size"); RPT(RPT_ERR, "Invalid value for uiLog2MinTbSize");
iRet = -1; iRet = -1;
goto exit; goto exit;
} }
if (log2_diff_max_min_transform_block_size < 0 || log2_diff_max_min_transform_block_size > 30) { if (iLog2DiffMaxMinTransformBlockSize < 0 || iLog2DiffMaxMinTransformBlockSize > 30) {
RPT(RPT_ERR, "Invalid value %d for log2_diff_max_min_transform_block_size", log2_diff_max_min_transform_block_size); RPT(RPT_ERR, "Invalid value %d for iLog2DiffMaxMinTransformBlockSize", iLog2DiffMaxMinTransformBlockSize);
iRet = -1; iRet = -1;
goto exit; goto exit;
} }
sps->max_transform_hierarchy_depth_inter = parseUe(pvBuf); ptSps->iMaxTransformHierarchyDepthInter = parseUe(pvBuf);
sps->max_transform_hierarchy_depth_intra = parseUe(pvBuf); ptSps->iMaxTransformHierarchyDepthIntra = parseUe(pvBuf);
sps->scaling_list_enable_flag = getOneBit(pvBuf); ptSps->u8ScalingListEnableFlag = getOneBit(pvBuf);
printf("sps->scaling_list_enable_flag: %d\n",sps->scaling_list_enable_flag); if (ptSps->u8ScalingListEnableFlag) {
setDefaultScalingListData(&ptSps->tScalingList);
if (sps->scaling_list_enable_flag) {
setDefaultScalingListData(&sps->scaling_list);
if (getOneBit(pvBuf)) { if (getOneBit(pvBuf)) {
iRet = scalingListData(pvBuf, &sps->scaling_list, sps); iRet = scalingListData(pvBuf, &ptSps->tScalingList, ptSps);
if (iRet < 0) if (iRet < 0)
goto exit; goto exit;
} }
} }
sps->amp_enabled_flag = getOneBit(pvBuf); ptSps->u8AmpEnabledFlag = getOneBit(pvBuf);
sps->sao_enabled = getOneBit(pvBuf); ptSps->u8SaoEnabled = getOneBit(pvBuf);
sps->pcm_enabled_flag = getOneBit(pvBuf); ptSps->iPcmEnabledFlag = getOneBit(pvBuf);
printf("sps->pcm_enabled_flag: %d\n",sps->pcm_enabled_flag); if (ptSps->iPcmEnabledFlag) {
if (sps->pcm_enabled_flag) { ptSps->pcm.u8BitDepth = getBits(pvBuf, 4) + 1;
sps->pcm.bit_depth = getBits(pvBuf, 4) + 1; ptSps->pcm.u8BitDepthChroma = getBits(pvBuf, 4) + 1;
sps->pcm.bit_depth_chroma = getBits(pvBuf, 4) + 1; ptSps->pcm.uiLog2MinPcmCbSize = parseUe(pvBuf) + 3;
sps->pcm.log2_min_pcm_cb_size = parseUe(pvBuf) + 3; ptSps->pcm.uiLog2MaxPcmCbSize = ptSps->pcm.uiLog2MinPcmCbSize +
sps->pcm.log2_max_pcm_cb_size = sps->pcm.log2_min_pcm_cb_size +
parseUe(pvBuf); parseUe(pvBuf);
if (FFMAX(sps->pcm.bit_depth, sps->pcm.bit_depth_chroma) > sps->bit_depth) { if (FFMAX(ptSps->pcm.u8BitDepth, ptSps->pcm.u8BitDepthChroma) > ptSps->iBitDepth) {
RPT(RPT_ERR, RPT(RPT_ERR,
"PCM bit depth (%d, %d) is greater than normal bit depth (%d)\n", "PCM bit depth (%d, %d) is greater than normal bit depth (%d)\n",
sps->pcm.bit_depth, sps->pcm.bit_depth_chroma, sps->bit_depth); ptSps->pcm.u8BitDepth, ptSps->pcm.u8BitDepthChroma, ptSps->iBitDepth);
iRet = -1; iRet = -1;
goto exit; goto exit;
} }
sps->pcm.loop_filter_disable_flag = getOneBit(pvBuf); ptSps->pcm.u8LoopFilterDisableFlag = getOneBit(pvBuf);
} }
sps->nb_st_rps = parseUe(pvBuf); ptSps->uiNbStRps = parseUe(pvBuf);
if (sps->nb_st_rps > HEVC_MAX_SHORT_TERM_REF_PIC_SETS) { if (ptSps->uiNbStRps > HEVC_MAX_SHORT_TERM_REF_PIC_SETS) {
RPT(RPT_ERR, "Too many short term RPS: %d.\n", RPT(RPT_ERR, "Too many short term RPS: %d.\n",
sps->nb_st_rps); ptSps->uiNbStRps);
iRet = -1; iRet = -1;
goto exit; goto exit;
} }
printf("sps->nb_st_rps: %d\n",sps->nb_st_rps); for (i = 0; i < ptSps->uiNbStRps; i++) {
for (i = 0; i < sps->nb_st_rps; i++) { if ((iRet = hevcDecodeShortTermRps(pvBuf, &ptSps->atStRps[i],
if ((iRet = hevcDecodeShortTermRps(pvBuf, &sps->st_rps[i], ptSps, 0)) < 0)
sps, 0)) < 0)
goto exit; goto exit;
} }
sps->long_term_ref_pics_present_flag = getOneBit(pvBuf); ptSps->u8LongTermRefPicsPresentFlag = getOneBit(pvBuf);
if (sps->long_term_ref_pics_present_flag) { if (ptSps->u8LongTermRefPicsPresentFlag) {
sps->num_long_term_ref_pics_sps = parseUe(pvBuf); ptSps->u8NumLongTermRefPicsSps = parseUe(pvBuf);
if (sps->num_long_term_ref_pics_sps > HEVC_MAX_LONG_TERM_REF_PICS) { if (ptSps->u8NumLongTermRefPicsSps > HEVC_MAX_LONG_TERM_REF_PICS) {
RPT(RPT_ERR, "Too many long term ref pics: %d.\n", RPT(RPT_ERR, "Too many long term ref pics: %d.\n",
sps->num_long_term_ref_pics_sps); ptSps->u8NumLongTermRefPicsSps);
iRet = -1; iRet = -1;
goto exit; goto exit;
} }
for (i = 0; i < sps->num_long_term_ref_pics_sps; i++) { for (i = 0; i < ptSps->u8NumLongTermRefPicsSps; i++) {
sps->lt_ref_pic_poc_lsb_sps[i] = getBits(pvBuf, sps->log2_max_poc_lsb); ptSps->au16LtRefPicPocLsbSps[i] = getBits(pvBuf, ptSps->uiLog2MaxPocLsb);
sps->used_by_curr_pic_lt_sps_flag[i] = getOneBit(pvBuf); ptSps->au8UsedByCurrPicLtSpsFlag[i] = getOneBit(pvBuf);
} }
} }
sps->sps_temporal_mvp_enabled_flag = getOneBit(pvBuf); ptSps->u8SpsTemporalMvpEnabledFlag = getOneBit(pvBuf);
sps->sps_strong_intra_smoothing_enable_flag = getOneBit(pvBuf); ptSps->u8SpsStrongIntraMmoothingEnableFlag = getOneBit(pvBuf);
sps->vui.sar = (T_AVRational){0, 1}; ptSps->tVui.tSar = (T_AVRational){0, 1};
vui_present = getOneBit(pvBuf); ptSps->iVuiPresent = getOneBit(pvBuf);
if (vui_present==1) if (ptSps->iVuiPresent)
decodeVui(pvBuf, sps); decodeVui(pvBuf, ptSps);
#endif
#if 0
if (getOneBit(pvBuf)) { // sps_extension_flag if (getOneBit(pvBuf)) { // sps_extension_flag
int sps_range_extension_flag = getOneBit(pvBuf); int iSpsRangeExtensionFlag = getOneBit(pvBuf);
getBits(pvBuf, 7); //sps_extension_7bits = getBits(pvBuf, 7); getBits(pvBuf, 7); //sps_extension_7bits = getBits(pvBuf, 7);
if (sps_range_extension_flag) { if (iSpsRangeExtensionFlag) {
int extended_precision_processing_flag; int iExtendedPrecisionProcessingFlag;
int cabac_bypass_alignment_enabled_flag; int iCabacBypassAlignmentEnabledFlag;
sps->transform_skip_rotation_enabled_flag = getOneBit(pvBuf); ptSps->iTransformSkipRotationEnabledFlag = getOneBit(pvBuf);
sps->transform_skip_context_enabled_flag = getOneBit(pvBuf); ptSps->iTransformSkipContextEnabledFlag = getOneBit(pvBuf);
sps->implicit_rdpcm_enabled_flag = getOneBit(pvBuf); ptSps->iImplicitRdpcmEnabledFlag = getOneBit(pvBuf);
sps->explicit_rdpcm_enabled_flag = getOneBit(pvBuf); ptSps->iExplicitRdpcmEnabledFlag = getOneBit(pvBuf);
extended_precision_processing_flag = getOneBit(pvBuf); iExtendedPrecisionProcessingFlag = getOneBit(pvBuf);
if (extended_precision_processing_flag) if (iExtendedPrecisionProcessingFlag)
RPT(RPT_WRN, RPT(RPT_WRN,
"extended_precision_processing_flag not yet implemented\n"); "iExtendedPrecisionProcessingFlag not yet implemented\n");
sps->intra_smoothing_disabled_flag = getOneBit(pvBuf); ptSps->iIntraSmoothingDisabledFlag = getOneBit(pvBuf);
sps->high_precision_offsets_enabled_flag = getOneBit(pvBuf); ptSps->iHighPrecisionOffsetsEnabledFlag = getOneBit(pvBuf);
if (sps->high_precision_offsets_enabled_flag) if (ptSps->iHighPrecisionOffsetsEnabledFlag)
RPT(RPT_WRN, RPT(RPT_WRN,
"high_precision_offsets_enabled_flag not yet implemented\n"); "iHighPrecisionOffsetsEnabledFlag not yet implemented\n");
sps->persistent_rice_adaptation_enabled_flag = getOneBit(pvBuf); ptSps->iPersistentRiceAdaptationEnabledFlag = getOneBit(pvBuf);
cabac_bypass_alignment_enabled_flag = getOneBit(pvBuf); iCabacBypassAlignmentEnabledFlag = getOneBit(pvBuf);
if (cabac_bypass_alignment_enabled_flag) if (iCabacBypassAlignmentEnabledFlag)
RPT(RPT_WRN, RPT(RPT_WRN,
"cabac_bypass_alignment_enabled_flag not yet implemented\n"); "iCabacBypassAlignmentEnabledFlag not yet implemented\n");
} }
} }
if (apply_defdispwin) {
sps->output_window.left_offset += sps->vui.def_disp_win.left_offset;
sps->output_window.right_offset += sps->vui.def_disp_win.right_offset;
sps->output_window.top_offset += sps->vui.def_disp_win.top_offset;
sps->output_window.bottom_offset += sps->vui.def_disp_win.bottom_offset;
}
ow = &sps->output_window; ow = &ptSps->tOutputWindow;
if (ow->left_offset >= INT_MAX - ow->right_offset || if (ow->uiLeftOffset >= INT_MAX - ow->uiRightOffset ||
ow->top_offset >= INT_MAX - ow->bottom_offset || ow->uiTopOffset >= INT_MAX - ow->uiBottomOffset ||
ow->left_offset + ow->right_offset >= sps->width || ow->uiLeftOffset + ow->uiRightOffset >= ptSps->iWidth ||
ow->top_offset + ow->bottom_offset >= sps->height) { ow->uiTopOffset + ow->uiBottomOffset >= ptSps->iHeight) {
RPT(RPT_WRN, "Invalid cropping offsets: %u/%u/%u/%u\n", RPT(RPT_WRN, "Invalid cropping offsets: %u/%u/%u/%u\n",
ow->left_offset, ow->right_offset, ow->top_offset, ow->bottom_offset); ow->uiLeftOffset, ow->uiRightOffset, ow->uiTopOffset, ow->uiBottomOffset);
if (avctx->err_recognition & AV_EF_EXPLODE) {
return AVERROR_INVALIDDATA;
}
RPT(RPT_WRN, RPT(RPT_WRN,
"Displaying the whole video surface.\n"); "Displaying the whole video surface.\n");
memset(ow, 0, sizeof(*ow)); memset(ow, 0, sizeof(*ow));
memset(&sps->pic_conf_win, 0, sizeof(sps->pic_conf_win)); memset(&ptSps->tPicConfWin, 0, sizeof(ptSps->tPicConfWin));
} }
// Inferred parameters // Inferred parameters
sps->log2_ctb_size = sps->log2_min_cb_size + ptSps->uiLog2CtbSize = ptSps->uiLog2MinCbSize +
sps->log2_diff_max_min_coding_block_size; ptSps->uiLog2DiffMaxMinCodingBlockSize;
sps->log2_min_pu_size = sps->log2_min_cb_size - 1; ptSps->uiLog2MinPuSize = ptSps->uiLog2MinCbSize - 1;
if (sps->log2_ctb_size > HEVC_MAX_LOG2_CTB_SIZE) { if (ptSps->uiLog2CtbSize > HEVC_MAX_LOG2_CTB_SIZE) {
RPT(RPT_ERR, "CTB size out of range: 2^%d\n", sps->log2_ctb_size); RPT(RPT_ERR, "CTB size out of range: 2^%d\n", ptSps->uiLog2CtbSize);
iRet = -1;
iRet = -1; iRet = -1;
goto exit; goto exit;
} }
if (sps->log2_ctb_size < 4) { if (ptSps->uiLog2CtbSize < 4) {
RPT(RPT_ERR, RPT(RPT_ERR,
"log2_ctb_size %d differs from the bounds of any known profile\n", "uiLog2CtbSize %d differs from the bounds of any known profile\n",
sps->log2_ctb_size); ptSps->uiLog2CtbSize);
avpriv_request_sample(avctx, "log2_ctb_size %d", sps->log2_ctb_size);
iRet = -1;
iRet = -1; iRet = -1;
goto exit; goto exit;
} }
sps->ctb_width = (sps->width + (1 << sps->log2_ctb_size) - 1) >> sps->log2_ctb_size; ptSps->iCtbWidth = (ptSps->iWidth + (1 << ptSps->uiLog2CtbSize) - 1) >> ptSps->uiLog2CtbSize;
sps->ctb_height = (sps->height + (1 << sps->log2_ctb_size) - 1) >> sps->log2_ctb_size; ptSps->iCtbHeight = (ptSps->iHeight + (1 << ptSps->uiLog2CtbSize) - 1) >> ptSps->uiLog2CtbSize;
sps->ctb_size = sps->ctb_width * sps->ctb_height; ptSps->iCtbSize = ptSps->iCtbWidth * ptSps->iCtbHeight;
sps->min_cb_width = sps->width >> sps->log2_min_cb_size; ptSps->iMinCbWidth = ptSps->iWidth >> ptSps->uiLog2MinCbSize;
sps->min_cb_height = sps->height >> sps->log2_min_cb_size; ptSps->iMinCbHeight = ptSps->iHeight >> ptSps->uiLog2MinCbSize;
sps->min_tb_width = sps->width >> sps->log2_min_tb_size; ptSps->iMinTbWidth = ptSps->iWidth >> ptSps->uiLog2MinTbSize;
sps->min_tb_height = sps->height >> sps->log2_min_tb_size; ptSps->iMinTbHeight = ptSps->iHeight >> ptSps->uiLog2MinTbSize;
sps->min_pu_width = sps->width >> sps->log2_min_pu_size; ptSps->iMinPuWidth = ptSps->iWidth >> ptSps->uiLog2MinPuSize;
sps->min_pu_height = sps->height >> sps->log2_min_pu_size; ptSps->iMinPuHeight = ptSps->iHeight >> ptSps->uiLog2MinPuSize;
sps->tb_mask = (1 << (sps->log2_ctb_size - sps->log2_min_tb_size)) - 1; ptSps->iTbMask = (1 << (ptSps->uiLog2CtbSize - ptSps->uiLog2MinTbSize)) - 1;
sps->qp_bd_offset = 6 * (sps->bit_depth - 8); ptSps->iQpBdOffset = 6 * (ptSps->iBitDepth - 8);
if (av_mod_uintp2(sps->width, sps->log2_min_cb_size) || if (avModUintp2c(ptSps->iWidth, ptSps->uiLog2MinCbSize) ||
av_mod_uintp2(sps->height, sps->log2_min_cb_size)) { avModUintp2c(ptSps->iHeight, ptSps->uiLog2MinCbSize)) {
RPT(RPT_ERR, "Invalid coded frame dimensions.\n"); RPT(RPT_ERR, "Invalid coded frame dimensions.\n");
iRet = -1; iRet = -1;
goto exit; goto exit;
} }
if (sps->max_transform_hierarchy_depth_inter > sps->log2_ctb_size - sps->log2_min_tb_size) { if (ptSps->iMaxTransformHierarchyDepthInter > ptSps->uiLog2CtbSize - ptSps->uiLog2MinTbSize) {
RPT(RPT_ERR, "max_transform_hierarchy_depth_inter out of range: %d\n", RPT(RPT_ERR, "iMaxTransformHierarchyDepthInter out of range: %d\n",
sps->max_transform_hierarchy_depth_inter); ptSps->iMaxTransformHierarchyDepthInter);
iRet = -1; iRet = -1;
goto exit; goto exit;
} }
if (sps->max_transform_hierarchy_depth_intra > sps->log2_ctb_size - sps->log2_min_tb_size) { if (ptSps->iMaxTransformHierarchyDepthIntra > ptSps->uiLog2CtbSize - ptSps->uiLog2MinTbSize) {
RPT(RPT_ERR, "max_transform_hierarchy_depth_intra out of range: %d\n", RPT(RPT_ERR, "iMaxTransformHierarchyDepthIntra out of range: %d\n",
sps->max_transform_hierarchy_depth_intra); ptSps->iMaxTransformHierarchyDepthIntra);
iRet = -1; iRet = -1;
goto exit; goto exit;
} }
if (sps->log2_max_trafo_size > FFMIN(sps->log2_ctb_size, 5)) { if (ptSps->uiLog2MaxTrafoSize > FFMIN(ptSps->uiLog2CtbSize, 5)) {
RPT(RPT_ERR, RPT(RPT_ERR,
"max transform block size out of range: %d\n", "max transform block size out of range: %d\n",
sps->log2_max_trafo_size); ptSps->uiLog2MaxTrafoSize);
iRet = -1; iRet = -1;
goto exit; goto exit;
} }
...@@ -2078,7 +2018,6 @@ int h265DecSeqParameterSet( void *pvBufSrc, T_HEVCSPS *sps ) ...@@ -2078,7 +2018,6 @@ int h265DecSeqParameterSet( void *pvBufSrc, T_HEVCSPS *sps )
iRet = -1; iRet = -1;
goto exit; goto exit;
} }
#endif
exit: exit:
...@@ -2089,6 +2028,141 @@ exit: ...@@ -2089,6 +2028,141 @@ exit:
} }
int h265DecVideoParameterSet( void *pvBufSrc, T_HEVCVPS *ptVps )
{
int iRet = 0;
int i,j;
int uiVpsId = 0;
void *pvBuf = NULL;
if(NULL == pvBufSrc || NULL == ptVps)
{
RPT(RPT_ERR,"ERR null pointer\n");
iRet = -1;
goto exit;
}
memset((void *)ptVps, 0, sizeof(T_HEVCVPS));
pvBuf = deEmulationPrevention(pvBufSrc);
if(NULL == pvBuf)
{
RPT(RPT_ERR,"ERR null pointer\n");
iRet = -1;
goto exit;
}
RPT(RPT_DBG, "Decoding VPS\n");
uiVpsId = getBits(pvBuf, 4);
if (uiVpsId >= HEVC_MAX_VPS_COUNT) {
RPT(RPT_ERR, "VPS id out of range: %d\n", uiVpsId);
iRet = -1;
goto exit;
}
if (getBits(pvBuf, 2) != 3) { // vps_reserved_three_2bits
RPT(RPT_ERR, "vps_reserved_three_2bits is not three\n");
iRet = -1;
goto exit;
}
ptVps->iVpsMaxLayers = getBits(pvBuf, 6) + 1;
ptVps->iVpsMaxSubLayers = getBits(pvBuf, 3) + 1;
ptVps->u8VpsTemporalIdNestingFlag = getOneBit(pvBuf);
if (getBits(pvBuf, 16) != 0xffff) { // vps_reserved_ffff_16bits
RPT(RPT_ERR, "vps_reserved_ffff_16bits is not 0xffff\n");
iRet = -1;
goto exit;
}
if (ptVps->iVpsMaxSubLayers > HEVC_MAX_SUB_LAYERS) {
RPT(RPT_ERR, "iVpsMaxSubLayers out of range: %d\n",
ptVps->iVpsMaxSubLayers);
iRet = -1;
goto exit;
}
if (parsePtl(pvBuf, &ptVps->tPtl, ptVps->iVpsMaxSubLayers) < 0){
iRet = -1;
goto exit;
}
ptVps->iVpsSubLayerOrderingInfoPresentFlag = getOneBit(pvBuf);
i = ptVps->iVpsSubLayerOrderingInfoPresentFlag ? 0 : ptVps->iVpsMaxSubLayers - 1;
for (; i < ptVps->iVpsMaxSubLayers; i++) {
ptVps->uiVpsMaxDecPicBuffering[i] = parseUe(pvBuf) + 1;
ptVps->auiVpsNumReorderPics[i] = parseUe(pvBuf);
ptVps->auiVpsMaxLatencyIncrease[i] = parseUe(pvBuf) - 1;
if (ptVps->uiVpsMaxDecPicBuffering[i] > HEVC_MAX_DPB_SIZE || !ptVps->uiVpsMaxDecPicBuffering[i]) {
RPT(RPT_ERR, "vps_max_dec_pic_buffering_minus1 out of range: %d\n",
ptVps->uiVpsMaxDecPicBuffering[i] - 1);
iRet = -1;
goto exit;
}
if (ptVps->auiVpsNumReorderPics[i] > ptVps->uiVpsMaxDecPicBuffering[i] - 1) {
RPT(RPT_WRN, "vps_max_num_reorder_pics out of range: %d\n",
ptVps->auiVpsNumReorderPics[i]);
}
}
ptVps->iVpsMaxLayerId = getBits(pvBuf, 6);
ptVps->iVpsNumLayerSets = parseUe(pvBuf) + 1;
if (ptVps->iVpsNumLayerSets < 1 || ptVps->iVpsNumLayerSets > 1024 ||
(ptVps->iVpsNumLayerSets - 1LL) * (ptVps->iVpsMaxLayerId + 1LL) > getBitsLeft(pvBuf)) {
RPT(RPT_ERR, "too many layer_id_included_flags\n");
iRet = -1;
goto exit;
}
for (i = 1; i < ptVps->iVpsNumLayerSets; i++)
for (j = 0; j <= ptVps->iVpsMaxLayerId; j++)
getBits(pvBuf, 1); // layer_id_included_flag[i][j]
ptVps->u8VpsTimingInfoPresentFlag = getOneBit(pvBuf);
if (ptVps->u8VpsTimingInfoPresentFlag) {
ptVps->u32VpsNumUnitsInTick = getBits(pvBuf, 32);
ptVps->u32VpsTimeScale = getBits(pvBuf, 32);
ptVps->u8VpsPocProportionalToTimingFlag = getOneBit(pvBuf);
if (ptVps->u8VpsPocProportionalToTimingFlag)
ptVps->iVpsNumTicksPocDiffOne = parseUe(pvBuf) + 1;
ptVps->iVpsNumHrdParameters = parseUe(pvBuf);
if (ptVps->iVpsNumHrdParameters > (unsigned)ptVps->iVpsNumLayerSets) {
RPT(RPT_ERR,
"iVpsNumHrdParameters %d is invalid\n", ptVps->iVpsNumHrdParameters);
iRet = -1;
goto exit;
}
for (i = 0; i < ptVps->iVpsNumHrdParameters; i++) {
int common_inf_present = 1;
parseUe(pvBuf); // hrd_layer_set_idx
if (i)
common_inf_present = getOneBit(pvBuf);
decodeHrd(pvBuf, common_inf_present, ptVps->iVpsMaxSubLayers);
}
}
getOneBit(pvBuf); /* vps_extension_flag */
if (getBitsLeft(pvBuf) < 0) {
RPT(RPT_ERR,
"Overread VPS by %d bits\n", -getBitsLeft(pvBuf));
iRet = -1;
goto exit;
}
exit:
getBitContextFree(pvBuf);
return iRet;
}
void h264GetWidthHeight(T_SPS *ptSps, int *piWidth, int *piHeight) void h264GetWidthHeight(T_SPS *ptSps, int *piWidth, int *piHeight)
{ {
// ¿í¸ß¼ÆË㹫ʽ // ¿í¸ß¼ÆË㹫ʽ
...@@ -2191,28 +2265,39 @@ void h264GeFramerate(T_SPS *ptSps, float *pfFramerate) ...@@ -2191,28 +2265,39 @@ void h264GeFramerate(T_SPS *ptSps, float *pfFramerate)
void h265GetWidthHeight(T_HEVCSPS *ptSps, int *piWidth, int *piHeight) void h265GetWidthHeight(T_HEVCSPS *ptSps, int *piWidth, int *piHeight)
{ {
#if 1 #if 1
// ¿í¸ß¼ÆË㹫ʽ
int iCodeWidth = 0; int iCodeWidth = 0;
int iCodedHeight = 0; int iCodedHeight = 0;
iCodeWidth = ptSps->width; iCodeWidth = ptSps->iWidth;
iCodedHeight = ptSps->height; iCodedHeight = ptSps->iHeight;
*piWidth = ptSps->width - ptSps->pic_conf_win.left_offset - ptSps->pic_conf_win.right_offset; *piWidth = ptSps->iWidth - ptSps->tOutputWindow.uiLeftOffset - ptSps->tOutputWindow.uiRightOffset;
*piHeight = ptSps->height - ptSps->pic_conf_win.top_offset - ptSps->pic_conf_win.bottom_offset; *piHeight = ptSps->iHeight - ptSps->tOutputWindow.uiTopOffset - ptSps->tOutputWindow.uiBottomOffset;
RPT(RPT_DBG, "iCodeWidth:%d, iCodedHeight:%d\n", iCodeWidth, iCodedHeight); RPT(RPT_DBG, "iCodeWidth:%d, iCodedHeight:%d\n", iCodeWidth, iCodedHeight);
RPT(RPT_DBG, "*piWidth:%d, *piHeight:%d\n", *piWidth, *piHeight); RPT(RPT_DBG, "*piWidth:%d, *piHeight:%d\n", *piWidth, *piHeight);
// RPT(RPT_DBG, "ptSps->uiCropRight:%d, ptSps->uiCropLeft:%d\n", ptSps->uiCropRight, ptSps->uiCropLeft); RPT(RPT_DBG, "ptSps->tOutputWindow.uiRightOffset:%d, ptSps->tOutputWindow.uiLeftOffset:%d\n", ptSps->tOutputWindow.uiRightOffset, ptSps->tOutputWindow.uiLeftOffset);
// RPT(RPT_DBG, "ptSps->uiCropTop:%d, ptSps->uiCropBottom:%d\n", ptSps->uiCropTop, ptSps->uiCropBottom); RPT(RPT_DBG, "ptSps->tOutputWindow.uiTopOffset:%d, ptSps->tOutputWindow.uiBottomOffset:%d\n", ptSps->tOutputWindow.uiTopOffset, ptSps->tOutputWindow.uiBottomOffset);
#endif #endif
} }
void h265GeFramerate(T_HEVCSPS *ptSps, float *pfFramerate) void h265GeFramerate(T_HEVCVPS *ptVps, T_HEVCSPS *ptSps,float *pfFramerate)
{ {
if (ptVps && ptVps->u8VpsTimingInfoPresentFlag) {
*pfFramerate = (float)(ptVps->u32VpsTimeScale) / (float)(ptVps->u32VpsNumUnitsInTick);
} else if (ptSps && ptSps->tVui.iVuiTimingInfoPresentFlag && ptSps->iVuiPresent) {
*pfFramerate = (float)(ptSps->tVui.u32VuiTimeScale) / (float)(ptSps->tVui.u32VuiNumUnitsInTick);
}
else{
//vps sps可能不包含帧率
*pfFramerate = 0.0F;
RPT(RPT_WRN, "frame rate:0");
}
} }
src/Extension/SPSParser.h
...@@ -237,184 +237,204 @@ typedef struct T_PPS { ...@@ -237,184 +237,204 @@ typedef struct T_PPS {
typedef struct T_HEVCWindow { typedef struct T_HEVCWindow {
unsigned int left_offset; unsigned int uiLeftOffset;
unsigned int right_offset; unsigned int uiRightOffset;
unsigned int top_offset; unsigned int uiTopOffset;
unsigned int bottom_offset; unsigned int uiBottomOffset;
} T_HEVCWindow; } T_HEVCWindow;
typedef struct T_VUI { typedef struct T_VUI {
T_AVRational sar; T_AVRational tSar;
int overscan_info_present_flag; int iOverscanInfoPresentFlag;
int overscan_appropriate_flag; int iOverscanAppropriateFlag;
int video_signal_type_present_flag; int iVideoSignalTypePresentFlag;
int video_format; int iVideoFormat;
int video_full_range_flag; int iVideoFullRangeFlag;
int colour_description_present_flag; int iColourDescriptionPresentFlag;
uint8_t colour_primaries; uint8_t u8ColourPrimaries;
uint8_t transfer_characteristic; uint8_t u8TransferCharacteristic;
uint8_t matrix_coeffs; uint8_t u8MatrixCoeffs;
int chroma_loc_info_present_flag; int iChromaLocInfoPresentFlag;
int chroma_sample_loc_type_top_field; int iChromaSampleLocTypeTopField;
int chroma_sample_loc_type_bottom_field; int iChromaSampleLocTypeBottomField;
int neutra_chroma_indication_flag; int iNeutraChromaIndicationFlag;
int field_seq_flag; int iFieldSeqFlag;
int frame_field_info_present_flag; int iFrameFieldInfoPresentFlag;
int default_display_window_flag; int iDefaultDisplayWindowFlag;
T_HEVCWindow def_disp_win; T_HEVCWindow tDefDispWin;
int vui_timing_info_present_flag; int iVuiTimingInfoPresentFlag;
uint32_t vui_num_units_in_tick; uint32_t u32VuiNumUnitsInTick;
uint32_t vui_time_scale; uint32_t u32VuiTimeScale;
int vui_poc_proportional_to_timing_flag; int iVuiPocProportionalToTimingFlag;
int vui_num_ticks_poc_diff_one_minus1; int iVuiNumTicksPocDiffOneMinus1;
int vui_hrd_parameters_present_flag; int iVuiHrdParametersPresentFlag;
int bitstream_restriction_flag; int iBitstreamRestrictionFlag;
int tiles_fixed_structure_flag; int iTilesFixedStructureFlag;
int motion_vectors_over_pic_boundaries_flag; int iMotionVectorsOverPicBoundariesFlag;
int restricted_ref_pic_lists_flag; int iRestrictedRefPicListsFlag;
int min_spatial_segmentation_idc; int iMinSpatialSegmentationIdc;
int max_bytes_per_pic_denom; int iMaxBytesPerPicDenom;
int max_bits_per_min_cu_denom; int iMaxBitsPerMinCuDenom;
int log2_max_mv_length_horizontal; int iLog2MaxMvLengthHorizontal;
int log2_max_mv_length_vertical; int iLog2MaxMvLengthVertical;
} T_VUI; } T_VUI;
typedef struct T_PTLCommon { typedef struct T_PTLCommon {
uint8_t profile_space; uint8_t u8ProfileSpace;
uint8_t tier_flag; uint8_t u8TierFlag;
uint8_t profile_idc; uint8_t u8ProfileIdc;
uint8_t profile_compatibility_flag[32]; uint8_t au8ProfileCompatibilityFlag[32];
uint8_t level_idc; uint8_t u8LevelIdc;
uint8_t progressive_source_flag; uint8_t u8ProgressiveSourceFlag;
uint8_t interlaced_source_flag; uint8_t u8InterlacedSourceFlag;
uint8_t non_packed_constraint_flag; uint8_t u8NonPackedConstraintFlag;
uint8_t frame_only_constraint_flag; uint8_t u8FrameOnlyConstraintFlag;
} T_PTLCommon; } T_PTLCommon;
typedef struct T_PTL { typedef struct T_PTL {
T_PTLCommon general_ptl; T_PTLCommon tGeneralPtl;
T_PTLCommon sub_layer_ptl[HEVC_MAX_SUB_LAYERS]; T_PTLCommon atSubLayerPtl[HEVC_MAX_SUB_LAYERS];
uint8_t sub_layer_profile_present_flag[HEVC_MAX_SUB_LAYERS]; uint8_t au8SubLayerProfilePresentFlag[HEVC_MAX_SUB_LAYERS];
uint8_t sub_layer_level_present_flag[HEVC_MAX_SUB_LAYERS]; uint8_t au8SubLayerLevelPresentFlag[HEVC_MAX_SUB_LAYERS];
} T_PTL; } T_PTL;
typedef struct T_ScalingList { typedef struct T_ScalingList {
/* This is a little wasteful, since sizeID 0 only needs 8 coeffs, /* This is a little wasteful, since sizeID 0 only needs 8 coeffs,
* and size ID 3 only has 2 arrays, not 6. */ * and size ID 3 only has 2 arrays, not 6. */
uint8_t sl[4][6][64]; uint8_t aaau8Sl[4][6][64];
uint8_t sl_dc[2][6]; uint8_t aau8SlDc[2][6];
} T_ScalingList; } T_ScalingList;
typedef struct T_ShortTermRPS { typedef struct T_ShortTermRPS {
unsigned int num_negative_pics; unsigned int uiNumNegativePics;
int num_delta_pocs; int iNumDeltaPocs;
int rps_idx_num_delta_pocs; int iRpsIdxNumDeltaPocs;
int32_t delta_poc[32]; int32_t au32DeltaPoc[32];
uint8_t used[32]; uint8_t au8Used[32];
} T_ShortTermRPS; } T_ShortTermRPS;
typedef struct T_HEVCVPS {
uint8_t u8VpsTemporalIdNestingFlag;
int iVpsMaxLayers;
int iVpsMaxSubLayers; ///< vps_max_temporal_layers_minus1 + 1
T_PTL tPtl;
int iVpsSubLayerOrderingInfoPresentFlag;
unsigned int uiVpsMaxDecPicBuffering[HEVC_MAX_SUB_LAYERS];
unsigned int auiVpsNumReorderPics[HEVC_MAX_SUB_LAYERS];
unsigned int auiVpsMaxLatencyIncrease[HEVC_MAX_SUB_LAYERS];
int iVpsMaxLayerId;
int iVpsNumLayerSets; ///< vps_num_layer_sets_minus1 + 1
uint8_t u8VpsTimingInfoPresentFlag;
uint32_t u32VpsNumUnitsInTick;
uint32_t u32VpsTimeScale;
uint8_t u8VpsPocProportionalToTimingFlag;
int iVpsNumTicksPocDiffOne; ///< vps_num_ticks_poc_diff_one_minus1 + 1
int iVpsNumHrdParameters;
} T_HEVCVPS;
typedef struct T_HEVCSPS { typedef struct T_HEVCSPS {
unsigned vps_id; unsigned int uiVpsId;
int chroma_format_idc; int iChromaFormatIdc;
uint8_t separate_colour_plane_flag; uint8_t u8SeparateColourPlaneFlag;
///< output (i.e. cropped) values ///< output (i.e. cropped) values
int output_width, output_height; int iIutputWidth, iOutputHeight;
T_HEVCWindow output_window; T_HEVCWindow tOutputWindow;
T_HEVCWindow pic_conf_win; T_HEVCWindow tPicConfWin;
int bit_depth; int iBitDepth;
int bit_depth_chroma; int iBitDepthChroma;
int pixel_shift; int iPixelShift;
// enum AVPixelFormat pix_fmt;
unsigned int log2_max_poc_lsb; unsigned int uiLog2MaxPocLsb;
int pcm_enabled_flag; int iPcmEnabledFlag;
int max_sub_layers; int iMaxSubLayers;
struct { struct {
int max_dec_pic_buffering; int iMaxDecPicBuffering;
int num_reorder_pics; int iNumReorderPics;
int max_latency_increase; int iMaxLatencyIncrease;
} temporal_layer[HEVC_MAX_SUB_LAYERS]; } stTemporalLayer[HEVC_MAX_SUB_LAYERS];
uint8_t temporal_id_nesting_flag; uint8_t u8temporalIdNestingFlag;
T_VUI vui; T_VUI tVui;
T_PTL ptl; T_PTL tPtl;
uint8_t scaling_list_enable_flag; uint8_t u8ScalingListEnableFlag;
T_ScalingList scaling_list; T_ScalingList tScalingList;
unsigned int nb_st_rps; unsigned int uiNbStRps;
T_ShortTermRPS st_rps[HEVC_MAX_SHORT_TERM_RPS_COUNT]; T_ShortTermRPS atStRps[HEVC_MAX_SHORT_TERM_RPS_COUNT];
uint8_t amp_enabled_flag; uint8_t u8AmpEnabledFlag;
uint8_t sao_enabled; uint8_t u8SaoEnabled;
uint8_t long_term_ref_pics_present_flag; uint8_t u8LongTermRefPicsPresentFlag;
uint16_t lt_ref_pic_poc_lsb_sps[32]; uint16_t au16LtRefPicPocLsbSps[32];
uint8_t used_by_curr_pic_lt_sps_flag[32]; uint8_t au8UsedByCurrPicLtSpsFlag[32];
uint8_t num_long_term_ref_pics_sps; uint8_t u8NumLongTermRefPicsSps;
struct { struct {
uint8_t bit_depth; uint8_t u8BitDepth;
uint8_t bit_depth_chroma; uint8_t u8BitDepthChroma;
unsigned int log2_min_pcm_cb_size; unsigned int uiLog2MinPcmCbSize;
unsigned int log2_max_pcm_cb_size; unsigned int uiLog2MaxPcmCbSize;
uint8_t loop_filter_disable_flag; uint8_t u8LoopFilterDisableFlag;
} pcm; } pcm;
uint8_t sps_temporal_mvp_enabled_flag; uint8_t u8SpsTemporalMvpEnabledFlag;
uint8_t sps_strong_intra_smoothing_enable_flag; uint8_t u8SpsStrongIntraMmoothingEnableFlag;
unsigned int log2_min_cb_size; unsigned int uiLog2MinCbSize;
unsigned int log2_diff_max_min_coding_block_size; unsigned int uiLog2DiffMaxMinCodingBlockSize;
unsigned int log2_min_tb_size; unsigned int uiLog2MinTbSize;
unsigned int log2_max_trafo_size; unsigned int uiLog2MaxTrafoSize;
unsigned int log2_ctb_size; unsigned int uiLog2CtbSize;
unsigned int log2_min_pu_size; unsigned int uiLog2MinPuSize;
int max_transform_hierarchy_depth_inter; int iMaxTransformHierarchyDepthInter;
int max_transform_hierarchy_depth_intra; int iMaxTransformHierarchyDepthIntra;
int transform_skip_rotation_enabled_flag; int iTransformSkipRotationEnabledFlag;
int transform_skip_context_enabled_flag; int iTransformSkipContextEnabledFlag;
int implicit_rdpcm_enabled_flag; int iImplicitRdpcmEnabledFlag;
int explicit_rdpcm_enabled_flag; int iExplicitRdpcmEnabledFlag;
int intra_smoothing_disabled_flag; int iIntraSmoothingDisabledFlag;
int persistent_rice_adaptation_enabled_flag; int iHighPrecisionOffsetsEnabledFlag;
int iPersistentRiceAdaptationEnabledFlag;
///< coded frame dimension in various units ///< coded frame dimension in various units
int width; int iWidth;
int height; int iHeight;
int ctb_width; int iCtbWidth;
int ctb_height; int iCtbHeight;
int ctb_size; int iCtbSize;
int min_cb_width; int iMinCbWidth;
int min_cb_height; int iMinCbHeight;
int min_tb_width; int iMinTbWidth;
int min_tb_height; int iMinTbHeight;
int min_pu_width; int iMinPuWidth;
int min_pu_height; int iMinPuHeight;
int tb_mask; int iTbMask;
int hshift[3]; int aiHshift[3];
int vshift[3]; int aiVshift[3];
int qp_bd_offset; int iQpBdOffset;
uint8_t data[4096]; int iVuiPresent;
int data_size;
}T_HEVCSPS; }T_HEVCSPS;
...@@ -428,13 +448,15 @@ typedef struct T_GetBitContext{ ...@@ -428,13 +448,15 @@ typedef struct T_GetBitContext{
int h264DecSeqParameterSet(void *pvBuf, T_SPS *ptSps); int h264DecSeqParameterSet(void *pvBuf, T_SPS *ptSps);
int h265DecSeqParameterSet( void *pvBufSrc, T_HEVCSPS *p_sps ); int h265DecSeqParameterSet( void *pvBufSrc, T_HEVCSPS *ptSps );
int h265DecVideoParameterSet( void *pvBufSrc, T_HEVCVPS *ptVps );
void h264GetWidthHeight(T_SPS *ptSps, int *piWidth, int *piHeight); void h264GetWidthHeight(T_SPS *ptSps, int *piWidth, int *piHeight);
void h265GetWidthHeight(T_HEVCSPS *ptSps, int *piWidth, int *piHeight); void h265GetWidthHeight(T_HEVCSPS *ptSps, int *piWidth, int *piHeight);
void h264GeFramerate(T_SPS *ptSps, float *pfFramerate); void h264GeFramerate(T_SPS *ptSps, float *pfFramerate);
void h265GeFramerate(T_HEVCSPS *ptSps, float *pfFramerate); void h265GeFramerate(T_HEVCVPS *ptVps, T_HEVCSPS *ptSps,float *pfFramerate);
#if defined (__cplusplus) #if defined (__cplusplus)
} }
......
Markdown 格式
0% 或
您添加了 0 人 到此讨论。请谨慎行事。
请先完成此评论的编辑！
请 注册 或者 后发表评论